CSS Independent Transform Properties

Source/core/style/ComputedStyle.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 864 matching lines @@
         case CSSPropertyBottom:
         case CSSPropertyRight:
             return true;
         default:
             break;
         }
     }
     return false;
 }
 
-inline bool requireTransformOrigin(const Vector<RefPtr<TransformOperation>>& transformOperations, ComputedStyle::ApplyTransformOrigin applyOrigin, ComputedStyle::ApplyMotionPath applyMotionPath)
+bool ComputedStyle::requireTransformOrigin(ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath) const
 {
+    const Vector<RefPtr<TransformOperation>>& transformOperations = rareNonInheritedData->m_transform->m_operations.operations();
+
     // transform-origin brackets the transform with translate operations.
     // Optimize for the case where the only transform is a translation, since the transform-origin is irrelevant
     // in that case.
-    if (applyOrigin != ComputedStyle::IncludeTransformOrigin)
+    if (applyOrigin != IncludeTransformOrigin)
         return false;
 
-    if (applyMotionPath == ComputedStyle::IncludeMotionPath)
+    if (applyMotionPath == IncludeMotionPath)
         return true;
 
     unsigned size = transformOperations.size();
     for (unsigned i = 0; i < size; ++i) {
         TransformOperation::OperationType type = transformOperations[i]->type();
         if (type != TransformOperation::TranslateX
             && type != TransformOperation::TranslateY
             && type != TransformOperation::Translate
             && type != TransformOperation::TranslateZ
             && type != TransformOperation::Translate3D)
             return true;
     }
 
+    if (hasScaleProperty() || hasRotateProperty())
+        return true;
+
     return false;
 }
 
-void ComputedStyle::applyTransform(TransformationMatrix& transform, const LayoutSize& borderBoxSize, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath) const
+void ComputedStyle::applyTransform(TransformationMatrix& transform, const LayoutSize& borderBoxSize, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath, ApplyTransformProperty applyTransformProperty) const
 {
-    applyTransform(transform, FloatRect(FloatPoint(), FloatSize(borderBoxSize)), applyOrigin, applyMotionPath);
+    applyTransform(transform, FloatRect(FloatPoint(), FloatSize(borderBoxSize)), applyOrigin, applyMotionPath, applyTransformProperty);
 }
 
-void ComputedStyle::applyTransform(TransformationMatrix& transform, const FloatRect& boundingBox, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath) const
+void ComputedStyle::applyTransform(TransformationMatrix& transform, const FloatRect& boundingBox, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath, ApplyTransformProperty applyTransformProperty) const
 {
     if (!hasMotionPath())
         applyMotionPath = ExcludeMotionPath;
     const Vector<RefPtr<TransformOperation>>& transformOperations = rareNonInheritedData->m_transform->m_operations.operations();
-    bool applyTransformOrigin = requireTransformOrigin(transformOperations, applyOrigin, applyMotionPath);
+    bool applyTransformOrigin = requireTransformOrigin(applyOrigin, applyMotionPath);
 
     float offsetX = transformOriginX().type() == Percent ? boundingBox.x() : 0;
     float offsetY = transformOriginY().type() == Percent ? boundingBox.y() : 0;
 
     if (applyTransformOrigin) {
         transform.translate3d(floatValueForLength(transformOriginX(), boundingBox.width()) + offsetX,
             floatValueForLength(transformOriginY(), boundingBox.height()) + offsetY,
             transformOriginZ());
     }
 
+    if (applyTransformProperty == IncludeTransformProperty) {
+        if (hasTranslateProperty()) {
+            RefPtr<TransformOperation> translateOp = translate();
+            translateOp->apply(transform, boundingBox.size());
+        }
+
+        if (hasRotateProperty()) {
+            RefPtr<TransformOperation> rotateOp = rotate();
+            rotateOp->apply(transform, boundingBox.size());
+        }
+
+        if (hasScaleProperty()) {
+            RefPtr<TransformOperation> scaleOp = scale();
+            scaleOp->apply(transform, boundingBox.size());
+        }
+    }
+
     if (applyMotionPath == ComputedStyle::IncludeMotionPath)
         applyMotionPathTransform(transform);
 
     unsigned size = transformOperations.size();
     for (unsigned i = 0; i < size; ++i)
         transformOperations[i]->apply(transform, boundingBox.size());
 
     if (applyTransformOrigin) {
         transform.translate3d(-floatValueForLength(transformOriginX(), boundingBox.width()) - offsetX,
             -floatValueForLength(transformOriginY(), boundingBox.height()) - offsetY,
@@ skipping 797 matching lines @@
 }
 
 void ComputedStyle::copyChildDependentFlagsFrom(const ComputedStyle& other)
 {
     setEmptyState(other.emptyState());
     if (other.hasExplicitlyInheritedProperties())
         setHasExplicitlyInheritedProperties();
 }
 
 } // namespace blink