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; }