Changeset 84609 in webkit

Timestamp:

Apr 22, 2011 12:40:32 AM (13 years ago)

Author:

commit-queue@webkit.org

Message:

2011-04-22 Luke Macpherson <​macpherson@chromium.org>

Reviewed by Eric Seidel.

Add FontItalics and FontSmallCaps enums to be used instead of boolean values.
​https://bugs.webkit.org/show_bug.cgi?id=59080

No new tests as no new functionality added.

• css/CSSPrimitiveValueMappings.h: Add casts to/from FontItalics and FontSmallCaps
• css/CSSStyleSelector.cpp: Use new casts defined in PrimitiveValueMappings.h
• platform/graphics/Font.h: Use FontItalics enum.
• platform/graphics/FontDescription.h: Define and use FontItalics and FontSmallCaps enums.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSPrimitiveValueMappings.h (modified) (2 diffs)
• css/CSSStyleSelector.cpp (modified) (2 diffs)
• platform/graphics/Font.h (modified) (1 diff)
• platform/graphics/FontDescription.h (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-04-22  Luke Macpherson   <macpherson@chromium.org>
+
+        Reviewed by Eric Seidel.
+
+        Add FontItalics and FontSmallCaps enums to be used instead of boolean values.
+        https://bugs.webkit.org/show_bug.cgi?id=59080
+
+        No new tests as no new functionality added.
+
+        * css/CSSPrimitiveValueMappings.h:
+        Add casts to/from FontItalics and FontSmallCaps
+        * css/CSSStyleSelector.cpp:
+        Use new casts defined in PrimitiveValueMappings.h
+        * platform/graphics/Font.h:
+        Use FontItalics enum.
+        * platform/graphics/FontDescription.h:
+        Define and use FontItalics and FontSmallCaps enums.
+
 2011-04-21  Andrey Kosyakov  <caseq@chromium.org>
 

trunk/Source/WebCore/css/CSSPrimitiveValueMappings.h

@@ -34 +34 @@
 #include "CSSPrimitiveValue.h"
 #include "CSSValueKeywords.h"
+#include "FontDescription.h"
 #include "FontSmoothingMode.h"
 #include "GraphicsTypes.h"
@@ -2324 +2325 @@
 }
 
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
+    : m_type(CSS_IDENT)
+    , m_hasCachedCSSText(false)
+{
+    switch (italic) {
+    case FontItalicOff:
+        m_value.ident = CSSValueNormal;
+        return;
+    case FontItalicOn:
+        m_value.ident = CSSValueItalic;
+        return;
+    }
+
+    ASSERT_NOT_REACHED();
+    m_value.ident = CSSValueNormal;
+}
+
+template<> inline CSSPrimitiveValue::operator FontItalic() const
+{
+    switch (m_value.ident) {
+    case CSSValueOblique:
+    // FIXME: oblique is the same as italic for the moment...
+    case CSSValueItalic:
+        return FontItalicOn;
+    case CSSValueNormal:
+        return FontItalicOff;
+    }
+    ASSERT_NOT_REACHED();
+    return FontItalicOff;
+}
+
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
+    : m_type(CSS_IDENT)
+    , m_hasCachedCSSText(false)
+{
+    switch (smallCaps) {
+    case FontSmallCapsOff:
+        m_value.ident = CSSValueNormal;
+        return;
+    case FontSmallCapsOn:
+        m_value.ident = CSSValueSmallCaps;
+        return;
+    }
+
+    ASSERT_NOT_REACHED();
+    m_value.ident = CSSValueNormal;
+}
+
+template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
+{
+    switch (m_value.ident) {
+    case CSSValueSmallCaps:
+        return FontSmallCapsOn;
+    case CSSValueNormal:
+        return FontSmallCapsOff;
+    }
+    ASSERT_NOT_REACHED();
+    return FontSmallCapsOff;
+}
+
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
     : m_type(CSS_IDENT)

trunk/Source/WebCore/css/CSSStyleSelector.cpp

@@ -3677 +3677 @@
             fontDescription.setItalic(m_parentStyle->fontDescription().italic());
         else if (isInitial)
