Bug 8864. Lift WebCoreTextStyle up into the API (as TextStyle).
authorhyatt <hyatt@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 12 May 2006 09:22:14 +0000 (09:22 +0000)
committerhyatt <hyatt@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 12 May 2006 09:22:14 +0000 (09:22 +0000)
        Reviewed by mjs

        * platform/Font.cpp:
        (WebCore::m_finalRoundingWidth):
        (WebCore::WidthIterator::advance):
        (WebCore::Font::width):
        (WebCore::Font::drawSimpleText):
        (WebCore::Font::drawText):
        (WebCore::Font::floatWidth):
        (WebCore::Font::floatWidthForSimpleText):
        * platform/Font.h:
        (WebCore::TextStyle::m_attemptFontSubstitution):
        (WebCore::TextStyle::tabWidth):
        (WebCore::TextStyle::xPos):
        (WebCore::TextStyle::padding):
        (WebCore::TextStyle::rtl):
        (WebCore::TextStyle::ltr):
        (WebCore::TextStyle::directionalOverride):
        (WebCore::TextStyle::applyRunRounding):
        (WebCore::TextStyle::applyWordRounding):
        (WebCore::TextStyle::attemptFontSubstitution):
        (WebCore::Font::operator==):
        * platform/GraphicsContext.cpp:
        (WebCore::GraphicsContext::drawText):
        (WebCore::GraphicsContext::drawHighlightForText):
        * platform/GraphicsContext.h:
        * platform/mac/FontMac.mm:
        (WebCore::overrideLayoutOperation):
        (WebCore::ATSULayoutParameters::initialize):
        (WebCore::Font::selectionRectForText):
        (WebCore::Font::drawComplexText):
        (WebCore::Font::floatWidthForComplexText):
        (WebCore::Font::offsetForPosition):
        * rendering/InlineTextBox.cpp:
        (WebCore::InlineTextBox::selectionRect):
        (WebCore::InlineTextBox::paint):
        (WebCore::InlineTextBox::paintSelection):
        (WebCore::InlineTextBox::paintMarkedTextBackground):
        (WebCore::InlineTextBox::paintTextMatchMarker):
        (WebCore::InlineTextBox::offsetForPosition):
        (WebCore::InlineTextBox::positionForOffset):
        * rendering/RenderText.cpp:
        (WebCore::RenderText::widthFromCache):
        (WebCore::RenderText::calcMinMaxWidth):
        (WebCore::RenderText::width):
        * rendering/RenderTextField.cpp:
        (WebCore::RenderTextField::calcMinMaxWidth):
        * rendering/render_line.cpp:
        (WebCore::EllipsisBox::paint):

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

WebCore/ChangeLog
WebCore/platform/Font.cpp
WebCore/platform/Font.h
WebCore/platform/GraphicsContext.cpp
WebCore/platform/GraphicsContext.h
WebCore/platform/mac/FontMac.mm
WebCore/rendering/InlineTextBox.cpp
WebCore/rendering/RenderText.cpp
WebCore/rendering/RenderTextField.cpp
WebCore/rendering/render_line.cpp

index 080c6d78b70451cc66c7449cfbe4c25e00903a46..1999f371c029a75fafc6c14e4411c36a1953da67 100644 (file)
@@ -1,3 +1,57 @@
+2006-05-12  David Hyatt  <hyatt@apple.com>
+
+        Bug 8864. Lift WebCoreTextStyle up into the API (as TextStyle).
+
+        Reviewed by mjs
+
+        * platform/Font.cpp:
+        (WebCore::m_finalRoundingWidth):
+        (WebCore::WidthIterator::advance):
+        (WebCore::Font::width):
+        (WebCore::Font::drawSimpleText):
+        (WebCore::Font::drawText):
+        (WebCore::Font::floatWidth):
+        (WebCore::Font::floatWidthForSimpleText):
+        * platform/Font.h:
+        (WebCore::TextStyle::m_attemptFontSubstitution):
+        (WebCore::TextStyle::tabWidth):
+        (WebCore::TextStyle::xPos):
+        (WebCore::TextStyle::padding):
+        (WebCore::TextStyle::rtl):
+        (WebCore::TextStyle::ltr):
+        (WebCore::TextStyle::directionalOverride):
+        (WebCore::TextStyle::applyRunRounding):
+        (WebCore::TextStyle::applyWordRounding):
+        (WebCore::TextStyle::attemptFontSubstitution):
+        (WebCore::Font::operator==):
+        * platform/GraphicsContext.cpp:
+        (WebCore::GraphicsContext::drawText):
+        (WebCore::GraphicsContext::drawHighlightForText):
+        * platform/GraphicsContext.h:
+        * platform/mac/FontMac.mm:
+        (WebCore::overrideLayoutOperation):
+        (WebCore::ATSULayoutParameters::initialize):
+        (WebCore::Font::selectionRectForText):
+        (WebCore::Font::drawComplexText):
+        (WebCore::Font::floatWidthForComplexText):
+        (WebCore::Font::offsetForPosition):
+        * rendering/InlineTextBox.cpp:
+        (WebCore::InlineTextBox::selectionRect):
+        (WebCore::InlineTextBox::paint):
+        (WebCore::InlineTextBox::paintSelection):
+        (WebCore::InlineTextBox::paintMarkedTextBackground):
+        (WebCore::InlineTextBox::paintTextMatchMarker):
+        (WebCore::InlineTextBox::offsetForPosition):
+        (WebCore::InlineTextBox::positionForOffset):
+        * rendering/RenderText.cpp:
+        (WebCore::RenderText::widthFromCache):
+        (WebCore::RenderText::calcMinMaxWidth):
+        (WebCore::RenderText::width):
+        * rendering/RenderTextField.cpp:
+        (WebCore::RenderTextField::calcMinMaxWidth):
+        * rendering/render_line.cpp:
+        (WebCore::EllipsisBox::paint):
+
 2006-05-11  Alexey Proskuryakov  <ap@nypop.com>
 
         Reviewed by Darin.
