Rename Blink constants generated from IDL files.

third_party/WebKit/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 68 matching lines @@
 }
 
 float SVGMarkerOrientEnumeration::calculateDistance(SVGPropertyBase* to, SVGElement* contextElement)
 {
     // SVGMarkerOrientEnumeration is only animated via SVGAngle
     ASSERT_NOT_REACHED();
     return -1.0;
 }
 
 SVGAngle::SVGAngle()
-    : m_unitType(SVG_ANGLETYPE_UNSPECIFIED)
+    : m_unitType(kSvgAngletypeUnspecified)
     , m_valueInSpecifiedUnits(0)
     , m_orientType(SVGMarkerOrientEnumeration::create(this))
 {
 }
 
 SVGAngle::SVGAngle(SVGAngleType unitType, float valueInSpecifiedUnits, SVGMarkerOrientType orientType)
     : m_unitType(unitType)
     , m_valueInSpecifiedUnits(valueInSpecifiedUnits)
     , m_orientType(SVGMarkerOrientEnumeration::create(this))
 {
@@ skipping 11 matching lines @@
 }
 
 SVGAngle* SVGAngle::clone() const
 {
     return new SVGAngle(m_unitType, m_valueInSpecifiedUnits, m_orientType->enumValue());
 }
 
 float SVGAngle::value() const
 {
     switch (m_unitType) {
-    case SVG_ANGLETYPE_GRAD:
+    case kSvgAngletypeGrad:
         return grad2deg(m_valueInSpecifiedUnits);
-    case SVG_ANGLETYPE_RAD:
+    case kSvgAngletypeRad:
         return rad2deg(m_valueInSpecifiedUnits);
-    case SVG_ANGLETYPE_TURN:
+    case kSvgAngletypeTurn:
         return turn2deg(m_valueInSpecifiedUnits);
-    case SVG_ANGLETYPE_UNSPECIFIED:
-    case SVG_ANGLETYPE_UNKNOWN:
-    case SVG_ANGLETYPE_DEG:
+    case kSvgAngletypeUnspecified:
+    case kSvgAngletypeUnknown:
+    case kSvgAngletypeDeg:
         return m_valueInSpecifiedUnits;
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 void SVGAngle::setValue(float value)
 {
     switch (m_unitType) {
-    case SVG_ANGLETYPE_GRAD:
+    case kSvgAngletypeGrad:
         m_valueInSpecifiedUnits = deg2grad(value);
         break;
-    case SVG_ANGLETYPE_RAD:
+    case kSvgAngletypeRad:
         m_valueInSpecifiedUnits = deg2rad(value);
         break;
-    case SVG_ANGLETYPE_TURN:
+    case kSvgAngletypeTurn:
         m_valueInSpecifiedUnits = deg2turn(value);
         break;
-    case SVG_ANGLETYPE_UNSPECIFIED:
-    case SVG_ANGLETYPE_UNKNOWN:
-    case SVG_ANGLETYPE_DEG:
+    case kSvgAngletypeUnspecified:
+    case kSvgAngletypeUnknown:
+    case kSvgAngletypeDeg:
         m_valueInSpecifiedUnits = value;
         break;
     }
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
 }
 
 template<typename CharType>
 static SVGAngle::SVGAngleType stringToAngleType(const CharType*& ptr, const CharType* end)
 {
     // If there's no unit given, the angle type is unspecified.
     if (ptr == end)
-        return SVGAngle::SVG_ANGLETYPE_UNSPECIFIED;
+        return SVGAngle::kSvgAngletypeUnspecified;
 
-    SVGAngle::SVGAngleType type = SVGAngle::SVG_ANGLETYPE_UNKNOWN;
+    SVGAngle::SVGAngleType type = SVGAngle::kSvgAngletypeUnknown;
     if (isHTMLSpace<CharType>(ptr[0])) {
-        type = SVGAngle::SVG_ANGLETYPE_UNSPECIFIED;
+        type = SVGAngle::kSvgAngletypeUnspecified;
         ptr++;
     } else if (end - ptr >= 3) {
         if (ptr[0] == 'd' && ptr[1] == 'e' && ptr[2] == 'g') {
-            type = SVGAngle::SVG_ANGLETYPE_DEG;
+            type = SVGAngle::kSvgAngletypeDeg;
             ptr += 3;
         } else if (ptr[0] == 'r' && ptr[1] == 'a' && ptr[2] == 'd') {
-            type = SVGAngle::SVG_ANGLETYPE_RAD;
+            type = SVGAngle::kSvgAngletypeRad;
             ptr += 3;
         } else if (end - ptr >= 4) {
             if (ptr[0] == 'g' && ptr[1] == 'r' && ptr[2] == 'a' && ptr[3] == 'd') {
-                type = SVGAngle::SVG_ANGLETYPE_GRAD;
+                type = SVGAngle::kSvgAngletypeGrad;
                 ptr += 4;
             } else if (ptr[0] == 't' && ptr[1] == 'u' && ptr[2] == 'r' && ptr[3] == 'n') {
-                type = SVGAngle::SVG_ANGLETYPE_TURN;
+                type = SVGAngle::kSvgAngletypeTurn;
                 ptr += 4;
             }
         }
     }
 
     if (!skipOptionalSVGSpaces(ptr, end))
         return type;
 
-    return SVGAngle::SVG_ANGLETYPE_UNKNOWN;
+    return SVGAngle::kSvgAngletypeUnknown;
 }
 
 String SVGAngle::valueAsString() const
 {
     switch (m_unitType) {
-    case SVG_ANGLETYPE_DEG: {
+    case kSvgAngletypeDeg: {
         DEFINE_STATIC_LOCAL(String, degString, ("deg"));
         return String::number(m_valueInSpecifiedUnits) + degString;
     }
-    case SVG_ANGLETYPE_RAD: {
+    case kSvgAngletypeRad: {
         DEFINE_STATIC_LOCAL(String, radString, ("rad"));
         return String::number(m_valueInSpecifiedUnits) + radString;
     }
-    case SVG_ANGLETYPE_GRAD: {
+    case kSvgAngletypeGrad: {
         DEFINE_STATIC_LOCAL(String, gradString, ("grad"));
         return String::number(m_valueInSpecifiedUnits) + gradString;
     }
-    case SVG_ANGLETYPE_TURN: {
+    case kSvgAngletypeTurn: {
         DEFINE_STATIC_LOCAL(String, turnString, ("turn"));
         return String::number(m_valueInSpecifiedUnits) + turnString;
     }
-    case SVG_ANGLETYPE_UNSPECIFIED:
-    case SVG_ANGLETYPE_UNKNOWN:
+    case kSvgAngletypeUnspecified:
+    case kSvgAngletypeUnknown:
         return String::number(m_valueInSpecifiedUnits);
     }
 
     ASSERT_NOT_REACHED();
     return String();
 }
 
 template<typename CharType>
 static SVGParsingError parseValue(const String& value, float& valueInSpecifiedUnits, SVGAngle::SVGAngleType& unitType)
 {
     const CharType* ptr = value.getCharacters<CharType>();
     const CharType* end = ptr + value.length();
 
     if (!parseNumber(ptr, end, valueInSpecifiedUnits, AllowLeadingWhitespace))
         return SVGParsingError(SVGParseStatus::ExpectedAngle, ptr - value.getCharacters<CharType>());
 
     unitType = stringToAngleType(ptr, end);
-    if (unitType == SVGAngle::SVG_ANGLETYPE_UNKNOWN)
+    if (unitType == SVGAngle::kSvgAngletypeUnknown)
         return SVGParsingError(SVGParseStatus::ExpectedAngle, ptr - value.getCharacters<CharType>());
 
     return SVGParseStatus::NoError;
 }
 
 SVGParsingError SVGAngle::setValueAsString(const String& value)
 {
     if (value.isEmpty()) {
-        newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
+        newValueSpecifiedUnits(kSvgAngletypeUnspecified, 0);
         return SVGParseStatus::NoError;
     }
 
     if (value == "auto") {
-        newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
+        newValueSpecifiedUnits(kSvgAngletypeUnspecified, 0);
         m_orientType->setEnumValue(SVGMarkerOrientAuto);
         return SVGParseStatus::NoError;
     }
     if (value == "auto-start-reverse") {
-        newValueSpecifiedUnits(SVG_ANGLETYPE_UNSPECIFIED, 0);
+        newValueSpecifiedUnits(kSvgAngletypeUnspecified, 0);
         m_orientType->setEnumValue(SVGMarkerOrientAutoStartReverse);
         return SVGParseStatus::NoError;
     }
 
     float valueInSpecifiedUnits = 0;
-    SVGAngleType unitType = SVG_ANGLETYPE_UNKNOWN;
+    SVGAngleType unitType = kSvgAngletypeUnknown;
 
     SVGParsingError error;
     if (value.is8Bit())
         error = parseValue<LChar>(value, valueInSpecifiedUnits, unitType);
     else
         error = parseValue<UChar>(value, valueInSpecifiedUnits, unitType);
     if (error != SVGParseStatus::NoError)
         return error;
 
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
     m_unitType = unitType;
     m_valueInSpecifiedUnits = valueInSpecifiedUnits;
     return SVGParseStatus::NoError;
 }
 
 void SVGAngle::newValueSpecifiedUnits(SVGAngleType unitType, float valueInSpecifiedUnits)
 {
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
     m_unitType = unitType;
     m_valueInSpecifiedUnits = valueInSpecifiedUnits;
 }
 
 void SVGAngle::convertToSpecifiedUnits(SVGAngleType unitType)
 {
     if (unitType == m_unitType)
         return;
 
     switch (m_unitType) {
-    case SVG_ANGLETYPE_TURN:
+    case kSvgAngletypeTurn:
         switch (unitType) {
-        case SVG_ANGLETYPE_GRAD:
+        case kSvgAngletypeGrad:
             m_valueInSpecifiedUnits = turn2grad(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_UNSPECIFIED:
-        case SVG_ANGLETYPE_DEG:
+        case kSvgAngletypeUnspecified:
+        case kSvgAngletypeDeg:
             m_valueInSpecifiedUnits = turn2deg(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_RAD:
+        case kSvgAngletypeRad:
             m_valueInSpecifiedUnits = deg2rad(turn2deg(m_valueInSpecifiedUnits));
             break;
-        case SVG_ANGLETYPE_TURN:
-        case SVG_ANGLETYPE_UNKNOWN:
+        case kSvgAngletypeTurn:
+        case kSvgAngletypeUnknown:
             ASSERT_NOT_REACHED();
             break;
         }
         break;
-    case SVG_ANGLETYPE_RAD:
+    case kSvgAngletypeRad:
         switch (unitType) {
-        case SVG_ANGLETYPE_GRAD:
+        case kSvgAngletypeGrad:
             m_valueInSpecifiedUnits = rad2grad(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_UNSPECIFIED:
-        case SVG_ANGLETYPE_DEG:
+        case kSvgAngletypeUnspecified:
+        case kSvgAngletypeDeg:
             m_valueInSpecifiedUnits = rad2deg(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_TURN:
+        case kSvgAngletypeTurn:
             m_valueInSpecifiedUnits = deg2turn(rad2deg(m_valueInSpecifiedUnits));
             break;
-        case SVG_ANGLETYPE_RAD:
-        case SVG_ANGLETYPE_UNKNOWN:
+        case kSvgAngletypeRad:
+        case kSvgAngletypeUnknown:
             ASSERT_NOT_REACHED();
             break;
         }
         break;
-    case SVG_ANGLETYPE_GRAD:
+    case kSvgAngletypeGrad:
         switch (unitType) {
-        case SVG_ANGLETYPE_RAD:
+        case kSvgAngletypeRad:
             m_valueInSpecifiedUnits = grad2rad(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_UNSPECIFIED:
-        case SVG_ANGLETYPE_DEG:
+        case kSvgAngletypeUnspecified:
+        case kSvgAngletypeDeg:
             m_valueInSpecifiedUnits = grad2deg(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_TURN:
+        case kSvgAngletypeTurn:
             m_valueInSpecifiedUnits = grad2turn(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_GRAD:
-        case SVG_ANGLETYPE_UNKNOWN:
+        case kSvgAngletypeGrad:
+        case kSvgAngletypeUnknown:
             ASSERT_NOT_REACHED();
             break;
         }
         break;
-    case SVG_ANGLETYPE_UNSPECIFIED:
+    case kSvgAngletypeUnspecified:
         // Spec: For angles, a unitless value is treated the same as if degrees were specified.
-    case SVG_ANGLETYPE_DEG:
+    case kSvgAngletypeDeg:
         switch (unitType) {
-        case SVG_ANGLETYPE_RAD:
+        case kSvgAngletypeRad:
             m_valueInSpecifiedUnits = deg2rad(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_GRAD:
+        case kSvgAngletypeGrad:
             m_valueInSpecifiedUnits = deg2grad(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_TURN:
+        case kSvgAngletypeTurn:
             m_valueInSpecifiedUnits = deg2turn(m_valueInSpecifiedUnits);
             break;
-        case SVG_ANGLETYPE_UNSPECIFIED:
-        case SVG_ANGLETYPE_DEG:
+        case kSvgAngletypeUnspecified:
+        case kSvgAngletypeDeg:
             break;
-        case SVG_ANGLETYPE_UNKNOWN:
+        case kSvgAngletypeUnknown:
             ASSERT_NOT_REACHED();
             break;
         }
         break;
-    case SVG_ANGLETYPE_UNKNOWN:
+    case kSvgAngletypeUnknown:
         ASSERT_NOT_REACHED();
         break;
     }
 
     m_unitType = unitType;
     m_orientType->setEnumValue(SVGMarkerOrientAngle);
 }
 
 void SVGAngle::add(SVGPropertyBase* other, SVGElement*)
 {
@@ skipping 59 matching lines @@
 }
 
 float SVGAngle::calculateDistance(SVGPropertyBase* other, SVGElement*)
 {
     return fabsf(value() - toSVGAngle(other)->value());
 }
 
 void SVGAngle::orientTypeChanged()
 {
     if (orientType()->enumValue() == SVGMarkerOrientAuto || orientType()->enumValue() == SVGMarkerOrientAutoStartReverse) {
-        m_unitType = SVG_ANGLETYPE_UNSPECIFIED;
+        m_unitType = kSvgAngletypeUnspecified;
         m_valueInSpecifiedUnits = 0;
     }
 }
 
 } // namespace blink