[SVG2] Add support for marker orient="auto-start-reverse".

Source/core/svg/SVGAngle.cpp

 /*
  * Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) Research In Motion Limited 2010. 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 20 matching lines @@
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 template<> const SVGEnumerationStringEntries& getStaticStringEntries<SVGMarkerOrientType>()
 {
     DEFINE_STATIC_LOCAL(SVGEnumerationStringEntries, entries, ());
     if (entries.isEmpty()) {
         entries.append(std::make_pair(SVGMarkerOrientAuto, "auto"));
         entries.append(std::make_pair(SVGMarkerOrientAngle, "angle"));
+        entries.append(std::make_pair(SVGMarkerOrientAutoStartReverse, "auto-start-reverse"));
     }
     return entries;
 }
 
+template<> unsigned short getMaxExposedEnumValue<SVGMarkerOrientType>()
+{
+    return SVGMarkerOrientAngle;
+}
+
 SVGMarkerOrientEnumeration::SVGMarkerOrientEnumeration(SVGAngle* angle)
     : SVGEnumeration<SVGMarkerOrientType>(SVGMarkerOrientAngle)
     , m_angle(angle)
 {
 }
 
 SVGMarkerOrientEnumeration::~SVGMarkerOrientEnumeration()
 {
 }
 
@@ skipping 169 matching lines @@
     if (value.isEmpty()) {
         newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
         return;
     }
 
     if (value == "auto") {
         newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
         m_orientType->setEnumValue(SVGMarkerOrientAuto);
         return;
     }
+    if (value == "auto-start-reverse") {
+        newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
+        m_orientType->setEnumValue(SVGMarkerOrientAutoStartReverse);
+        return;
+    }
 
     float valueInSpecifiedUnits = 0;
     SVGAngleType unitType = SVG_ANGLETYPE_UNKNOWN;
 
     bool success = value.is8Bit() ? parseValue<LChar>(value, valueInSpecifiedUnits, unitType)
                                   : parseValue<UChar>(value, valueInSpecifiedUnits, unitType);
     if (!success) {
         exceptionState.throwDOMException(SyntaxError, "The value provided ('" + value + "') is invalid.");
         return;
     }
@@ skipping 122 matching lines @@
     bool isToAnimation = animationElement->animationMode() == ToAnimation;
 
     RefPtr<SVGAngle> fromAngle = isToAnimation ? this : toSVGAngle(from);
     RefPtr<SVGAngle> toAngle = toSVGAngle(to);
     RefPtr<SVGAngle> toAtEndOfDurationAngle = toSVGAngle(toAtEndOfDuration);
 
     SVGMarkerOrientType fromOrientType = fromAngle->orientType()->enumValue();
     SVGMarkerOrientType toOrientType = toAngle->orientType()->enumValue();
 
     if (fromOrientType != toOrientType) {
-        // Animating from eg. auto to 90deg, or auto to 90deg.
+        // Animating from eg. 90deg to auto.
         if (fromOrientType == SVGMarkerOrientAngle) {
             // Animating from an angle value to eg. 'auto' - this disabled additive as 'auto' is a keyword..
-            if (toOrientType == SVGMarkerOrientAuto) {
+            if (toOrientType == SVGMarkerOrientAuto || toOrientType == SVGMarkerOrientAutoStartReverse) {
                 if (percentage < 0.5f) {
                     newValueSpecifiedUnits(fromAngle->unitType(), fromAngle->valueInSpecifiedUnits());
                     return;
                 }
-                orientType()->setEnumValue(SVGMarkerOrientAuto);
+                orientType()->setEnumValue(toOrientType);
                 return;
             }
             m_valueInSpecifiedUnits = 0;
             orientType()->setEnumValue(SVGMarkerOrientUnknown);
             return;
+        } else if (toOrientType == SVGMarkerOrientAuto || toOrientType == SVGMarkerOrientAutoStartReverse) {
+            // Animating from e.g 'auto' to 'auto-start-reverse'
+            if (percentage >= 0.5f) {
+                m_valueInSpecifiedUnits = 0;
+                orientType()->setEnumValue(toOrientType);
+                return;
+            }
         }
     }
 
-    // From 'auto' to 'auto'.
-    if (fromOrientType == SVGMarkerOrientAuto) {
+    // From 'auto' to 'auto', or 'auto-start-reverse' to 'auto-start-reverse'
+    if (fromOrientType == SVGMarkerOrientAuto || fromOrientType == SVGMarkerOrientAutoStartReverse) {
         m_valueInSpecifiedUnits = 0;
-        orientType()->setEnumValue(SVGMarkerOrientAuto);
+        orientType()->setEnumValue(fromOrientType);
         return;
     }
 
     // If the enumeration value is not angle or auto, its unknown.
     if (fromOrientType != SVGMarkerOrientAngle) {
         m_valueInSpecifiedUnits = 0;
         orientType()->setEnumValue(SVGMarkerOrientUnknown);
         return;
     }
 
     // Regular from angle to angle animation, with all features like additive etc.
     float animatedValue = value();
     animationElement->animateAdditiveNumber(percentage, repeatCount, fromAngle->value(), toAngle->value(), toAtEndOfDurationAngle->value(), animatedValue);
     orientType()->setEnumValue(SVGMarkerOrientAngle);
     setValue(animatedValue);
 }
 
 float SVGAngle::calculateDistance(PassRefPtr<SVGPropertyBase> other, SVGElement*)
 {
     return fabsf(value() - toSVGAngle(other)->value());
 }
 
 void SVGAngle::orientTypeChanged()
 {
-    if (orientType()->enumValue() == SVGMarkerOrientAuto) {
+    if (orientType()->enumValue() == SVGMarkerOrientAuto || orientType()->enumValue() == SVGMarkerOrientAutoStartReverse) {
         m_unitType = SVG_ANGLETYPE_UNSPECIFIED;
         m_valueInSpecifiedUnits = 0;
     }
 }
 
 }