-            fontDescription.setItalic(false);
+            fontDescription.setItalic(FontItalicOff);
         else {
             if (!primitiveValue)
                 return;
-            switch (primitiveValue->getIdent()) {
-                case CSSValueOblique:
-                // FIXME: oblique is the same as italic for the moment...
-                case CSSValueItalic:
-                    fontDescription.setItalic(true);
-                    break;
-                case CSSValueNormal:
-                    fontDescription.setItalic(false);
-                    break;
-                default:
-                    return;
-            }
+            fontDescription.setItalic((FontItalic)*primitiveValue);
         }
         if (m_style->setFontDescription(fontDescription))
@@ -3705 +3694 @@
             fontDescription.setSmallCaps(m_parentStyle->fontDescription().smallCaps());
         else if (isInitial)
-            fontDescription.setSmallCaps(false);
+            fontDescription.setSmallCaps(FontSmallCapsOff);
         else {
             if (!primitiveValue)
                 return;
-            int id = primitiveValue->getIdent();
-            if (id == CSSValueNormal)
-                fontDescription.setSmallCaps(false);
-            else if (id == CSSValueSmallCaps)
-                fontDescription.setSmallCaps(true);
-            else
-                return;
+            fontDescription.setSmallCaps((FontSmallCaps)*primitiveValue);
         }
         if (m_style->setFontDescription(fontDescription))

trunk/Source/WebCore/platform/graphics/Font.h

@@ -124 +124 @@
     const FontFamily& family() const { return m_fontDescription.family(); }
 
-    bool italic() const { return m_fontDescription.italic(); }
+    FontItalic italic() const { return m_fontDescription.italic(); }
     FontWeight weight() const { return m_fontDescription.weight(); }
     FontWidthVariant widthVariant() const { return m_fontDescription.widthVariant(); }

trunk/Source/WebCore/platform/graphics/FontDescription.h

@@ -51 +51 @@
 };
 
+enum FontItalic {
+    FontItalicOff = 0,
+    FontItalicOn = 1
+};
+
+enum FontSmallCaps {
+    FontSmallCapsOff = 0,
+    FontSmallCapsOn = 1
+};
+
 class FontDescription {
 public:
@@ -62 +72 @@
         , m_textOrientation(TextOrientationVerticalRight)
         , m_widthVariant(RegularWidth)
-        , m_italic(false)
-        , m_smallCaps(false)
+        , m_italic(FontItalicOff)
+        , m_smallCaps(FontSmallCapsOff)
         , m_isAbsoluteSize(false)
         , m_weight(FontWeightNormal)
@@ -83 +93 @@
     float specifiedSize() const { return m_specifiedSize; }
     float computedSize() const { return m_computedSize; }
-    bool italic() const { return m_italic; }
+    FontItalic italic() const { return static_cast<FontItalic>(m_italic); }
     int computedPixelSize() const { return int(m_computedSize + 0.5f); }
-    bool smallCaps() const { return m_smallCaps; }
+    FontSmallCaps smallCaps() const { return static_cast<FontSmallCaps>(m_smallCaps); }
     bool isAbsoluteSize() const { return m_isAbsoluteSize; }
     FontWeight weight() const { return static_cast<FontWeight>(m_weight); }
@@ -108 +118 @@
     void setComputedSize(float s) { m_computedSize = s; }
     void setSpecifiedSize(float s) { m_specifiedSize = s; }
-    void setItalic(bool i) { m_italic = i; }
-    void setSmallCaps(bool c) { m_smallCaps = c; }
+    void setItalic(FontItalic i) { m_italic = i; }
+    void setItalic(bool i) { setItalic(i ? FontItalicOn : FontItalicOff); }
+    void setSmallCaps(FontSmallCaps c) { m_smallCaps = c; }
+    void setSmallCaps(bool c) { setSmallCaps(c ? FontSmallCapsOn : FontSmallCapsOff); }
     void setIsAbsoluteSize(bool s) { m_isAbsoluteSize = s; }
     void setWeight(FontWeight w) { m_weight = w; }
@@ -139 +151 @@
     FontWidthVariant m_widthVariant;
 
-    bool m_italic : 1;
-    bool m_smallCaps : 1;
+    unsigned m_italic : 1; // FontItalic
+    unsigned m_smallCaps : 1; // FontSmallCaps
     bool m_isAbsoluteSize : 1;   // Whether or not CSS specified an explicit size
                                  // (logical sizes like "medium" don't count).