[WIP] CSS Motion Path: offset-anchor and offset-position

third_party/WebKit/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 970 matching lines @@
         case CSSPropertyWebkitMaskBoxImage:
         case CSSPropertyWebkitClipPath:
         case CSSPropertyWebkitBoxReflect:
         case CSSPropertyFilter:
         case CSSPropertyAliasWebkitFilter:
         case CSSPropertyBackdropFilter:
         case CSSPropertyZIndex:
         case CSSPropertyPosition:
         case CSSPropertyMixBlendMode:
         case CSSPropertyIsolation:
+        case CSSPropertyOffsetPath:
             return true;
         default:
             break;
         }
     }
     return false;
 }
 
 void ComputedStyle::updateIsStackingContext(bool isDocumentElement, bool isInTopLayer)
 {
@@ skipping 89 matching lines @@
     return scale() || rotate();
 }
 
 void ComputedStyle::applyTransform(TransformationMatrix& result, const LayoutSize& borderBoxSize, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath, ApplyIndependentTransformProperties applyIndependentTransformProperties) const
 {
     applyTransform(result, FloatRect(FloatPoint(), FloatSize(borderBoxSize)), applyOrigin, applyMotionPath, applyIndependentTransformProperties);
 }
 
 void ComputedStyle::applyTransform(TransformationMatrix& result, const FloatRect& boundingBox, ApplyTransformOrigin applyOrigin, ApplyMotionPath applyMotionPath, ApplyIndependentTransformProperties applyIndependentTransformProperties) const
 {
-    if (!hasMotionPath())
+    if (!hasOffsetPath())
         applyMotionPath = ExcludeMotionPath;
     bool applyTransformOrigin = requireTransformOrigin(applyOrigin, applyMotionPath);
 
     float offsetX = transformOriginX().type() == Percent ? boundingBox.x() : 0;
     float offsetY = transformOriginY().type() == Percent ? boundingBox.y() : 0;
 
     float originX = 0;
     float originY = 0;
     float originZ = 0;
 
     if (applyTransformOrigin) {
         originX = floatValueForLength(transformOriginX(), boundingBox.width()) + offsetX;
         originY = floatValueForLength(transformOriginY(), boundingBox.height()) + offsetY;
         originZ = transformOriginZ();
         result.translate3d(originX, originY, originZ);
     }
 
     if (applyIndependentTransformProperties == IncludeIndependentTransformProperties) {
         if (translate())
             translate()->apply(result, boundingBox.size());
 
         if (rotate())
             rotate()->apply(result, boundingBox.size());
 
         if (scale())
             scale()->apply(result, boundingBox.size());
     }
 
     if (applyMotionPath == ComputedStyle::IncludeMotionPath)
-        applyMotionPathTransform(originX, originY, result);
+        applyMotionPathTransform(originX, originY, boundingBox, result);
 
     const Vector<RefPtr<TransformOperation>>& transformOperations = transform().operations();
     unsigned size = transformOperations.size();
     for (unsigned i = 0; i < size; ++i)
         transformOperations[i]->apply(result, boundingBox.size());
 
     if (applyTransformOrigin) {
         result.translate3d(-originX, -originY, -originZ);
     }
 }
 
-void ComputedStyle::applyMotionPathTransform(float originX, float originY, TransformationMatrix& transform) const
+void ComputedStyle::applyMotionPathTransform(float originX, float originY, const FloatRect& boundingBox, TransformationMatrix& transform) const
 {
     const StyleMotionData& motionData = m_rareNonInheritedData->m_transform->m_motion;
     ASSERT(motionData.m_path);
     const StylePath& motionPath = *motionData.m_path;
     float pathLength = motionPath.length();
-    float distance = floatValueForLength(motionData.m_offset, pathLength);
+    float distance = floatValueForLength(motionData.m_distance, pathLength);
     float computedDistance;
     if (motionPath.isClosed() && pathLength > 0) {
         computedDistance = fmod(distance, pathLength);
         if (computedDistance < 0)
             computedDistance += pathLength;
     } else {
         computedDistance = clampTo<float>(distance, 0, pathLength);
     }
 
     FloatPoint point;
     float angle;
     motionPath.path().pointAndNormalAtLength(computedDistance, point, angle);
 
-    if (motionData.m_rotation.type == MotionRotationFixed)
+    if (motionData.m_rotation.type == OffsetRotationFixed)
         angle = 0;
 
-    transform.translate(point.x() - originX, point.y() - originY);
+    float translateX = point.x();
+    float translateY = point.y();
+    const LengthPoint& position = offsetPosition();
+    if (position.x() == Auto) {
+        translateX -= originX;
+        translateY -= originY;
+    } else {
+        translateX += floatValueForLength(position.x(), boundingBox.width()) - floatValueForLength(left(), boundingBox.width());
+        translateY += floatValueForLength(position.y(), boundingBox.height()) - floatValueForLength(top(), boundingBox.height());
+    }
+
+    const LengthPoint& anchor = offsetAnchor();
+    // TODO(ericwilligers): Consider interaction between position, anchor, rotation
+    if (anchor.x() != Auto) {
+        translateX += floatValueForLength(left(), boundingBox.width()) - boundingBox.x() - floatValueForLength(anchor.x(), boundingBox.width());
+        translateY += floatValueForLength(top(), boundingBox.height()) - boundingBox.y() - floatValueForLength(anchor.y(), boundingBox.height());
+    }
+    transform.translate(translateX, translateY);
     transform.rotate(angle + motionData.m_rotation.angle);
 }
 
 void ComputedStyle::setTextShadow(PassRefPtr<ShadowList> s)
 {
     m_rareInheritedData.access()->textShadow = s;
 }
 
 void ComputedStyle::setBoxShadow(PassRefPtr<ShadowList> s)
 {
@@ skipping 660 matching lines @@
         else
             setMarginLeft(margin);
     } else {
         if (isLeftToRightDirection())
             setMarginBottom(margin);
         else
             setMarginTop(margin);
     }
 }
 
-void ComputedStyle::setMotionPath(PassRefPtr<StylePath> path)
+void ComputedStyle::setOffsetPath(PassRefPtr<StylePath> path)
 {
     m_rareNonInheritedData.access()->m_transform.access()->m_motion.m_path = path;
 }
 
 int ComputedStyle::outlineOutsetExtent() const
 {
     if (!hasOutline())
         return 0;
     if (outlineStyleIsAuto())
         return GraphicsContext::focusRingOutsetExtent(outlineOffset(), outlineWidth());
@@ skipping 171 matching lines @@
         if (value < 0)
             fvalue -= 0.5f;
         else
             fvalue += 0.5f;
     }
 
     return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 } // namespace blink