Rename isSpace to treatAsSpace. Move it and the rounding hack function into
authorhyatt <hyatt@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 10 May 2006 21:08:31 +0000 (21:08 +0000)
committerhyatt <hyatt@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 10 May 2006 21:08:31 +0000 (21:08 +0000)
        Font and make them static methods (inlined in the header).  Make the rounding
        hack character table a static member as well.  Remove the redundant space/rounding
        functions from FontData.mm.

        Reviewed by darin

        * platform/Font.cpp:
        (WebCore::):
        (WebCore::m_finalRoundingWidth):
        (WebCore::WidthIterator::advance):
        * platform/Font.h:
        (WebCore::Font::treatAsSpace):
        (WebCore::Font::isRoundingHackCharacter):
        * platform/mac/FontData.mm:
        (WebCore::overrideLayoutOperation):
        (WebCore::createATSULayoutParameters):
        (WebCore::initializeWidthIterator):
        (WebCore::advanceWidthIterator):
        * platform/mac/FontMac.mm:
        (WebCore::overrideLayoutOperation):
        (WebCore::ATSULayoutParameters::initialize):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@14292 268f45cc-cd09-0410-ab3c-d52691b4dbfc

WebCore/ChangeLog
WebCore/platform/Font.cpp
WebCore/platform/Font.h
WebCore/platform/mac/FontData.mm
WebCore/platform/mac/FontMac.mm

index d43aa9281264ffa4d60e2b6152c6b4070bce7451..98c0f7c2ba3aa11890b179e139b79d1cad88f085 100644 (file)
@@ -1,3 +1,28 @@
+2006-05-10  David Hyatt  <hyatt@apple.com>
+
+        Rename isSpace to treatAsSpace.  Move it and the rounding hack function into
+        Font and make them static methods (inlined in the header).  Make the rounding
+        hack character table a static member as well.  Remove the redundant space/rounding
+        functions from FontData.mm.
+
+        Reviewed by darin
+
+        * platform/Font.cpp:
+        (WebCore::):
+        (WebCore::m_finalRoundingWidth):
+        (WebCore::WidthIterator::advance):
+        * platform/Font.h:
+        (WebCore::Font::treatAsSpace):
+        (WebCore::Font::isRoundingHackCharacter):
+        * platform/mac/FontData.mm:
+        (WebCore::overrideLayoutOperation):
+        (WebCore::createATSULayoutParameters):
+        (WebCore::initializeWidthIterator):
+        (WebCore::advanceWidthIterator):
+        * platform/mac/FontMac.mm:
+        (WebCore::overrideLayoutOperation):
+        (WebCore::ATSULayoutParameters::initialize):
+
 2006-05-10  Darin Adler  <darin@apple.com>
 
         * WebCore: Removed an extra WebCore subtree that somehow got checked in.
