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 we have an accumulated transform from last time, multiply in this transform
if (m_accumulatedTransform) {
if (m_direction == ApplyTransformDirection)
m_accumulatedTransform = adoptPtr(new TransformationMatrix(transformFromContainer * *m_accumulatedTransform));
else
m_accumulatedTransform->multiply(transformFromContainer);
} else if (accumulate == AccumulateTransform) {
// Make one if we started to accumulate
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);
}
void TransformState::move(const LayoutSize& offset, TransformAccumulation accumulate)
{
if (accumulate == FlattenTransform || !m_accumulatedTransform)
m_accumulatedOffset += offset;
else {
applyAccumulatedOffset();
if (m_accumulatingTransform && m_accumulatedTransform) {
// If we're accumulating into an existing transform, apply the translation.
translateTransform(offset);
// Then flatten if necessary.
if (accumulate == FlattenTransform)
flatten();
} else
// Just move the point and/or quad.
translateMappedCoordinates(offset);
}
m_accumulatingTransform = accumulate == AccumulateTransform;
}