This source file includes following definitions.
- translateTransform
- translateMappedCoordinates
- move
- applyAccumulatedOffset
- applyTransform
- applyTransform
- flatten
- mappedPoint
- mappedQuad
- flattenWithTransform
#include "config.h"
#include "platform/geometry/TransformState.h"
#include "wtf/PassOwnPtr.h"
namespace WebCore {
TransformState& TransformState::operator=(const TransformState& other)
{
m_accumulatedOffset = other.m_accumulatedOffset;
m_mapPoint = other.m_mapPoint;
m_mapQuad = other.m_mapQuad;
if (m_mapPoint)
m_lastPlanarPoint = other.m_lastPlanarPoint;
if (m_mapQuad)
m_lastPlanarQuad = other.m_lastPlanarQuad;
m_accumulatingTransform = other.m_accumulatingTransform;
m_direction = other.m_direction;
m_accumulatedTransform.clear();
if (other.m_accumulatedTransform)
m_accumulatedTransform = adoptPtr(new TransformationMatrix(*other.m_accumulatedTransform));
return *this;
}
void TransformState::translateTransform(const LayoutSize& offset)
{
if (m_direction == ApplyTransformDirection)
m_accumulatedTransform->translateRight(offset.width().toDouble(), offset.height().toDouble());
else
m_accumulatedTransform->translate(offset.width().toDouble(), offset.height().toDouble());
}
void TransformState::translateMappedCoordinates(const LayoutSize& offset)
{
LayoutSize adjustedOffset = (m_direction == ApplyTransformDirection) ? offset : -offset;
if (m_mapPoint)
m_lastPlanarPoint.move(adjustedOffset);
if (m_mapQuad)
m_lastPlanarQuad.move(adjustedOffset);
}
void TransformState::move(const LayoutSize& offset, TransformAccumulation accumulate)
{
if (accumulate == FlattenTransform || !m_accumulatedTransform) {
m_accumulatedOffset += offset;
} else {
applyAccumulatedOffset();
if (m_accumulatingTransform && m_accumulatedTransform) {
translateTransform(offset);
if (accumulate == FlattenTransform)
flatten();
} else {
translateMappedCoordinates(offset);
}
}
m_accumulatingTransform = accumulate == AccumulateTransform;
}
void TransformState::applyAccumulatedOffset()
{
LayoutSize offset = m_accumulatedOffset;
m_accumulatedOffset = LayoutSize();
if (!offset.isZero()) {
if (m_accumulatedTransform) {
translateTransform(offset);
flatten();
} else {
translateMappedCoordinates(offset);
}
}
}
void TransformState::applyTransform(const AffineTransform& transformFromContainer, TransformAccumulation accumulate, bool* wasClamped)
{
applyTransform(transformFromContainer.toTransformationMatrix(), accumulate, wasClamped);
}
void TransformState::applyTransform(const TransformationMatrix& transformFromContainer, TransformAccumulation accumulate, bool* wasClamped)
{
if (wasClamped)
*wasClamped = false;
if (transformFromContainer.isIntegerTranslation()) {
move(LayoutSize(transformFromContainer.e(), transformFromContainer.f()), accumulate);
return;
}
applyAccumulatedOffset();
if (m_accumulatedTransform) {
if (m_direction == ApplyTransformDirection)
m_accumulatedTransform = adoptPtr(new TransformationMatrix(transformFromContainer * *m_accumulatedTransform));
else
m_accumulatedTransform->multiply(transformFromContainer);
} else if (accumulate == AccumulateTransform) {
m_accumulatedTransform = adoptPtr(new TransformationMatrix(transformFromContainer));
}
if (accumulate == FlattenTransform) {
const TransformationMatrix* finalTransform = m_accumulatedTransform ? m_accumulatedTransform.get() : &transformFromContainer;
flattenWithTransform(*finalTransform, wasClamped);
}
m_accumulatingTransform = accumulate == AccumulateTransform;
}
void TransformState::flatten(bool* wasClamped)
{
if (wasClamped)
*wasClamped = false;
applyAccumulatedOffset();
if (!m_accumulatedTransform) {
m_accumulatingTransform = false;
return;
}
flattenWithTransform(*m_accumulatedTransform, wasClamped);
}
FloatPoint TransformState::mappedPoint(bool* wasClamped) const
{
if (wasClamped)
*wasClamped = false;
FloatPoint point = m_lastPlanarPoint;
point.move((m_direction == ApplyTransformDirection) ? m_accumulatedOffset : -m_accumulatedOffset);
if (!m_accumulatedTransform)
return point;
if (m_direction == ApplyTransformDirection)
return m_accumulatedTransform->mapPoint(point);
return m_accumulatedTransform->inverse().projectPoint(point, wasClamped);
}
FloatQuad TransformState::mappedQuad(bool* wasClamped) const
{
if (wasClamped)
*wasClamped = false;
FloatQuad quad = m_lastPlanarQuad;
quad.move((m_direction == ApplyTransformDirection) ? m_accumulatedOffset : -m_accumulatedOffset);
if (!m_accumulatedTransform)
return quad;
if (m_direction == ApplyTransformDirection)
return m_accumulatedTransform->mapQuad(quad);
return m_accumulatedTransform->inverse().projectQuad(quad, wasClamped);
}
void TransformState::flattenWithTransform(const TransformationMatrix& t, bool* wasClamped)
{
if (m_direction == ApplyTransformDirection) {
if (m_mapPoint)
m_lastPlanarPoint = t.mapPoint(m_lastPlanarPoint);
if (m_mapQuad)
m_lastPlanarQuad = t.mapQuad(m_lastPlanarQuad);
} else {
TransformationMatrix inverseTransform = t.inverse();
if (m_mapPoint)
m_lastPlanarPoint = inverseTransform.projectPoint(m_lastPlanarPoint);
if (m_mapQuad)
m_lastPlanarQuad = inverseTransform.projectQuad(m_lastPlanarQuad, wasClamped);
}
if (m_accumulatedTransform)
m_accumulatedTransform->makeIdentity();
m_accumulatingTransform = false;
}
}