index d0c2658e96e9c4ef16a3b83e697fe3a3520ec810..2081f5de0cf74948d729c3bc12675cb98b8ed980 100644 (file)
@@ -56,9 +56,7 @@ const uint8_t Font::gRoundingHackCharacterTable[256] = {
 };
 
 struct WidthIterator {
-    WidthIterator(const Font* font, const TextRun& run,
-                  int tabWidth, int xpos, int toAdd, TextDirection dir, bool visuallyOrdered,
-                  bool applyWordRounding, bool applyRunRounding, const FontData* substituteFontData);
+    WidthIterator(const Font* font, const TextRun& run, const TextStyle& style, const FontData* substituteFontData = 0);
 
     void advance(int to, GlyphBuffer* glyphBuffer = 0);
 
@@ -67,13 +65,7 @@ struct WidthIterator {
     const TextRun& m_run;
     int m_end;
 
-    int m_tabWidth;
-    int m_xPos;
-    int m_toAdd;
-    TextDirection m_dir;
-    bool m_visuallyOrdered;
-    bool m_applyWordRounding;
-    bool m_applyRunRounding;
+    const TextStyle& m_style;
     const FontData* m_substituteFontData;
 
     unsigned m_currentCharacter;
@@ -87,27 +79,25 @@ private:
     UChar32 normalizeVoicingMarks();
 };
 
-WidthIterator::WidthIterator(const Font* font, const TextRun& run,
-                             int tabWidth, int xpos, int toAdd, TextDirection dir, bool visuallyOrdered,
-                             bool applyWordRounding, bool applyRunRounding, const FontData* substituteFontData)
-:m_font(font), m_run(run), m_end(dir == LTR ? run.to() : run.length()),
- m_tabWidth(tabWidth), m_xPos(xpos), m_toAdd(toAdd), m_dir(dir), m_visuallyOrdered(visuallyOrdered),
- m_applyWordRounding(applyWordRounding), m_applyRunRounding(applyRunRounding), m_substituteFontData(substituteFontData),
+WidthIterator::WidthIterator(const Font* font, const TextRun& run, const TextStyle& style, const FontData* substituteFontData)
+:m_font(font), m_run(run), m_end(style.rtl() ? run.length() : run.to()), m_style(style), m_substituteFontData(substituteFontData),
  m_currentCharacter(run.from()), m_runWidthSoFar(0), m_finalRoundingWidth(0)
 {
     // If the padding is non-zero, count the number of spaces in the run
     // and divide that by the padding for per space addition.
-    if (!toAdd) {
-        m_padding = 0;
+    m_padding = m_style.padding();
+    if (!m_padding)
         m_padPerSpace = 0;
-    else {
+    else {
         float numSpaces = 0;
         for (int i = run.from(); i < m_end; i++)
             if (Font::treatAsSpace(m_run[i]))
                 numSpaces++;
 
-        m_padding = toAdd;
-        m_padPerSpace = ceilf(m_padding / numSpaces);
+        if (numSpaces == 0)
+            m_padPerSpace = 0;
+        else
+            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
     }
     
     // Calculate width up to starting position of the run.  This is
@@ -117,8 +107,7 @@ WidthIterator::WidthIterator(const Font* font, const TextRun& run,
         m_widthToStart = 0;
     else {
         TextRun completeRun(run.characters(), run.length());
-        WidthIterator startPositionIterator(font, completeRun, tabWidth, xpos, toAdd, dir, visuallyOrdered,
-                                            applyWordRounding, applyRunRounding, substituteFontData);
+        WidthIterator startPositionIterator(font, completeRun, style, substituteFontData);
         startPositionIterator.advance(run.from());
         m_widthToStart = startPositionIterator.m_runWidthSoFar;
     }
@@ -132,7 +121,7 @@ void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
     int currentCharacter = m_currentCharacter;
     const UChar* cp = m_run.data(currentCharacter);
 
-    bool rtl = (m_dir == RTL);
+    bool rtl = m_style.rtl();
     bool needCharTransform = rtl || m_font->isSmallCaps();
     bool hasExtraSpacing = m_font->letterSpacing() || m_font->wordSpacing() || m_padding;
 
@@ -192,13 +181,13 @@ void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
 
         // Try to find a substitute font if this font didn't have a glyph for a character in the
         // string. If one isn't found we end up drawing and measuring the 0 glyph, usually a box.
-        if (glyph == 0 && !m_substituteFontData) {
+        if (glyph == 0 && !m_substituteFontData && m_style.attemptFontSubstitution()) {
             // FIXME: Should go through fallback list eventually.
             const FontData* substituteFontData = fontData->findSubstituteFontData(cp, clusterLength, m_font->fontDescription());
             if (substituteFontData) {
                 GlyphBuffer localGlyphBuffer;
-                m_font->floatWidthForSimpleText(TextRun((UChar*)cp, clusterLength), 0, 0, 0, m_dir, m_visuallyOrdered
-                                                 m_applyWordRounding, false, substituteFontData, 0, &localGlyphBuffer);
+                m_font->floatWidthForSimpleText(TextRun((UChar*)cp, clusterLength), TextStyle(0, 0, 0, m_style.rtl(), m_style.directionalOverride()
+                                                                                              false, m_style.applyWordRounding()), substituteFontData, 0, &localGlyphBuffer);
                 if (localGlyphBuffer.size() == 1) {
                     assert(substituteFontData == localGlyphBuffer.fontDataAt(0));
                     glyph = localGlyphBuffer.glyphAt(0);
@@ -210,15 +199,15 @@ void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
 
         // Now that we have a glyph and font data, get its width.
         float width;
-        if (c == '\t' && m_tabWidth)
-            width = m_tabWidth - fmodf(m_xPos + runWidthSoFar, m_tabWidth);
+        if (c == '\t' && m_style.tabWidth())
+            width = m_style.tabWidth() - fmodf(m_style.xPos() + runWidthSoFar, m_style.tabWidth());
         else {
             width = fontData->widthForGlyph(glyph);
             // We special case spaces in two ways when applying word rounding.
             // First, we round spaces to an adjusted width in all fonts.
             // Second, in fixed-pitch fonts we ensure that all characters that
             // match the width of the space character have the same width as the space character.
-            if (width == fontData->m_spaceWidth && (fontData->m_treatAsFixedPitch || glyph == fontData->m_spaceGlyph) && m_applyWordRounding)
+            if (width == fontData->m_spaceWidth && (fontData->m_treatAsFixedPitch || glyph == fontData->m_spaceGlyph) && m_style.applyWordRounding())
                 width = fontData->m_adjustedSpaceWidth;
         }
 
@@ -261,13 +250,13 @@ 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 && Font::isRoundingHackCharacter(c))
+        if (m_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 ((m_applyWordRounding && currentCharacter < m_run.length() && Font::isRoundingHackCharacter(*cp))
-                || (m_applyRunRounding && currentCharacter >= m_end)) {
+        if ((m_style.applyWordRounding() && currentCharacter < m_run.length() && Font::isRoundingHackCharacter(*cp))
+                || (m_style.applyRunRounding() && currentCharacter >= m_end)) {
             float totalWidth = m_widthToStart + runWidthSoFar + width;
             width += ceilf(totalWidth) - totalWidth;
         }
@@ -356,13 +345,13 @@ void Font::update() const
     m_fontList->invalidate();
 }
 
-int Font::width(const TextRun& run, int tabWidth, int xpos) const
+int Font::width(const TextRun& run, const TextStyle& style) const
 {
     // FIXME: Want to define an lroundf for win32.
 #if __APPLE__
-    return lroundf(floatWidth(run, tabWidth, xpos));
+    return lroundf(floatWidth(run, style));
 #else
-    return floatWidth(run, tabWidth, xpos) + 0.5f;
+    return floatWidth(run, style) + 0.5f;
 #endif
 }
 
@@ -457,17 +446,14 @@ bool Font::canUseGlyphCache(const TextRun& run) const
 
 }
 
-void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const IntPoint& point, int tabWidth, int xpos,
-                          int toAdd, TextDirection dir, bool visuallyOrdered) const
+void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const TextStyle& style, const IntPoint& point) const
 {
     // This glyph buffer holds our glyphs+advances+font data for each glyph.
     GlyphBuffer glyphBuffer;
 
     // Our measuring code will generate glyphs and advances for us.
     float startX;
-    floatWidthForSimpleText(run, tabWidth, xpos, toAdd, dir, visuallyOrdered, 
-                            true, true, 0,
-                            &startX, &glyphBuffer);
+    floatWidthForSimpleText(run, style, 0, &startX, &glyphBuffer);
     
     // We couldn't generate any glyphs for the run.  Give up.
     if (glyphBuffer.isEmpty())
@@ -479,7 +465,7 @@ void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const In
     FloatPoint startPoint(startX, point.y());
 
     // Swap the order of the glyphs if right-to-left.
-    if (dir == RTL)
+    if (style.rtl())
         for (int i = 0, end = glyphBuffer.size() - 1; i < glyphBuffer.size() / 2; ++i, --end)
             glyphBuffer.swap(i, end);
 
@@ -502,36 +488,31 @@ void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const In
     drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint);
 }
 
-void Font::drawText(GraphicsContext* context, const TextRun& run, const IntPoint& point, int tabWidth, int xpos,
-                    int toAdd, TextDirection d, bool visuallyOrdered) const
+void Font::drawText(GraphicsContext* context, const TextRun& run, const TextStyle& style, const IntPoint& point) const
 {
     if (canUseGlyphCache(run))
-        drawSimpleText(context, run, point, tabWidth, xpos, toAdd, d, visuallyOrdered);
+        drawSimpleText(context, run, style, point);
     else
-        drawComplexText(context, run, point, tabWidth, xpos, toAdd, d, visuallyOrdered);
+        drawComplexText(context, run, style, point);
 }
 
-float Font::floatWidth(const TextRun& run, int tabWidth, int xpos, bool runRounding) const
+float Font::floatWidth(const TextRun& run, const TextStyle& style) const
 {
     if (canUseGlyphCache(run))
-        return floatWidthForSimpleText(run, tabWidth, xpos, 0, LTR, false, true, runRounding, 0, 0, 0);
+        return floatWidthForSimpleText(run, style, 0, 0, 0);
     else
-        return floatWidthForComplexText(run, tabWidth, xpos, runRounding);
+        return floatWidthForComplexText(run, style);
 }
 
-float Font::floatWidthForSimpleText(const TextRun& run, int tabWidth, int xpos, int toAdd, 
-                                    TextDirection dir, bool visuallyOrdered, 
-                                    bool applyWordRounding, bool applyRunRounding,
-                                    const FontData* substituteFont,
-                                    float* startPosition, GlyphBuffer* glyphBuffer) const
+float Font::floatWidthForSimpleText(const TextRun& run, const TextStyle& style,
+                                    const FontData* substituteFont, float* startPosition, GlyphBuffer* glyphBuffer) const
 {
     
-    WidthIterator it(this, run, tabWidth, xpos, toAdd, dir, visuallyOrdered, 
-                     applyWordRounding, applyRunRounding, substituteFont);
+    WidthIterator it(this, run, style, substituteFont);
     it.advance(run.to(), glyphBuffer);
     float runWidth = it.m_runWidthSoFar;
     if (startPosition) {
-        if (dir == LTR)
+        if (style.ltr())
             *startPosition = it.m_widthToStart;
         else {
             float finalRoundingWidth = it.m_finalRoundingWidth;
index 2e77d7f08840c5e98ee2980c68dc5b3cc1331c4f..21f39290dd45564a93fcd1aadab065d4a6dc2b6d 100644 (file)
@@ -80,6 +80,36 @@ private:
     int m_to;
 };
 
+class TextStyle
+{
+public:
+    TextStyle(int tabWidth = 0, int xpos = 0, int padding = 0, bool rtl = false, bool directionalOverride = false,
+              bool applyRunRounding = true, bool applyWordRounding = true, bool attemptFontSubstitution = true)
+    :m_tabWidth(tabWidth), m_xpos(xpos), m_padding(padding), m_rtl(rtl), m_directionalOverride(directionalOverride),
+     m_applyRunRounding(applyRunRounding), m_applyWordRounding(applyWordRounding), m_attemptFontSubstitution(attemptFontSubstitution)
+    {}
+    
+    int tabWidth() const { return m_tabWidth; }
+    int xPos() const { return m_xpos; }
+    int padding() const { return m_padding; }
+    bool rtl() const { return m_rtl; }
+    bool ltr() const { return !m_rtl; }
+    bool directionalOverride() const { return m_directionalOverride; }
+    bool applyRunRounding() const { return m_applyRunRounding; }
+    bool applyWordRounding() const { return m_applyWordRounding; }
+    bool attemptFontSubstitution() const { return m_attemptFontSubstitution; }
+
+private:
+    int m_tabWidth;
+    int m_xpos;
+    int m_padding;
+    bool m_rtl;
+    bool m_directionalOverride;
+    bool m_applyRunRounding;
+    bool m_applyWordRounding;
+    bool m_attemptFontSubstitution;
+};
+
 class Font {
 public:
     Font();
@@ -90,7 +120,7 @@ public:
     Font& operator=(const Font&);
 
     bool operator==(const Font& other) const {
-        // The renderer pointer doesn't have to be checked, since
+        // Our FontData doesn't have to be checked, since
         // checking the font description will be fine.
         return (m_fontDescription == other.m_fontDescription &&
                 m_letterSpacing == other.m_letterSpacing &&
@@ -108,19 +138,13 @@ public:
     
     void update() const;
 
-    void drawText(GraphicsContext*, const TextRun&, const IntPoint&, int tabWidth, int xpos,
-                  int toAdd, TextDirection, bool visuallyOrdered) const;
-    void drawLineForMisspelling(GraphicsContext*, const IntPoint&, int width) const;
-    int misspellingLineThickness(GraphicsContext*) const;
+    void drawText(GraphicsContext*, const TextRun&, const TextStyle&, const IntPoint&) const;
 
-    float floatWidth(const TextRun&, int tabWidth, int xpos, bool runRounding = true) const;
-    
-    int checkSelectionPoint(const TextRun&, int toAdd, int tabWidth, int xpos,
-        int x, TextDirection, bool visuallyOrdered, bool includePartialGlyphs) const;
-    FloatRect selectionRectForText(const TextRun&, const IntPoint&, int h, int tabWidth, int xpos, int width,
-                                   bool rtl, bool visuallyOrdered = false) const;
+    int width(const TextRun&, const TextStyle& = TextStyle()) const;
+    float floatWidth(const TextRun&, const TextStyle& = TextStyle()) const;
     
-    int width(const TextRun&, int tabWidth = 0, int xpos = 0) const;
+    int offsetForPosition(const TextRun&, const TextStyle&, int position, bool includePartialGlyphs) const;
+    FloatRect selectionRectForText(const TextRun&, const TextStyle&, const IntPoint&, int h) const;
 
     bool isSmallCaps() const { return m_fontDescription.smallCaps(); }
 
@@ -158,19 +182,11 @@ private:
 #if __APPLE__
     // FIXME: This will eventually be cross-platform, but we want to keep Windows compiling for now.
     bool canUseGlyphCache(const TextRun&) const;
-    void drawSimpleText(GraphicsContext*, const TextRun&, const IntPoint&, 
-                        int tabWidth, int xpos, int toAdd, 
-                        TextDirection, bool visuallyOrdered) const;
+    void drawSimpleText(GraphicsContext*, const TextRun&, const TextStyle&, const IntPoint&) const;
     void drawGlyphs(GraphicsContext*, const FontData*, const GlyphBuffer&, int from, int to, const FloatPoint&) const;
-    void drawComplexText(GraphicsContext*, const TextRun&, const IntPoint&, 
-                         int tabWidth, int xpos, int toAdd, TextDirection, bool visuallyOrdered) const;
-    float floatWidthForSimpleText(const TextRun&, 
-                                  int tabWidth, int xpos, int toAdd, 
-                                  TextDirection, bool visuallyOrdered, 
-                                  bool applyWordRounding, bool applyRunRounding,
-                                  const FontData* substituteFont,
-                                  float* startX, GlyphBuffer*) const;
-    float floatWidthForComplexText(const TextRun&, int tabWidth, int xpos, bool runRounding = true) const;
+    void drawComplexText(GraphicsContext*, const TextRun&, const TextStyle&, const IntPoint&) const;
+    float floatWidthForSimpleText(const TextRun&, const TextStyle&, const FontData* substituteFont, float* startX, GlyphBuffer*) const;
+    float floatWidthForComplexText(const TextRun&, const TextStyle&) const;
 
     friend struct WidthIterator;
     
index dcb9c540385755ea8219fc6c13eab45783719857..cf858bbb4ca79c88a664698c55190593f57b7553 100644 (file)
@@ -192,22 +192,20 @@ void GraphicsContext::drawImage(Image* image, const IntRect& dest, const IntRect
     drawImage(image, FloatRect(dest), srcRect, op);
 }
 
-void GraphicsContext::drawText(const TextRun& run, const IntPoint& point, int tabWidth, int xpos, int toAdd,
-                               TextDirection d, bool visuallyOrdered)
+void GraphicsContext::drawText(const TextRun& run, const IntPoint& point, const TextStyle& style)
 {
     if (paintingDisabled())
         return;
     
-    font().drawText(this, run, point, tabWidth, xpos, toAdd, d, visuallyOrdered);
+    font().drawText(this, run, style, point);
 }
 
-void GraphicsContext::drawHighlightForText(const TextRun& run, const IntPoint& point, int h, int tabWidth, int xpos, int toAdd,
-                                           TextDirection d, bool visuallyOrdered, const Color& backgroundColor)
+void GraphicsContext::drawHighlightForText(const TextRun& run, const IntPoint& point, int h, const TextStyle& style, const Color& backgroundColor)
 {
     if (paintingDisabled())
         return;
 
-    fillRect(font().selectionRectForText(run, point, h, tabWidth, xpos, toAdd, d == RTL, visuallyOrdered), backgroundColor);
+    fillRect(font().selectionRectForText(run, style, point, h), backgroundColor);
 }
 
 void GraphicsContext::initFocusRing(int width, int offset)
index 82dd51631d4b27cc455e53c3b25a57e1c0837cf4..b46e2851f16e3d46343425bec84eeab0bd5eaa64 100644 (file)
@@ -26,6 +26,7 @@
 #ifndef GraphicsContext_h
 #define GraphicsContext_h
 
+#include "Font.h"
 #include "FloatRect.h"
 #include "Image.h"
 #include "IntRect.h"
@@ -57,7 +58,6 @@ namespace WebCore {
     class IntPoint;
     class IntPointArray;
     class Path;
-    class TextRun;
 
 #if SVG_SUPPORT
     class KRenderingDeviceContext;
@@ -112,12 +112,9 @@ namespace WebCore {
         void setFocusRingClip(const IntRect&);
         void clearFocusRingClip();
 
-        void drawText(const TextRun&, const IntPoint&, int tabWidth = 0, int xpos = 0, int toAdd = 0,
-                      TextDirection = LTR, bool visuallyOrdered = false);
-        void drawHighlightForText(const TextRun&, const IntPoint&, int h, 
-                                  int tabWidth, int xpos, int toAdd, TextDirection, bool visuallyOrdered, const Color& backgroundColor);
-                                  
-        
+        void drawText(const TextRun&, const IntPoint&, const TextStyle& = TextStyle());
+        void drawHighlightForText(const TextRun&, const IntPoint&, int h, const TextStyle&, const Color& backgroundColor);
+
         void drawLineForText(const IntPoint&, int yOffset, int width, bool printing);
         void drawLineForMisspelling(const IntPoint&, int width);
 
index 9ac12f5d514bc4da5493f0e795a13f5fc73741df..157773d1ea992557475191a497bc0a67e264f6c8 100644 (file)
@@ -113,20 +113,15 @@ void FontFallbackList::invalidate()
 
 struct ATSULayoutParameters
 {
-    ATSULayoutParameters(const TextRun& run, int toAdd, TextDirection dir, bool applyWordRounding, bool applyRunRounding)
-    :m_run(run), m_padding(toAdd), m_rtl(dir == RTL),
-     m_applyWordRounding(applyWordRounding), m_applyRunRounding(applyRunRounding),
+    ATSULayoutParameters(const TextRun& run, const TextStyle& style)
+    :m_run(run), m_style(style),
      m_font(0), m_fonts(0), m_charBuffer(0), m_hasSyntheticBold(false), m_syntheticBoldPass(false), m_padPerSpace(0)
     {}
 
     void initialize(const Font* font);
 
     const TextRun& m_run;
-
-    int m_padding;
-    bool m_rtl;
-    bool m_applyWordRounding;
-    bool m_applyRunRounding;
+    const TextStyle& m_style;
     
     const Font* m_font;
     
@@ -211,7 +206,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
     ItemCount count;
     ATSLayoutRecord *layoutRecords;
 
-    if (params->m_applyWordRounding) {
+    if (params->m_style.applyWordRounding()) {
         status = ATSUDirectGetLayoutDataArrayPtrFromLineRef(iLineRef, kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, true, (void **)&layoutRecords, &count);
         if (status != noErr) {
             *oCallbackStatus = kATSULayoutOperationCallbackStatusContinue;
@@ -231,8 +226,8 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
         bool syntheticBoldPass = params->m_syntheticBoldPass;
         Fixed syntheticBoldOffset = 0;
         ATSGlyphRef spaceGlyph = 0;
-        bool hasExtraSpacing = params->m_font->letterSpacing() || params->m_font->wordSpacing() | params->m_padding;
-        float padding = params->m_padding;
+        bool hasExtraSpacing = params->m_font->letterSpacing() || params->m_font->wordSpacing() | params->m_style.padding();
+        float padding = params->m_style.padding();
         // In the CoreGraphics code path, the rounding hack is applied in logical order.
         // Here it is applied in visual left-to-right order, which may be better.
         ItemCount lastRoundingChar = 0;
@@ -263,7 +258,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
                 if (width && params->m_font->letterSpacing())
                     width +=params->m_font->letterSpacing();
                 if (Font::treatAsSpace(nextCh)) {
-                    if (params->m_padding) {
+                    if (params->m_style.padding()) {
                         if (padding < params->m_padPerSpace) {
                             width += padding;
                             padding = 0;
@@ -288,10 +283,10 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
             lastAdjustedPos = lastAdjustedPos + width;
             if (Font::isRoundingHackCharacter(nextCh)
                 && (!isLastChar
-                    || params->m_applyRunRounding
+                    || params->m_style.applyRunRounding()
                     || (params->m_run.to() < (int)params->m_run.length() && 
                         Font::isRoundingHackCharacter(characters[params->m_run.to() - params->m_run.from()])))) {
-                if (!params->m_rtl)
+                if (params->m_style.ltr())
                     lastAdjustedPos = ceilf(lastAdjustedPos);
                 else {
                     float roundingWidth = ceilf(lastAdjustedPos) - lastAdjustedPos;
@@ -326,7 +321,7 @@ void ATSULayoutParameters::initialize(const Font* font)
     // fontData ATSUMirrors is true, for a substitute fontData it might be false.
     const FontData* fontData = font->primaryFont();
     m_fonts = new const FontData*[m_run.length()];
-    m_charBuffer = (UChar*)((font->isSmallCaps() || (m_rtl && !fontData->m_ATSUMirrors)) ? new UChar[m_run.length()] : 0);
+    m_charBuffer = (UChar*)((font->isSmallCaps() || (m_style.rtl() && !fontData->m_ATSUMirrors)) ? new UChar[m_run.length()] : 0);
     
     // The only Cocoa calls here are to NSGraphicsContext, which does not raise exceptions.
 
@@ -365,14 +360,14 @@ void ATSULayoutParameters::initialize(const Font* font)
 
     CGContextRef cgContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
     ATSLineLayoutOptions lineLayoutOptions = kATSLineKeepSpacesOutOfMargin | kATSLineHasNoHangers;
-    Boolean rtl = m_rtl;
+    Boolean rtl = m_style.rtl();
     overrideSpecifier.operationSelector = kATSULayoutOperationPostLayoutAdjustment;
     overrideSpecifier.overrideUPP = overrideLayoutOperation;
     ATSUAttributeTag tags[] = { kATSUCGContextTag, kATSULineLayoutOptionsTag, kATSULineDirectionTag, kATSULayoutOperationOverrideTag };
     ByteCount sizes[] = { sizeof(CGContextRef), sizeof(ATSLineLayoutOptions), sizeof(Boolean), sizeof(ATSULayoutOperationOverrideSpecifier) };
     ATSUAttributeValuePtr values[] = { &cgContext, &lineLayoutOptions, &rtl, &overrideSpecifier };
     
-    status = ATSUSetLayoutControls(layout, (m_applyWordRounding ? 4 : 3), tags, sizes, values);
+    status = ATSUSetLayoutControls(layout, (m_style.applyWordRounding() ? 4 : 3), tags, sizes, values);
     if (status != noErr)
         LOG_ERROR("ATSUSetLayoutControls failed(%d)", status);
 
@@ -420,7 +415,7 @@ void ATSULayoutParameters::initialize(const Font* font)
                 else
                     break;
             }
-            if (m_rtl && m_charBuffer && !r->m_ATSUMirrors)
+            if (m_style.rtl() && m_charBuffer && !r->m_ATSUMirrors)
                 m_charBuffer[i] = u_charMirror(m_charBuffer[i]);
             if (m_font->isSmallCaps()) {
                 UChar c = m_charBuffer[i];
@@ -449,14 +444,17 @@ void ATSULayoutParameters::initialize(const Font* font)
         }
         substituteOffset += substituteLength;
     }
-    if (m_padding) {
+    if (m_style.padding()) {
         float numSpaces = 0;
         unsigned k;
         for (k = 0; k < totalLength; k++)
             if (Font::treatAsSpace(m_run[k]))
                 numSpaces++;
 
-        m_padPerSpace = ceilf(m_padding / numSpaces);
+        if (numSpaces == 0)
+            m_padPerSpace = 0;
+        else
+            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
     } else
         m_padPerSpace = 0;
 }
@@ -473,7 +471,7 @@ const FontPlatformData& Font::platformFont() const
     return m_fontList->platformFont(fontDescription());
 }
 
-FloatRect Font::selectionRectForText(const TextRun& textRun, const IntPoint& point, int h, int tabWidth, int xpos, int toAdd, bool rtl, bool visuallyOrdered) const
+FloatRect Font::selectionRectForText(const TextRun& textRun, const TextStyle& textStyle, const IntPoint& point, int h) const
 {
     assert(m_fontList);
 
@@ -483,15 +481,15 @@ FloatRect Font::selectionRectForText(const TextRun& textRun, const IntPoint& poi
     WebCoreInitializeTextRun(&run, textRun.characters(), textRun.length(), textRun.from(), textRun.to());
     WebCoreTextStyle style;
     WebCoreInitializeEmptyTextStyle(&style);
-    style.rtl = rtl;
-    style.directionalOverride = visuallyOrdered;
+    style.rtl = textStyle.rtl();
+    style.directionalOverride = textStyle.directionalOverride();
     style.letterSpacing = letterSpacing();
     style.wordSpacing = wordSpacing();
     style.smallCaps = fontDescription().smallCaps();
     style.families = families;    
-    style.padding = toAdd;
-    style.tabWidth = tabWidth;
-    style.xpos = xpos;
+    style.padding = textStyle.padding();
+    style.tabWidth = textStyle.tabWidth();
+    style.xpos = textStyle.xPos();
     WebCoreTextGeometry geometry;
     WebCoreInitializeEmptyTextGeometry(&geometry);
     geometry.point = point;
@@ -501,15 +499,14 @@ FloatRect Font::selectionRectForText(const TextRun& textRun, const IntPoint& poi
     return m_fontList->primaryFont(fontDescription())->selectionRectForRun(&run, &style, &geometry);
 }
 
-void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run, const IntPoint& point, int tabWidth, int xpos,
-                           int toAdd, TextDirection d, bool visuallyOrdered) const
+void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run, const TextStyle& style, const IntPoint& point) const
 {
     OSStatus status;
     
     int runLength = run.length();
 
-    TextRun adjustedRun = visuallyOrdered ? addDirectionalOverride(run, d == RTL) : run;
-    ATSULayoutParameters params(adjustedRun, toAdd, d, true, true);
+    TextRun adjustedRun = style.directionalOverride() ? addDirectionalOverride(run, style.rtl()) : run;
+    ATSULayoutParameters params(adjustedRun, style);
     params.initialize(this);
 
     [nsColor(graphicsContext->pen().color()) set];
@@ -540,13 +537,13 @@ void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run,
 
     disposeATSULayoutParameters(&params);
     
-    if (visuallyOrdered)
+    if (style.directionalOverride())
         delete []adjustedRun.characters();
 }
 
-float Font::floatWidthForComplexText(const TextRun& run, int tabWidth, int xpos, bool runRounding) const
+float Font::floatWidthForComplexText(const TextRun& run, const TextStyle& style) const
 {
-    ATSULayoutParameters params(run, 0, LTR, true, runRounding);
+    ATSULayoutParameters params(run, style);
     params.initialize(this);
     
     OSStatus status;
@@ -565,7 +562,7 @@ float Font::floatWidthForComplexText(const TextRun& run, int tabWidth, int xpos,
            MIN(FixedToFloat(firstGlyphBounds.upperLeft.x), FixedToFloat(firstGlyphBounds.lowerLeft.x));
 }
 
-int Font::checkSelectionPoint(const TextRun& textRun, int toAdd, int tabWidth, int xpos, int x, TextDirection d, bool visuallyOrdered, bool includePartialGlyphs) const
+int Font::offsetForPosition(const TextRun& textRun, const TextStyle& textStyle, int x, bool includePartialGlyphs) const
 {
     assert(m_fontList);
     CREATE_FAMILY_ARRAY(fontDescription(), families);
@@ -579,11 +576,11 @@ int Font::checkSelectionPoint(const TextRun& textRun, int toAdd, int tabWidth, i
     style.wordSpacing = wordSpacing();
     style.smallCaps = fontDescription().smallCaps();
     style.families = families;
-    style.padding = toAdd;
-    style.tabWidth = tabWidth;
-    style.xpos = xpos;
-    style.rtl =  d == RTL;
-    style.directionalOverride = visuallyOrdered;
+    style.padding = textStyle.padding();
+    style.tabWidth = textStyle.tabWidth();
+    style.xpos = textStyle.xPos();
+    style.rtl = textStyle.rtl();
+    style.directionalOverride = textStyle.directionalOverride();
 
     return m_fontList->primaryFont(fontDescription())->pointToOffset(&run, &style, x, includePartialGlyphs);
 }
index 119a3b64e76a25d4d1d4be8f34e4ff5dccfb52d6..5812a45a6672219e9fe0c7c95e1ce0f3f9976033 100644 (file)
@@ -118,8 +118,8 @@ IntRect InlineTextBox::selectionRect(int tx, int ty, int startPos, int endPos)
     const Font *f = textObj->font(m_firstLine);
 
     IntRect r = enclosingIntRect(f->selectionRectForText(TextRun(textObj->string(), m_start, m_len, sPos, ePos),
-                                        IntPoint(tx + m_x, ty + selTop), selHeight, textObj->tabWidth(), textPos(), 
-                                        m_toAdd, m_reversed, m_dirOverride));
+                                                         TextStyle(textObj->tabWidth(), textPos(), m_toAdd, m_reversed, m_dirOverride),
+                                                         IntPoint(tx + m_x, ty + selTop), selHeight));
     if (r.x() > tx + m_x + m_width)
         r.setWidth(0);
     else if (r.right() - 1 > tx + m_x + m_width)
@@ -327,6 +327,8 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
 
     StringImpl* textStr = textObject()->string();
 
+    TextStyle textStyle(textObject()->tabWidth(), textPos(), m_toAdd, m_reversed, m_dirOverride || styleToUse->visuallyOrdered());
+
     if (!paintSelectedTextOnly && !paintSelectedTextSeparately) {
         // paint all the text
         // FIXME: Handle RTL direction, handle reversed strings.  For now truncation can only be turned on
@@ -334,24 +336,19 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
         int endPoint = m_len;
         if (m_truncation != cNoTruncation)
             endPoint = m_truncation - m_start;
-        i.p->drawText(TextRun(textStr, m_start, endPoint),
-                      IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                      m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered());
+        i.p->drawText(TextRun(textStr, m_start, endPoint), IntPoint(m_x + tx, m_y + ty + m_baseline), textStyle);
     } else {
         int sPos, ePos;
         selectionStartEnd(sPos, ePos);
         if (paintSelectedTextSeparately) {
             // paint only the text that is not selected
             if (sPos >= ePos)
-                i.p->drawText(TextRun(textStr, m_start, m_len), IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                              m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered());
+                i.p->drawText(TextRun(textStr, m_start, m_len), IntPoint(m_x + tx, m_y + ty + m_baseline), textStyle);
             else {
                 if (sPos - 1 >= 0)
-                    i.p->drawText(TextRun(textStr, m_start, m_len, 0, sPos), IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                                  m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered());
+                    i.p->drawText(TextRun(textStr, m_start, m_len, 0, sPos), IntPoint(m_x + tx, m_y + ty + m_baseline), textStyle);
                 if (ePos < m_start + m_len)
-                    i.p->drawText(TextRun(textStr, m_start, m_len, ePos), IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                                  m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered());
+                    i.p->drawText(TextRun(textStr, m_start, m_len, ePos), IntPoint(m_x + tx, m_y + ty + m_baseline), textStyle);
             }
         }
             
@@ -364,8 +361,7 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
                 i.p->setShadow(IntSize(selectionTextShadow->x, selectionTextShadow->y),
                                selectionTextShadow->blur,
                                selectionTextShadow->color);
-            i.p->drawText(TextRun(textStr, m_start, m_len, sPos, ePos), IntPoint(m_x + tx, m_y + ty + m_baseline), textObject()->tabWidth(), textPos(),
-                          m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || styleToUse->visuallyOrdered());
+            i.p->drawText(TextRun(textStr, m_start, m_len, sPos, ePos), IntPoint(m_x + tx, m_y + ty + m_baseline), textStyle);
             if (selectionTextShadow)
                 i.p->clearShadow();
         }
@@ -448,8 +444,8 @@ void InlineTextBox::paintSelection(GraphicsContext* p, int tx, int ty, RenderSty
     int y = r->selectionTop();
     int h = r->selectionHeight();
     p->addClip(IntRect(m_x + tx, y + ty, m_width, h));
-    p->drawHighlightForText(TextRun(textObject()->string(), m_start, m_len, sPos, ePos), IntPoint(m_x + tx, y + ty), h, textObject()->tabWidth(), textPos(), 
-                            m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), c);
+    p->drawHighlightForText(TextRun(textObject()->string(), m_start, m_len, sPos, ePos), IntPoint(m_x + tx, y + ty), h, 
+                            TextStyle(textObject()->tabWidth(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()), c);
     p->restore();
 }
 
@@ -472,8 +468,8 @@ void InlineTextBox::paintMarkedTextBackground(GraphicsContext* p, int tx, int ty
     int y = r->selectionTop();
     int h = r->selectionHeight();
     p->drawHighlightForText(TextRun(textObject()->string(), m_start, m_len, sPos, ePos),
-                            IntPoint(m_x + tx, y + ty), h, textObject()->tabWidth(), textPos(),
-                            m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), c);
+                            IntPoint(m_x + tx, y + ty), h, 
+                            TextStyle(textObject()->tabWidth(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()), c);
     p->restore();
 }
 
@@ -571,8 +567,8 @@ void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, int _tx, int _ty,
     int sPos = max(marker.startOffset - m_start, (unsigned)0);
     int ePos = min(marker.endOffset - m_start, (unsigned)m_len);
     
-    pt->drawHighlightForText(TextRun(textObject()->string(), m_start, m_len, sPos, ePos), IntPoint(m_x + _tx, y + _ty), h, textObject()->tabWidth(), textPos(), 
-                             m_toAdd, m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), yellow);
+    pt->drawHighlightForText(TextRun(textObject()->string(), m_start, m_len, sPos, ePos), IntPoint(m_x + _tx, y + _ty), h,
+                             TextStyle(textObject()->tabWidth(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()), yellow);
     pt->restore();
 }
 
@@ -685,9 +681,9 @@ int InlineTextBox::offsetForPosition(int _x, bool includePartialGlyphs) const
     RenderText* text = static_cast<RenderText*>(m_object);
     RenderStyle *style = text->style(m_firstLine);
     const Font* f = &style->font();
-    return f->checkSelectionPoint(TextRun(textObject()->string(), m_start, m_len),
-                                  m_toAdd, text->tabWidth(), textPos(), _x - m_x,
-                                  m_reversed ? RTL : LTR, m_dirOverride || style->visuallyOrdered(), includePartialGlyphs);
+    return f->offsetForPosition(TextRun(textObject()->string(), m_start, m_len),
+                                TextStyle(text->tabWidth(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()),
+                                _x - m_x, includePartialGlyphs);
 }
 
 int InlineTextBox::positionForOffset(int offset) const
@@ -700,7 +696,9 @@ int InlineTextBox::positionForOffset(int offset) const
     int from = m_reversed ? offset - m_start : 0;
     int to = m_reversed ? m_len : offset - m_start;
     // FIXME: Do we need to add rightBearing here?
-    return enclosingIntRect(f->selectionRectForText(TextRun(text->string(), m_start, m_len, from, to), IntPoint(m_x, 0), 0, text->tabWidth(), textPos(), m_toAdd, m_reversed, m_dirOverride)).right();
+    return enclosingIntRect(f->selectionRectForText(TextRun(text->string(), m_start, m_len, from, to),
+                                                    TextStyle(text->tabWidth(), textPos(), m_reversed, m_dirOverride),
+                                                    IntPoint(m_x, 0), 0)).right();
 }
 
 }
index 05905f21f54eba4469fc010210c4ac5746d9857d..a4073b9dbb4d355cf615b005540aa65bdfeb78ca 100644 (file)
@@ -486,7 +486,7 @@ ALWAYS_INLINE int RenderText::widthFromCache(const Font* f, int start, int len,
         return w;
     }
     
-    return f->width(TextRun(string(), start, len, 0), tabWidth, xpos);
+    return f->width(TextRun(string(), start, len, 0), TextStyle(tabWidth, xpos));
 }
 
 void RenderText::trimmedMinMaxWidth(int leadWidth,
@@ -704,7 +704,7 @@ void RenderText::calcMinMaxWidth(int leadWidth)
             }
             else
             {
-                currMaxWidth += f->width(TextRun(txt + i, 1), tabWidth(), leadWidth + currMaxWidth);
+                currMaxWidth += f->width(TextRun(txt + i, 1), TextStyle(tabWidth(), leadWidth + currMaxWidth));
                 needsWordSpacing = isSpace && !previousCharacterIsSpace && i == len-1;
             }
         }
@@ -995,7 +995,7 @@ unsigned int RenderText::width(unsigned int from, unsigned int len, const Font *
     else if (f == &style()->font())
         w = widthFromCache(f, from, len, tabWidth(), xpos);
     else
-        w = f->width(TextRun(string(), from, len, 0), tabWidth(), xpos );
+        w = f->width(TextRun(string(), from, len, 0), TextStyle(tabWidth(), xpos));
         
     return w;
 }
index 1b194df74645fe116802f94cf39b7324340f1e7f..3015da21aa8aedf2c5c37ccbc974b68ae7fd8c8f 100644 (file)
@@ -230,10 +230,8 @@ void RenderTextField::calcMinMaxWidth()
         if (size <= 0)
             size = 20;
 
-        // FIXME: Once we have a struct that can hold rounding hack info, we will be able to just use the 
-        // normal width method (and make floatWidth properly private).
         const UChar ch = '0';
-        int sizeWidth = (int)ceilf(style()->font().floatWidth(TextRun(&ch, 1), 0, 0, false) * size);
+        int sizeWidth = (int)ceilf(style()->font().floatWidth(TextRun(&ch, 1), TextStyle(0, 0, 0, false, false, false)) * size);
         m_maxWidth = sizeWidth;
     }
     
index 9b14d4d8cdc7487b870427f67784ab555bd2f822..2d1db68c113c2f0cc91f96c107fbecaaeadde67e 100644 (file)
@@ -1086,7 +1086,7 @@ void EllipsisBox::paint(RenderObject::PaintInfo& i, int _tx, int _ty)
     }
 
     const String& str = m_str;
-    p->drawText(TextRun(str.impl()), IntPoint(m_x + _tx, m_y + _ty + m_baseline), 0, 0, 0, LTR, _style->visuallyOrdered());
+    p->drawText(TextRun(str.impl()), IntPoint(m_x + _tx, m_y + _ty + m_baseline), TextStyle(0, 0, 0, false, _style->visuallyOrdered()));
 
     if (setShadow)
         p->clearShadow();