TransformState.cpp [plain text]
#include "config.h"
#include "TransformState.h"
#include <wtf/PassOwnPtr.h>
namespace WebCore {
TransformState& TransformState::operator=(const TransformState& other)
{
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::move(LayoutUnit x, LayoutUnit y, TransformAccumulation accumulate)
{
if (m_accumulatingTransform && m_accumulatedTransform) {
if (m_direction == ApplyTransformDirection)
m_accumulatedTransform->translateRight(x, y);
else
m_accumulatedTransform->translate(x, y);
if (accumulate == FlattenTransform)
flatten();
} else {
if (m_direction == UnapplyInverseTransformDirection) {
x = -x;
y = -y;
}
if (m_mapPoint)
m_lastPlanarPoint.move(x, y);
if (m_mapQuad)
m_lastPlanarQuad.move(x, y);
}
m_accumulatingTransform = accumulate == AccumulateTransform;
}
void TransformState::applyTransform(const AffineTransform& transformFromContainer, TransformAccumulation accumulate)
{
applyTransform(transformFromContainer.toTransformationMatrix(), accumulate);
}
void TransformState::applyTransform(const TransformationMatrix& transformFromContainer, TransformAccumulation accumulate)
{
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);
}
m_accumulatingTransform = accumulate == AccumulateTransform;
}
void TransformState::flatten()
{
if (!m_accumulatedTransform) {
m_accumulatingTransform = false;
return;
}
flattenWithTransform(*m_accumulatedTransform);
}
FloatPoint TransformState::mappedPoint() const
{
if (!m_accumulatedTransform)
return m_lastPlanarPoint;
if (m_direction == ApplyTransformDirection)
return m_accumulatedTransform->mapPoint(m_lastPlanarPoint);
return m_accumulatedTransform->inverse().projectPoint(m_lastPlanarPoint);
}
FloatQuad TransformState::mappedQuad() const
{
if (!m_accumulatedTransform)
return m_lastPlanarQuad;
if (m_direction == ApplyTransformDirection)
return m_accumulatedTransform->mapQuad(m_lastPlanarQuad);
return m_accumulatedTransform->inverse().projectQuad(m_lastPlanarQuad);
}
void TransformState::flattenWithTransform(const TransformationMatrix& t)
{
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);
}
if (m_accumulatedTransform)
m_accumulatedTransform->makeIdentity();
m_accumulatingTransform = false;
}
}