index 243b133b4becd62b1651d3471daadade488d54e2..9d4caedfd3508b62a8f869e5bd5f62ce196f3584 100644 (file)
@@ -40,18 +40,11 @@ namespace WebCore {
 #if __APPLE__
 
 // FIXME: Cross-platform eventually, but for now we compile only on OS X.
-#define SPACE 0x0020
-#define NO_BREAK_SPACE 0x00A0
 
 // According to http://www.unicode.org/Public/UNIDATA/UCD.html#Canonical_Combining_Class_Values
 #define HIRAGANA_KATAKANA_VOICING_MARKS 8
 
-bool isSpace(unsigned c)
-{
-    return c == SPACE || c == '\t' || c == '\n' || c == NO_BREAK_SPACE;
-}
-
-static const uint8_t isRoundingHackCharacterTable[0x100] = {
+const uint8_t Font::gRoundingHackCharacterTable[256] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*\t*/, 1 /*\n*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1 /*space*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*-*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*?*/,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -62,11 +55,6 @@ static const uint8_t isRoundingHackCharacterTable[0x100] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 
-bool isRoundingHackCharacter(UChar32 c)
-{
-    return (((c & ~0xFF) == 0 && isRoundingHackCharacterTable[c]));
-}
-
 struct WidthIterator {
     WidthIterator(const Font* font, const UChar* str, int from, int to, int len,
                   int tabWidth, int xpos, int toAdd, TextDirection dir, bool visuallyOrdered,
@@ -116,7 +104,7 @@ WidthIterator::WidthIterator(const Font* font, const UChar* str, int from, int t
     } else {
         float numSpaces = 0;
         for (int i = from; i < to; i++)
-            if (isSpace(m_characters[i]))
+            if (Font::treatAsSpace(m_characters[i]))
                 numSpaces++;
 
         m_padding = toAdd;
@@ -239,7 +227,7 @@ void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
             if (width && m_font->letterSpacing())
                 width += m_font->letterSpacing();
 
-            if (isSpace(c)) {
+            if (Font::treatAsSpace(c)) {
                 // Account for padding. WebCore uses space padding to justify text.
                 // We distribute the specified padding over the available spaces in the run.
                 if (m_padding) {
@@ -255,7 +243,7 @@ void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
 
                 // Account for word spacing.
                 // We apply additional space between "words" by adding width to the space character.
-                if (currentCharacter != 0 && !isSpace(cp[-1]) && m_font->wordSpacing())
+                if (currentCharacter != 0 && !Font::treatAsSpace(cp[-1]) && m_font->wordSpacing())
                     width += m_font->wordSpacing();
             }
         }
@@ -273,12 +261,12 @@ void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
 
         // Force characters that are used to determine word boundaries for the rounding hack
         // to be integer width, so following words will start on an integer boundary.
-        if (m_applyWordRounding && isRoundingHackCharacter(c))
+        if (m_applyWordRounding && Font::isRoundingHackCharacter(c))
             width = ceilf(width);
 
         // Check to see if the next character is a "rounding hack character", if so, adjust
         // width so that the total run width will be on an integer boundary.
-        if ((m_applyWordRounding && currentCharacter < m_len && isRoundingHackCharacter(*cp))
+        if ((m_applyWordRounding && currentCharacter < m_len && Font::isRoundingHackCharacter(*cp))
                 || (m_applyRunRounding && currentCharacter >= m_to)) {
             float totalWidth = m_widthToStart + runWidthSoFar + width;
             width += ceilf(totalWidth) - totalWidth;
index 5fa26edf176e076005c836db40cd0cfbb9a41316..53c7a59fd2ca4032d362224903f54554c7e06244 100644 (file)
@@ -152,6 +152,13 @@ private:
 public:
     static void setAlwaysUseComplexPath(bool);
     static bool gAlwaysUseComplexPath;
+    
+    static const uint8_t gRoundingHackCharacterTable[256];
+    static bool treatAsSpace(UChar c) { return c == ' ' || c == '\t' || c == '\n' || c == 0x00A0; }
+    static bool isRoundingHackCharacter(UChar32 c)
+    {
+        return (((c & ~0xFF) == 0 && gRoundingHackCharacterTable[c])); 
+    }
 #endif
 
 private:
@@ -161,11 +168,6 @@ private:
     short m_wordSpacing;
 };
 
-#if __APPLE__
-    // FIXME: This will eventually be cross-platform, but we want to keep Windows compiling for now.
-    bool isSpace(unsigned c);
-    bool isRoundingHackCharacter(UChar c);
-#endif
 }
 
 #endif
index 44e33a4b42784774029e3b70c64cbc1d9d666e7a..811e87c40e14efe74e831b042cf8ae1a45a6bfdb 100644 (file)
@@ -187,27 +187,6 @@ static void disposeATSULayoutParameters(ATSULayoutParameters *params);
 
 // Character property functions.
 
-inline bool isSpace(UChar32 c)
-{
-    return c == SPACE || c == '\t' || c == '\n' || c == NO_BREAK_SPACE;
-}
-
-static const uint8_t isRoundingHackCharacterTable[0x100] = {
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*\t*/, 1 /*\n*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1 /*space*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*-*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*?*/,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    1 /*no-break space*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
-bool isRoundingHackCharacter(UChar c)
-{
-    return (((c & ~0xFF) == 0 && isRoundingHackCharacterTable[c]));
-}
-
 void WebCoreInitializeFont(FontPlatformData *font)
 {
     font->font = nil;
@@ -332,7 +311,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
             if (hasExtraSpacing) {
                 if (width && style->letterSpacing)
                     width +=style->letterSpacing;
-                if (isSpace(nextCh)) {
+                if (Font::treatAsSpace(nextCh)) {
                     if (style->padding) {
                         if (padding < params->padPerSpace) {
                             width += padding;
@@ -342,7 +321,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
                             padding -= params->padPerSpace;
                         }
                     }
-                    if (offset != 0 && !isSpace(*((UniChar *)(((char *)characters)+offset) - 1)) && style->wordSpacing)
+                    if (offset != 0 && !Font::treatAsSpace(*((UniChar *)(((char *)characters)+offset) - 1)) && style->wordSpacing)
                         width += style->wordSpacing;
                 }
             }
@@ -353,13 +332,13 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
             // We won't actually round unless the other conditions are satisfied.
             nextCh = isLastChar ? ' ' : *(UniChar *)(((char *)characters)+offset);
 
-            if (isRoundingHackCharacter(ch))
+            if (Font::isRoundingHackCharacter(ch))
                 width = ceilf(width);
             lastAdjustedPos = lastAdjustedPos + width;
-            if (isRoundingHackCharacter(nextCh)
+            if (Font::isRoundingHackCharacter(nextCh)
                 && (!isLastChar
                     || style->applyRunRounding
-                    || (run->to < (int)run->length && isRoundingHackCharacter(characters[run->to - run->from])))) {
+                    || (run->to < (int)run->length && Font::isRoundingHackCharacter(characters[run->to - run->from])))) {
                 if (!style->rtl)
                     lastAdjustedPos = ceilf(lastAdjustedPos);
                 else {
@@ -1416,7 +1395,7 @@ static void createATSULayoutParameters(ATSULayoutParameters *params, FontData *r
         float numSpaces = 0;
         unsigned k;
         for (k = 0; k < totalLength; k++)
-            if (isSpace(run->characters[k]))
+            if (Font::treatAsSpace(run->characters[k]))
                 numSpaces++;
 
         params->padPerSpace = ceilf(style->padding / numSpaces);
@@ -1773,7 +1752,7 @@ static void initializeWidthIterator(WidthIterator *iterator, FontData *renderer,
         float numSpaces = 0;
         int k;
         for (k = run->from; k < run->to; k++)
-            if (isSpace(run->characters[k]))
+            if (Font::treatAsSpace(run->characters[k]))
                 numSpaces++;
 
         iterator->padding = style->padding;
@@ -1927,7 +1906,7 @@ static unsigned advanceWidthIterator(WidthIterator *iterator, unsigned offset, f
             if (width && style->letterSpacing)
                 width += style->letterSpacing;
 
-            if (isSpace(c)) {
+            if (Font::treatAsSpace(c)) {
                 // Account for padding. WebCore uses space padding to justify text.
                 // We distribute the specified padding over the available spaces in the run.
                 if (style->padding) {
@@ -1943,7 +1922,7 @@ static unsigned advanceWidthIterator(WidthIterator *iterator, unsigned offset, f
 
                 // Account for word spacing.
                 // We apply additional space between "words" by adding width to the space character.
-                if (currentCharacter != 0 && !isSpace(cp[-1]) && style->wordSpacing)
+                if (currentCharacter != 0 && !Font::treatAsSpace(cp[-1]) && style->wordSpacing)
                     width += style->wordSpacing;
             }
         }
@@ -1961,12 +1940,12 @@ static unsigned advanceWidthIterator(WidthIterator *iterator, unsigned offset, f
 
         // Force characters that are used to determine word boundaries for the rounding hack
         // to be integer width, so following words will start on an integer boundary.
-        if (style->applyWordRounding && isRoundingHackCharacter(c))
+        if (style->applyWordRounding && Font::isRoundingHackCharacter(c))
             width = ceilf(width);
 
         // Check to see if the next character is a "rounding hack character", if so, adjust
         // width so that the total run width will be on an integer boundary.
-        if ((style->applyWordRounding && currentCharacter < run->length && isRoundingHackCharacter(*cp))
+        if ((style->applyWordRounding && currentCharacter < run->length && Font::isRoundingHackCharacter(*cp))
                 || (style->applyRunRounding && currentCharacter >= (unsigned)run->to)) {
             float totalWidth = iterator->widthToStart + runWidthSoFar + width;
             width += ceilf(totalWidth) - totalWidth;
index 5a43491fbba1d53f421e1e88bca1d245e01d2337..fee274eb91cf72e75c5974a24122eafa210acd81 100644 (file)
@@ -269,7 +269,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
             if (hasExtraSpacing) {
                 if (width && params->m_font->letterSpacing())
                     width +=params->m_font->letterSpacing();
-                if (isSpace(nextCh)) {
+                if (Font::treatAsSpace(nextCh)) {
                     if (params->m_padding) {
                         if (padding < params->m_padPerSpace) {
                             width += padding;
@@ -279,7 +279,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
                             padding -= params->m_padPerSpace;
                         }
                     }
-                    if (offset != 0 && !isSpace(*((UniChar *)(((char *)characters)+offset) - 1)) && params->m_font->wordSpacing())
+                    if (offset != 0 && !Font::treatAsSpace(*((UniChar *)(((char *)characters)+offset) - 1)) && params->m_font->wordSpacing())
                         width += params->m_font->wordSpacing();
                 }
             }
@@ -290,13 +290,13 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
             // We won't actually round unless the other conditions are satisfied.
             nextCh = isLastChar ? ' ' : *(UniChar *)(((char *)characters)+offset);
 
-            if (isRoundingHackCharacter(ch))
+            if (Font::isRoundingHackCharacter(ch))
                 width = ceilf(width);
             lastAdjustedPos = lastAdjustedPos + width;
-            if (isRoundingHackCharacter(nextCh)
+            if (Font::isRoundingHackCharacter(nextCh)
                 && (!isLastChar
                     || params->m_applyRunRounding
-                    || (params->m_to < (int)params->m_len && isRoundingHackCharacter(characters[params->m_to - params->m_from])))) {
+                    || (params->m_to < (int)params->m_len && Font::isRoundingHackCharacter(characters[params->m_to - params->m_from])))) {
                 if (!params->m_rtl)
                     lastAdjustedPos = ceilf(lastAdjustedPos);
                 else {
@@ -459,7 +459,7 @@ void ATSULayoutParameters::initialize(const Font* font)
         float numSpaces = 0;
         unsigned k;
         for (k = 0; k < totalLength; k++)
-            if (isSpace(m_characters[k]))
+            if (Font::treatAsSpace(m_characters[k]))
                 numSpaces++;
 
         m_padPerSpace = ceilf(m_padding / numSpaces);