Changeset 28298 in webkit

Timestamp:

Dec 1, 2007, 8:28:57 AM (17 years ago)

Author:

mitz@apple.com

Message:

Reviewed by Darin Adler.

• fold FontStyle into TextRun

• WebCore.xcodeproj/project.pbxproj:
• platform/graphics/Font.cpp: (WebCore::WidthIterator::WidthIterator): (WebCore::WidthIterator::advance): (WebCore::Font::width): (WebCore::Font::drawSimpleText): (WebCore::Font::drawGlyphBuffer): (WebCore::Font::drawText): (WebCore::Font::floatWidth): (WebCore::Font::floatWidthForSimpleText): (WebCore::Font::selectionRectForText): (WebCore::Font::selectionRectForSimpleText): (WebCore::Font::offsetForPosition): (WebCore::Font::offsetForPositionForSimpleText):
• platform/graphics/Font.h: (WebCore::TextRun::TextRun): (WebCore::TextRun::setText): (WebCore::TextRun::allowTabs): (WebCore::TextRun::xPos): (WebCore::TextRun::padding): (WebCore::TextRun::rtl): (WebCore::TextRun::ltr): (WebCore::TextRun::directionalOverride): (WebCore::TextRun::applyRunRounding): (WebCore::TextRun::applyWordRounding): (WebCore::TextRun::spacingDisabled): (WebCore::TextRun::disableSpacing): (WebCore::TextRun::disableRoundingHacks): (WebCore::TextRun::setRTL): (WebCore::TextRun::setDirectionalOverride):
• platform/graphics/FontStyle.h: Removed.
• platform/graphics/GraphicsContext.cpp: (WebCore::GraphicsContext::drawText): (WebCore::GraphicsContext::drawBidiText): (WebCore::GraphicsContext::drawHighlightForText):
• platform/graphics/GraphicsContext.h:
• platform/graphics/StringTruncator.cpp: (WebCore::stringWidth):
• platform/graphics/gtk/FontGtk.cpp: (WebCore::Font::drawComplexText): (WebCore::Font::floatWidthForComplexText): (WebCore::Font::offsetForPositionForComplexText): (WebCore::Font::selectionRectForComplexText):
• platform/graphics/mac/FontMac.mm: (WebCore::ATSULayoutParameters::ATSULayoutParameters): (WebCore::addDirectionalOverride): (WebCore::overrideLayoutOperation): (WebCore::ATSULayoutParameters::initialize): (WebCore::Font::selectionRectForComplexText): (WebCore::Font::drawComplexText): (WebCore::Font::floatWidthForComplexText): (WebCore::Font::offsetForPositionForComplexText):
• platform/graphics/qt/FontQt.cpp: (WebCore::generateComponents): (WebCore::Font::drawText): (WebCore::Font::width): (WebCore::Font::offsetForPosition): (WebCore::cursorToX): (WebCore::Font::selectionRectForText):
• platform/graphics/win/FontWin.cpp: (WebCore::Font::selectionRectForComplexText): (WebCore::Font::drawComplexText): (WebCore::Font::floatWidthForComplexText): (WebCore::Font::offsetForPositionForComplexText):
• platform/graphics/wx/FontWx.cpp: (WebCore::Font::selectionRectForComplexText): (WebCore::Font::drawComplexText): (WebCore::Font::floatWidthForComplexText): (WebCore::Font::offsetForPositionForComplexText):
• platform/mac/WebCoreTextRenderer.mm: (WebCoreDrawTextAtPoint): (WebCoreTextFloatWidth):
• platform/win/PopupMenuWin.cpp: (WebCore::PopupMenu::paint):
• platform/win/UniscribeController.cpp: (WebCore::UniscribeController::UniscribeController): (WebCore::UniscribeController::offsetForPosition): (WebCore::UniscribeController::advance): (WebCore::UniscribeController::itemizeShapeAndPlace): (WebCore::UniscribeController::resetControlAndState): (WebCore::UniscribeController::shapeAndPlaceItem):
• platform/win/UniscribeController.h:
• platform/win/WebCoreTextRenderer.cpp: (WebCore::doDrawTextAtPoint):
• rendering/EllipsisBox.cpp: (WebCore::EllipsisBox::paint):
• rendering/InlineTextBox.cpp: (WebCore::InlineTextBox::selectionRect): (WebCore::InlineTextBox::paint): (WebCore::InlineTextBox::paintSelection): (WebCore::InlineTextBox::paintCompositionBackground): (WebCore::InlineTextBox::paintSpellingOrGrammarMarker): (WebCore::InlineTextBox::paintTextMatchMarker): (WebCore::InlineTextBox::offsetForPosition): (WebCore::InlineTextBox::positionForOffset):
• rendering/RenderFileUploadControl.cpp: (WebCore::RenderFileUploadControl::paintObject): (WebCore::RenderFileUploadControl::calcPrefWidths):
• rendering/RenderImage.cpp:
• rendering/RenderListBox.cpp: (WebCore::RenderListBox::updateFromElement): (WebCore::RenderListBox::paintItemForeground):
• rendering/RenderMenuList.cpp: (WebCore::RenderMenuList::updateOptionsWidth):
• rendering/RenderText.cpp: (WebCore::RenderText::widthFromCache): (WebCore::RenderText::calcPrefWidths): (WebCore::RenderText::width):
• rendering/RenderText.h: (WebCore::RenderText::allowTabs):
• rendering/RenderTextControl.cpp: (WebCore::RenderTextControl::calcPrefWidths):
• rendering/SVGInlineTextBox.cpp: (WebCore::SVGInlineTextBox::calculateGlyphWidth): (WebCore::SVGInlineTextBox::paintCharacters): (WebCore::SVGInlineTextBox::paintSelection):
• rendering/SVGRootInlineBox.cpp: (WebCore::SVGRootInlineBoxPaintWalker::chunkPortionCallback): (WebCore::cummulatedWidthOfInlineBoxCharacterRange): (WebCore::svgTextRunForInlineTextBox):
• rendering/SVGRootInlineBox.h:

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.xcodeproj/project.pbxproj (modified) (4 diffs)
• platform/graphics/Font.cpp (modified) (20 diffs)
• platform/graphics/Font.h (modified) (5 diffs)
• platform/graphics/FontStyle.h (deleted)
• platform/graphics/GraphicsContext.cpp (modified) (5 diffs)
• platform/graphics/GraphicsContext.h (modified) (2 diffs)
• platform/graphics/StringTruncator.cpp (modified) (2 diffs)
• platform/graphics/gtk/FontGtk.cpp (modified) (3 diffs)
• platform/graphics/mac/FontMac.mm (modified) (20 diffs)
• platform/graphics/qt/FontQt.cpp (modified) (20 diffs)
• platform/graphics/win/FontWin.cpp (modified) (7 diffs)
• platform/graphics/wx/FontWx.cpp (modified) (3 diffs)
• platform/mac/WebCoreTextRenderer.mm (modified) (3 diffs)
• platform/win/PopupMenuWin.cpp (modified) (3 diffs)
• platform/win/UniscribeController.cpp (modified) (15 diffs)
• platform/win/UniscribeController.h (modified) (2 diffs)
• platform/win/WebCoreTextRenderer.cpp (modified) (3 diffs)
• rendering/EllipsisBox.cpp (modified) (2 diffs)
• rendering/InlineTextBox.cpp (modified) (13 diffs)
• rendering/RenderFileUploadControl.cpp (modified) (4 diffs)
• rendering/RenderImage.cpp (modified) (1 diff)
• rendering/RenderListBox.cpp (modified) (4 diffs)
• rendering/RenderMenuList.cpp (modified) (2 diffs)
• rendering/RenderText.cpp (modified) (4 diffs)
• rendering/RenderText.h (modified) (1 diff)
• rendering/RenderTextControl.cpp (modified) (2 diffs)
• rendering/SVGInlineTextBox.cpp (modified) (4 diffs)
• rendering/SVGRootInlineBox.cpp (modified) (4 diffs)
• rendering/SVGRootInlineBox.h (modified) (1 diff)

trunk/WebCore/ChangeLog

@@ +1 @@
+2007-12-01  Dan Bernstein  <mitz@apple.com>
+
+        Reviewed by Darin Adler.
+
+        - fold FontStyle into TextRun
+
+        * WebCore.xcodeproj/project.pbxproj:
+        * platform/graphics/Font.cpp:
+        (WebCore::WidthIterator::WidthIterator):
+        (WebCore::WidthIterator::advance):
+        (WebCore::Font::width):
+        (WebCore::Font::drawSimpleText):
+        (WebCore::Font::drawGlyphBuffer):
+        (WebCore::Font::drawText):
+        (WebCore::Font::floatWidth):
+        (WebCore::Font::floatWidthForSimpleText):
+        (WebCore::Font::selectionRectForText):
+        (WebCore::Font::selectionRectForSimpleText):
+        (WebCore::Font::offsetForPosition):
+        (WebCore::Font::offsetForPositionForSimpleText):
+        * platform/graphics/Font.h:
+        (WebCore::TextRun::TextRun):
+        (WebCore::TextRun::setText):
+        (WebCore::TextRun::allowTabs):
+        (WebCore::TextRun::xPos):
+        (WebCore::TextRun::padding):
+        (WebCore::TextRun::rtl):
+        (WebCore::TextRun::ltr):
+        (WebCore::TextRun::directionalOverride):
+        (WebCore::TextRun::applyRunRounding):
+        (WebCore::TextRun::applyWordRounding):
+        (WebCore::TextRun::spacingDisabled):
+        (WebCore::TextRun::disableSpacing):
+        (WebCore::TextRun::disableRoundingHacks):
+        (WebCore::TextRun::setRTL):
+        (WebCore::TextRun::setDirectionalOverride):
+        * platform/graphics/FontStyle.h: Removed.
+        * platform/graphics/GraphicsContext.cpp:
+        (WebCore::GraphicsContext::drawText):
+        (WebCore::GraphicsContext::drawBidiText):
+        (WebCore::GraphicsContext::drawHighlightForText):
+        * platform/graphics/GraphicsContext.h:
+        * platform/graphics/StringTruncator.cpp:
+        (WebCore::stringWidth):
+        * platform/graphics/gtk/FontGtk.cpp:
+        (WebCore::Font::drawComplexText):
+        (WebCore::Font::floatWidthForComplexText):
+        (WebCore::Font::offsetForPositionForComplexText):
+        (WebCore::Font::selectionRectForComplexText):
+        * platform/graphics/mac/FontMac.mm:
+        (WebCore::ATSULayoutParameters::ATSULayoutParameters):
+        (WebCore::addDirectionalOverride):
+        (WebCore::overrideLayoutOperation):
+        (WebCore::ATSULayoutParameters::initialize):
+        (WebCore::Font::selectionRectForComplexText):
+        (WebCore::Font::drawComplexText):
+        (WebCore::Font::floatWidthForComplexText):
+        (WebCore::Font::offsetForPositionForComplexText):
+        * platform/graphics/qt/FontQt.cpp:
+        (WebCore::generateComponents):
+        (WebCore::Font::drawText):
+        (WebCore::Font::width):
+        (WebCore::Font::offsetForPosition):
+        (WebCore::cursorToX):
+        (WebCore::Font::selectionRectForText):
+        * platform/graphics/win/FontWin.cpp:
+        (WebCore::Font::selectionRectForComplexText):
+        (WebCore::Font::drawComplexText):
+        (WebCore::Font::floatWidthForComplexText):
+        (WebCore::Font::offsetForPositionForComplexText):
+        * platform/graphics/wx/FontWx.cpp:
+        (WebCore::Font::selectionRectForComplexText):
+        (WebCore::Font::drawComplexText):
+        (WebCore::Font::floatWidthForComplexText):
+        (WebCore::Font::offsetForPositionForComplexText):
+        * platform/mac/WebCoreTextRenderer.mm:
+        (WebCoreDrawTextAtPoint):
+        (WebCoreTextFloatWidth):
+        * platform/win/PopupMenuWin.cpp:
+        (WebCore::PopupMenu::paint):
+        * platform/win/UniscribeController.cpp:
+        (WebCore::UniscribeController::UniscribeController):
+        (WebCore::UniscribeController::offsetForPosition):
+        (WebCore::UniscribeController::advance):
+        (WebCore::UniscribeController::itemizeShapeAndPlace):
+        (WebCore::UniscribeController::resetControlAndState):
+        (WebCore::UniscribeController::shapeAndPlaceItem):
+        * platform/win/UniscribeController.h:
+        * platform/win/WebCoreTextRenderer.cpp:
+        (WebCore::doDrawTextAtPoint):
+        * rendering/EllipsisBox.cpp:
+        (WebCore::EllipsisBox::paint):
+        * rendering/InlineTextBox.cpp:
+        (WebCore::InlineTextBox::selectionRect):
+        (WebCore::InlineTextBox::paint):
+        (WebCore::InlineTextBox::paintSelection):
+        (WebCore::InlineTextBox::paintCompositionBackground):
+        (WebCore::InlineTextBox::paintSpellingOrGrammarMarker):
+        (WebCore::InlineTextBox::paintTextMatchMarker):
+        (WebCore::InlineTextBox::offsetForPosition):
+        (WebCore::InlineTextBox::positionForOffset):
+        * rendering/RenderFileUploadControl.cpp:
+        (WebCore::RenderFileUploadControl::paintObject):
+        (WebCore::RenderFileUploadControl::calcPrefWidths):
+        * rendering/RenderImage.cpp:
+        * rendering/RenderListBox.cpp:
+        (WebCore::RenderListBox::updateFromElement):
+        (WebCore::RenderListBox::paintItemForeground):
+        * rendering/RenderMenuList.cpp:
+        (WebCore::RenderMenuList::updateOptionsWidth):
+        * rendering/RenderText.cpp:
+        (WebCore::RenderText::widthFromCache):
+        (WebCore::RenderText::calcPrefWidths):
+        (WebCore::RenderText::width):
+        * rendering/RenderText.h:
+        (WebCore::RenderText::allowTabs):
+        * rendering/RenderTextControl.cpp:
+        (WebCore::RenderTextControl::calcPrefWidths):
+        * rendering/SVGInlineTextBox.cpp:
+        (WebCore::SVGInlineTextBox::calculateGlyphWidth):
+        (WebCore::SVGInlineTextBox::paintCharacters):
+        (WebCore::SVGInlineTextBox::paintSelection):
+        * rendering/SVGRootInlineBox.cpp:
+        (WebCore::SVGRootInlineBoxPaintWalker::chunkPortionCallback):
+        (WebCore::cummulatedWidthOfInlineBoxCharacterRange):
+        (WebCore::svgTextRunForInlineTextBox):
+        * rendering/SVGRootInlineBox.h:
+
 2007-12-01  Adam Treat  <treat@kde.org>
 

trunk/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -2972 +2972 @@
                 B24055660B5BE640002A28C0 /* DOMSVGElementInstanceListInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = B24055640B5BE640002A28C0 /* DOMSVGElementInstanceListInternal.h */; };
                 B25DFAAF0B2E2929000E6510 /* JSSVGMatrixCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B25DFAAE0B2E2929000E6510 /* JSSVGMatrixCustom.cpp */; };
-                B25E96BE0D00975100CFD296 /* FontStyle.h in Headers */ = {isa = PBXBuildFile; fileRef = B25E96BD0D00975100CFD296 /* FontStyle.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 B26554EA0B80D74900A50EC3 /* RenderSVGTextPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B26554E80B80D74900A50EC3 /* RenderSVGTextPath.cpp */; };
                 B26554EB0B80D74900A50EC3 /* RenderSVGTextPath.h in Headers */ = {isa = PBXBuildFile; fileRef = B26554E90B80D74900A50EC3 /* RenderSVGTextPath.h */; };
@@ -6961 +6960 @@
                 B24055640B5BE640002A28C0 /* DOMSVGElementInstanceListInternal.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = DOMSVGElementInstanceListInternal.h; sourceTree = "<group>"; };
                 B25DFAAE0B2E2929000E6510 /* JSSVGMatrixCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSSVGMatrixCustom.cpp; sourceTree = "<group>"; };
-                B25E96BD0D00975100CFD296 /* FontStyle.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = FontStyle.h; sourceTree = "<group>"; };
                 B26554E80B80D74900A50EC3 /* RenderSVGTextPath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = RenderSVGTextPath.cpp; sourceTree = "<group>"; };
                 B26554E90B80D74900A50EC3 /* RenderSVGTextPath.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = RenderSVGTextPath.h; sourceTree = "<group>"; };
@@ -11008 +11006 @@
                         isa = PBXGroup;
                         children = (
-                                B25E96BD0D00975100CFD296 /* FontStyle.h */,
                                 B23540F00D00782E002382FA /* StringTruncator.cpp */,
                                 B23540F10D00782E002382FA /* StringTruncator.h */,
@@ -13924 +13921 @@
                                 B2C3DA700D006CD600EF6F26 /* GlyphWidthMap.h in Headers */,
                                 B23540F30D00782E002382FA /* StringTruncator.h in Headers */,
-                                B25E96BE0D00975100CFD296 /* FontStyle.h in Headers */,
                                 B2AFFC7E0D00A5C10030074D /* FontCustomPlatformData.h in Headers */,
                                 B2AFFC810D00A5C10030074D /* FontPlatformData.h in Headers */,

trunk/WebCore/platform/graphics/Font.cpp

@@ -33 +33 @@
 #include "IntPoint.h"
 #include "GlyphBuffer.h"
-#include "FontStyle.h"
 #include <wtf/unicode/Unicode.h>
 #include <wtf/MathExtras.h>
@@ -63 +62 @@
 
 struct WidthIterator {
-    WidthIterator(const Font* font, const TextRun& run, const FontStyle& style);
+    WidthIterator(const Font* font, const TextRun& run);
 
     void advance(int to, GlyphBuffer* glyphBuffer = 0);
@@ -73 +72 @@
     int m_end;
 
-    const FontStyle& m_style;
-    
     unsigned m_currentCharacter;
     float m_runWidthSoFar;
@@ -85 +82 @@
 };
 
-WidthIterator::WidthIterator(const Font* font, const TextRun& run, const FontStyle& style)
+WidthIterator::WidthIterator(const Font* font, const TextRun& run)
     : m_font(font)
     , m_run(run)
     , m_end(run.length())
-    , m_style(style)
     , m_currentCharacter(0)
     , m_runWidthSoFar(0)
@@ -96 +92 @@
     // If the padding is non-zero, count the number of spaces in the run
     // and divide that by the padding for per space addition.
-    m_padding = m_style.padding();
+    m_padding = m_run.padding();
     if (!m_padding)
         m_padPerSpace = 0;
@@ -108 +104 @@
             m_padPerSpace = 0;
         else
-            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
+            m_padPerSpace = ceilf(m_run.padding() / numSpaces);
     }
 }
@@ -120 +116 @@
     const UChar* cp = m_run.data(currentCharacter);
 
-    bool rtl = m_style.rtl();
+    bool rtl = m_run.rtl();
     bool hasExtraSpacing = m_font->letterSpacing() || m_font->wordSpacing() || m_padding;
 
@@ -164 +160 @@
         // Now that we have a glyph and font data, get its width.
         float width;
-        if (c == '\t' && m_style.allowTabs()) {
+        if (c == '\t' && m_run.allowTabs()) {
             float tabWidth = m_font->tabWidth();
-            width = tabWidth - fmodf(m_style.xPos() + runWidthSoFar, tabWidth);
+            width = tabWidth - fmodf(m_run.xPos() + runWidthSoFar, tabWidth);
         } else {
             width = fontData->widthForGlyph(glyph);
@@ -173 +169 @@
             // 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_style.applyWordRounding())
+            if (width == fontData->m_spaceWidth && (fontData->m_treatAsFixedPitch || glyph == fontData->m_spaceGlyph) && m_run.applyWordRounding())
                 width = fontData->m_adjustedSpaceWidth;
         }
 
-        if (hasExtraSpacing && !m_style.spacingDisabled()) {
+        if (hasExtraSpacing && !m_run.spacingDisabled()) {
             // Account for letter-spacing.
             if (width && m_font->letterSpacing())
@@ -216 +212 @@
         // 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_style.applyWordRounding() && Font::isRoundingHackCharacter(c))
+        if (m_run.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_style.applyWordRounding() && currentCharacter < m_run.length() && Font::isRoundingHackCharacter(*cp))
-                || (m_style.applyRunRounding() && currentCharacter >= m_end)) {
+        if ((m_run.applyWordRounding() && currentCharacter < m_run.length() && Font::isRoundingHackCharacter(*cp))
+                || (m_run.applyRunRounding() && currentCharacter >= m_end)) {
             float totalWidth = runWidthSoFar + width;
             width += ceilf(totalWidth) - totalWidth;
@@ -511 +507 @@
 int Font::width(const TextRun& run) const
 {
-    return width(run, FontStyle());
-}
-
-int Font::width(const TextRun& run, const FontStyle& style) const
-{
-    return lroundf(floatWidth(run, style));
+    return lroundf(floatWidth(run));
 }
 
@@ -619 +610 @@
 }
 
-void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const FontStyle& style, const FloatPoint& point, int from, int to) const
+void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
 {
     // This glyph buffer holds our glyphs+advances+font data for each glyph.
@@ -625 +616 @@
 
     float startX = point.x();
-    WidthIterator it(this, run, style);
+    WidthIterator it(this, run);
     it.advance(from);
     float beforeWidth = it.m_runWidthSoFar;
@@ -636 +627 @@
     float afterWidth = it.m_runWidthSoFar;
 
-    if (style.rtl()) {
+    if (run.rtl()) {
         float finalRoundingWidth = it.m_finalRoundingWidth;
         it.advance(run.length());
@@ -644 +635 @@
 
     // Swap the order of the glyphs if right-to-left.
-    if (style.rtl())
+    if (run.rtl())
         for (int i = 0, end = glyphBuffer.size() - 1; i < glyphBuffer.size() / 2; ++i, --end)
             glyphBuffer.swap(i, end);
@@ -651 +642 @@
     // all the advances up to the first glyph.
     FloatPoint startPoint(startX, point.y());
-    drawGlyphBuffer(context, glyphBuffer, run, style, startPoint);
+    drawGlyphBuffer(context, glyphBuffer, run, startPoint);
 }
 
 void Font::drawGlyphBuffer(GraphicsContext* context, const GlyphBuffer& glyphBuffer, 
-                           const TextRun& run, const FontStyle& style, const FloatPoint& point) const
+                           const TextRun& run, const FloatPoint& point) const
 {   
     // Draw each contiguous run of glyphs that use the same font data.
@@ -680 +671 @@
 }
 
-void Font::drawText(GraphicsContext* context, const TextRun& run, const FontStyle& style, const FloatPoint& point, int from, int to) const
+void Font::drawText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
 {
     // Don't draw anything while we are using custom fonts that are in the process of loading.
@@ -688 +679 @@
     to = (to == -1 ? run.length() : to);
     if (canUseGlyphCache(run))
-        drawSimpleText(context, run, style, point, from, to);
+        drawSimpleText(context, run, point, from, to);
     else
-        drawComplexText(context, run, style, point, from, to);
-}
-
-float Font::floatWidth(const TextRun& run, const FontStyle& style) const
+        drawComplexText(context, run, point, from, to);
+}
+
+float Font::floatWidth(const TextRun& run) const
 {
     if (canUseGlyphCache(run))
-        return floatWidthForSimpleText(run, style, 0);
-    return floatWidthForComplexText(run, style);
-}
-
-float Font::floatWidthForSimpleText(const TextRun& run, const FontStyle& style, GlyphBuffer* glyphBuffer) const
-{
-    WidthIterator it(this, run, style);
+        return floatWidthForSimpleText(run, 0);
+    return floatWidthForComplexText(run);
+}
+
+float Font::floatWidthForSimpleText(const TextRun& run, GlyphBuffer* glyphBuffer) const
+{
+    WidthIterator it(this, run);
     it.advance(run.length(), glyphBuffer);
     return it.m_runWidthSoFar;
 }
 
-FloatRect Font::selectionRectForText(const TextRun& run, const FontStyle& style, const IntPoint& point, int h, int from, int to) const
+FloatRect Font::selectionRectForText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
 {
     to = (to == -1 ? run.length() : to);
     if (canUseGlyphCache(run))
-        return selectionRectForSimpleText(run, style, point, h, from, to);
-    return selectionRectForComplexText(run, style, point, h, from, to);
-}
-
-FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FontStyle& style, const IntPoint& point, int h, int from, int to) const
-{
-    WidthIterator it(this, run, style);
+        return selectionRectForSimpleText(run, point, h, from, to);
+    return selectionRectForComplexText(run, point, h, from, to);
+}
+
+FloatRect Font::selectionRectForSimpleText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
+{
+    WidthIterator it(this, run);
     it.advance(from);
     float beforeWidth = it.m_runWidthSoFar;
@@ -724 +715 @@
 
     // Using roundf() rather than ceilf() for the right edge as a compromise to ensure correct caret positioning
-    if (style.rtl()) {
+    if (run.rtl()) {
         it.advance(run.length());
         float totalWidth = it.m_runWidthSoFar;
@@ -733 +724 @@
 }
 
-int Font::offsetForPosition(const TextRun& run, const FontStyle& style, int x, bool includePartialGlyphs) const
+int Font::offsetForPosition(const TextRun& run, int x, bool includePartialGlyphs) const
 {
     if (canUseGlyphCache(run))
-        return offsetForPositionForSimpleText(run, style, x, includePartialGlyphs);
-    return offsetForPositionForComplexText(run, style, x, includePartialGlyphs);
-}
-
-int Font::offsetForPositionForSimpleText(const TextRun& run, const FontStyle& style, int x, bool includePartialGlyphs) const
+        return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
+    return offsetForPositionForComplexText(run, x, includePartialGlyphs);
+}
+
+int Font::offsetForPositionForSimpleText(const TextRun& run, int x, bool includePartialGlyphs) const
 {
     float delta = (float)x;
 
-    WidthIterator it(this, run, style);
+    WidthIterator it(this, run);
     GlyphBuffer localGlyphBuffer;
     unsigned offset;
-    if (style.rtl()) {
-        delta -= floatWidthForSimpleText(run, style, 0);
+    if (run.rtl()) {
+        delta -= floatWidthForSimpleText(run, 0);
         while (1) {
             offset = it.m_currentCharacter;

trunk/WebCore/platform/graphics/Font.h

@@ -47 +47 @@
 class GraphicsContext;
 class IntPoint;
-class FontStyle;
 
 struct GlyphData;
@@ -53 +52 @@
 class TextRun {
 public:
-    TextRun(const UChar* c, int len)
-    :m_characters(c), m_len(len)
-    {}
-
-    TextRun(const String& s)
-    :m_characters(s.characters()), m_len(s.length())
-    {}
+    TextRun(const UChar* c, int len, bool allowTabs = false, int xpos = 0, int padding = 0, bool rtl = false, bool directionalOverride = false,
+              bool applyRunRounding = true, bool applyWordRounding = true)
+        : m_characters(c)
+        , m_len(len)
+        , m_allowTabs(allowTabs)
+        , m_xpos(xpos)
+        , m_padding(padding)
+        , m_rtl(rtl)
+        , m_directionalOverride(directionalOverride)
+        , m_applyRunRounding(applyRunRounding)
+        , m_applyWordRounding(applyWordRounding)
+        , m_disableSpacing(false)
+    {
+    }
+
+    TextRun(const String& s, bool allowTabs = false, int xpos = 0, int padding = 0, bool rtl = false, bool directionalOverride = false,
+              bool applyRunRounding = true, bool applyWordRounding = true)
+        : m_characters(s.characters())
+        , m_len(s.length())
+        , m_allowTabs(allowTabs)
+        , m_xpos(xpos)
+        , m_padding(padding)
+        , m_rtl(rtl)
+        , m_directionalOverride(directionalOverride)
+        , m_applyRunRounding(applyRunRounding)
+        , m_applyWordRounding(applyWordRounding)
+        , m_disableSpacing(false)
+    {
+    }
 
     const UChar operator[](int i) const { return m_characters[i]; }
@@ -66 +87 @@
     const UChar* characters() const { return m_characters; }
     int length() const { return m_len; }
-   
+
+    void setText(const UChar* c, int len) { m_characters = c; m_len = len; }
+
+    bool allowTabs() const { return m_allowTabs; }
+    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 spacingDisabled() const { return m_disableSpacing; }
+
+    void disableSpacing() { m_disableSpacing = true; }
+    void disableRoundingHacks() { m_applyRunRounding = m_applyWordRounding = false; }
+    void setRTL(bool b) { m_rtl = b; }
+    void setDirectionalOverride(bool override) { m_directionalOverride = override; }
+    
 private:
     const UChar* m_characters;
     int m_len;
+
+    bool m_allowTabs;
+    int m_xpos;
+    int m_padding;
+    bool m_rtl;
+    bool m_directionalOverride;
+    bool m_applyRunRounding;
+    bool m_applyWordRounding;
+    bool m_disableSpacing;
 };
 
@@ -96 +143 @@
     void update(PassRefPtr<FontSelector>) const;
 
-    void drawText(GraphicsContext*, const TextRun&, const FontStyle&, const FloatPoint&, int from = 0, int to = -1) const;
-
-    int width(const TextRun&, const FontStyle&) const;
+    void drawText(GraphicsContext*, const TextRun&, const FloatPoint&, int from = 0, int to = -1) const;
+
     int width(const TextRun&) const;
-    float floatWidth(const TextRun&, const FontStyle&) const;
     float floatWidth(const TextRun&) const;
     
-    int offsetForPosition(const TextRun&, const FontStyle&, int position, bool includePartialGlyphs) const;
-    FloatRect selectionRectForText(const TextRun&, const FontStyle&, const IntPoint&, int h, int from = 0, int to = -1) const;
+    int offsetForPosition(const TextRun&, int position, bool includePartialGlyphs) const;
+    FloatRect selectionRectForText(const TextRun&, const IntPoint&, int h, int from = 0, int to = -1) const;
 
     bool isSmallCaps() const { return m_fontDescription.smallCaps(); }
@@ -151 +196 @@
 private:
     bool canUseGlyphCache(const TextRun&) const;
-    void drawSimpleText(GraphicsContext*, const TextRun&, const FontStyle&, const FloatPoint&, int from, int to) const;
+    void drawSimpleText(GraphicsContext*, const TextRun&, const FloatPoint&, int from, int to) const;
     void drawGlyphs(GraphicsContext*, const FontData*, const GlyphBuffer&, int from, int to, const FloatPoint&) const;
-    void drawGlyphBuffer(GraphicsContext*, const GlyphBuffer&, const TextRun&, const FontStyle&, const FloatPoint&) const;
-    void drawComplexText(GraphicsContext*, const TextRun&, const FontStyle&, const FloatPoint&, int from, int to) const;
-    float floatWidthForSimpleText(const TextRun&, const FontStyle&, GlyphBuffer*) const;
-    float floatWidthForComplexText(const TextRun&, const FontStyle&) const;
-    int offsetForPositionForSimpleText(const TextRun&, const FontStyle&, int position, bool includePartialGlyphs) const;
-    int offsetForPositionForComplexText(const TextRun&, const FontStyle&, int position, bool includePartialGlyphs) const;
-    FloatRect selectionRectForSimpleText(const TextRun&, const FontStyle&, const IntPoint&, int h, int from, int to) const;
-    FloatRect selectionRectForComplexText(const TextRun&, const FontStyle&, const IntPoint&, int h, int from, int to) const;
+    void drawGlyphBuffer(GraphicsContext*, const GlyphBuffer&, const TextRun&, const FloatPoint&) const;
+    void drawComplexText(GraphicsContext*, const TextRun&, const FloatPoint&, int from, int to) const;
+    float floatWidthForSimpleText(const TextRun&, GlyphBuffer*) const;
+    float floatWidthForComplexText(const TextRun&) const;
+    int offsetForPositionForSimpleText(const TextRun&, int position, bool includePartialGlyphs) const;
+    int offsetForPositionForComplexText(const TextRun&, int position, bool includePartialGlyphs) const;
+    FloatRect selectionRectForSimpleText(const TextRun&, const IntPoint&, int h, int from, int to) const;
+    FloatRect selectionRectForComplexText(const TextRun&, const IntPoint&, int h, int from, int to) const;
 #endif
     friend struct WidthIterator;

trunk/WebCore/platform/graphics/GraphicsContext.cpp

@@ -29 +29 @@
 #include "BidiResolver.h"
 #include "Font.h"
-#include "FontStyle.h"
 
 using namespace std;
@@ -244 +243 @@
 void GraphicsContext::drawText(const TextRun& run, const IntPoint& point, int from, int to)
 {
-    drawText(run, point, FontStyle(), from, to);
-}
-
-void GraphicsContext::drawText(const TextRun& run, const IntPoint& point, const FontStyle& style, int from, int to)
-{
-    if (paintingDisabled())
-        return;
-    
-    font().drawText(this, run, style, point, from, to);
-}
-
-void GraphicsContext::drawBidiText(const TextRun& run, const IntPoint& point, const FontStyle& style)
+    if (paintingDisabled())
+        return;
+    
+    font().drawText(this, run, point, from, to);
+}
+
+void GraphicsContext::drawBidiText(const TextRun& run, const IntPoint& point)
 {
     if (paintingDisabled())
@@ -261 +255 @@
 
     BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
-    WTF::Unicode::Direction paragraphDirection = style.ltr() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
-
-    bidiResolver.setStatus(BidiStatus(paragraphDirection, paragraphDirection, paragraphDirection, new BidiContext(style.ltr() ? 0 : 1, paragraphDirection, style.directionalOverride())));
+    WTF::Unicode::Direction paragraphDirection = run.ltr() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
+
+    bidiResolver.setStatus(BidiStatus(paragraphDirection, paragraphDirection, paragraphDirection, new BidiContext(run.ltr() ? 0 : 1, paragraphDirection, run.directionalOverride())));
 
     bidiResolver.createBidiRunsForLine(TextRunIterator(&run, 0), TextRunIterator(&run, run.length()));
@@ -273 +267 @@
     BidiCharacterRun* bidiRun = bidiResolver.firstRun();
     while (bidiRun) {
-        FontStyle subrunStyle(style);
-        subrunStyle.setRTL(bidiRun->level() % 2);
-        subrunStyle.setDirectionalOverride(bidiRun->dirOverride(false));
-
-        TextRun subrun(run.data(bidiRun->start()), bidiRun->stop() - bidiRun->start());
-
-        font().drawText(this, subrun, subrunStyle, currPoint);
+
+        TextRun subrun = run;
+        subrun.setText(run.data(bidiRun->start()), bidiRun->stop() - bidiRun->start());
+        subrun.setRTL(bidiRun->level() % 2);
+        subrun.setDirectionalOverride(bidiRun->dirOverride(false));
+
+        font().drawText(this, subrun, currPoint);
 
         bidiRun = bidiRun->next();
         // FIXME: Have Font::drawText return the width of what it drew so that we don't have to re-measure here.
         if (bidiRun)
-            currPoint.move(font().floatWidth(subrun, subrunStyle), 0.f);
+            currPoint.move(font().floatWidth(subrun), 0.f);
     }
 
@@ -290 +284 @@
 }
 
-void GraphicsContext::drawHighlightForText(const TextRun& run, const IntPoint& point, int h, const FontStyle& style, const Color& backgroundColor, int from, int to)
-{
-    if (paintingDisabled())
-        return;
-
-    fillRect(font().selectionRectForText(run, style, point, h, from, to), backgroundColor);
+void GraphicsContext::drawHighlightForText(const TextRun& run, const IntPoint& point, int h, const Color& backgroundColor, int from, int to)
+{
+    if (paintingDisabled())
+        return;
+
+    fillRect(font().selectionRectForText(run, point, h, from, to), backgroundColor);
 }
 

trunk/WebCore/platform/graphics/GraphicsContext.h

@@ -87 +87 @@
     class Path;
     class TextRun;
-    class FontStyle;
 
     // These bits can be ORed together for a total of 8 possible text drawing modes.
@@ -174 +173 @@
 
         void drawText(const TextRun&, const IntPoint&, int from = 0, int to = -1);
-        void drawText(const TextRun&, const IntPoint&, const FontStyle&, int from = 0, int to = -1);
-        void drawBidiText(const TextRun&, const IntPoint&, const FontStyle&);
-        void drawHighlightForText(const TextRun&, const IntPoint&, int h, const FontStyle&, const Color& backgroundColor, int from = 0, int to = -1);
+        void drawBidiText(const TextRun&, const IntPoint&);
+        void drawHighlightForText(const TextRun&, const IntPoint&, int h, const Color& backgroundColor, int from = 0, int to = -1);
 
         FloatRect roundToDevicePixels(const FloatRect&);

trunk/WebCore/platform/graphics/StringTruncator.cpp

@@ -34 +34 @@
 #include "FontPlatformData.h"
 #include "TextBreakIterator.h"
-#include "FontStyle.h"
 #include <wtf/Assertions.h>
 #include <wtf/Vector.h>
@@ -97 +96 @@
 {
     TextRun run(characters, length);
-    FontStyle style;
     if (disableRoundingHacks)
-        style.disableRoundingHacks();
-    return renderer.floatWidth(run, style);
+        run.disableRoundingHacks();
+    return renderer.floatWidth(run);
 }
 

trunk/WebCore/platform/graphics/gtk/FontGtk.cpp

@@ -62 +62 @@
 }
 
-void Font::drawComplexText(GraphicsContext*, const TextRun&, const FontStyle&, const FloatPoint&, int from, int to) const
+void Font::drawComplexText(GraphicsContext*, const TextRun&, const FloatPoint&, int from, int to) const
 {
     notImplemented();
 }
 
-float Font::floatWidthForComplexText(const TextRun&, const FontStyle&) const
+float Font::floatWidthForComplexText(const TextRun&) const
 {
     notImplemented();
@@ -73 +73 @@
 }
 
-int Font::offsetForPositionForComplexText(const TextRun&, const FontStyle&, int, bool) const
+int Font::offsetForPositionForComplexText(const TextRun&, int, bool) const
 {
     notImplemented();
@@ -79 +79 @@
 }
 
-FloatRect Font::selectionRectForComplexText(const TextRun&, const FontStyle&, const IntPoint&, int, int, int) const
+FloatRect Font::selectionRectForComplexText(const TextRun&, const IntPoint&, int, int, int) const
 {
     notImplemented();

trunk/WebCore/platform/graphics/mac/FontMac.mm

@@ -35 +35 @@
 #import "IntRect.h"
 #import "Logging.h"
-#import "FontStyle.h"
 #import "WebCoreSystemInterface.h"
 #import "WebCoreTextRenderer.h"
@@ -58 +57 @@
 struct ATSULayoutParameters
 {
-    ATSULayoutParameters(const TextRun& run, const FontStyle& style)
+    ATSULayoutParameters(const TextRun& run)
         : m_run(run)
-        , m_style(style)
         , m_font(0)
         , m_fonts(0)
@@ -72 +70 @@
 
     const TextRun& m_run;
-    const FontStyle& m_style;
     
     const Font* m_font;
@@ -93 +90 @@
     charactersWithOverride[run.length() + 1] = popDirectionalFormatting;
 
-    return TextRun(charactersWithOverride, run.length() + 2);
+    TextRun result = run;
+    result.setText(charactersWithOverride, run.length() + 2);
+    return result;
 }
 
@@ -157 +156 @@
     ATSLayoutRecord *layoutRecords;
 
-    if (params->m_style.applyWordRounding()) {
+    if (params->m_run.applyWordRounding()) {
         status = ATSUDirectGetLayoutDataArrayPtrFromLineRef(iLineRef, kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, true, (void **)&layoutRecords, &count);
         if (status != noErr) {
@@ -177 +176 @@
         Fixed syntheticBoldOffset = 0;
         ATSGlyphRef spaceGlyph = 0;
-        bool hasExtraSpacing = params->m_font->letterSpacing() || params->m_font->wordSpacing() | params->m_style.padding();
-        float padding = params->m_style.padding();
+        bool hasExtraSpacing = params->m_font->letterSpacing() || params->m_font->wordSpacing() | params->m_run.padding();
+        float padding = params->m_run.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.
@@ -214 +213 @@
                     width +=params->m_font->letterSpacing();
                 if (Font::treatAsSpace(nextCh)) {
-                    if (params->m_style.padding()) {
+                    if (params->m_run.padding()) {
                         if (padding < params->m_padPerSpace) {
                             width += padding;
@@ -237 +236 @@
                 width = ceilf(width);
             lastAdjustedPos = lastAdjustedPos + width;
-            if (Font::isRoundingHackCharacter(nextCh) && (!isLastChar || params->m_style.applyRunRounding())){
-                if (params->m_style.ltr())
+            if (Font::isRoundingHackCharacter(nextCh) && (!isLastChar || params->m_run.applyRunRounding())){
+                if (params->m_run.ltr())
                     lastAdjustedPos = ceilf(lastAdjustedPos);
                 else {
@@ -353 +352 @@
     
     ATSLineLayoutOptions lineLayoutOptions = kATSLineKeepSpacesOutOfMargin | kATSLineHasNoHangers;
-    Boolean rtl = m_style.rtl();
+    Boolean rtl = m_run.rtl();
     overrideSpecifier.operationSelector = kATSULayoutOperationPostLayoutAdjustment;
     overrideSpecifier.overrideUPP = overrideLayoutOperation;
@@ -360 +359 @@
     ATSUAttributeValuePtr values[] = { &cgContext, &lineLayoutOptions, &rtl, &overrideSpecifier };
     
-    status = ATSUSetLayoutControls(layout, (m_style.applyWordRounding() ? 4 : 3), tags, sizes, values);
+    status = ATSUSetLayoutControls(layout, (m_run.applyWordRounding() ? 4 : 3), tags, sizes, values);
     if (status != noErr)
         LOG_ERROR("ATSUSetLayoutControls failed(%d)", status);
@@ -417 +416 @@
                 shapeArabic(m_run.characters(), m_charBuffer, runLength, i);
             }
-            if (m_style.rtl() && !r->m_ATSUMirrors) {
+            if (m_run.rtl() && !r->m_ATSUMirrors) {
                 UChar mirroredChar = u_charMirror(m_run[i]);
                 if (mirroredChar != m_run[i]) {
@@ -456 +455 @@
         substituteOffset += substituteLength;
     }
-    if (m_style.padding()) {
+    if (m_run.padding()) {
         float numSpaces = 0;
         unsigned k;
@@ -466 +465 @@
             m_padPerSpace = 0;
         else
-            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
+            m_padPerSpace = ceilf(m_run.padding() / numSpaces);
     } else
         m_padPerSpace = 0;
@@ -478 +477 @@
 }
 
-FloatRect Font::selectionRectForComplexText(const TextRun& run, const FontStyle& style, const IntPoint& point, int h, int from, int to) const
+FloatRect Font::selectionRectForComplexText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
 {        
-    TextRun adjustedRun = style.directionalOverride() ? addDirectionalOverride(run, style.rtl()) : run;
-    if (style.directionalOverride()) {
+    TextRun adjustedRun = run.directionalOverride() ? addDirectionalOverride(run, run.rtl()) : run;
+    if (run.directionalOverride()) {
         from++;
         to++;
     }
 
-    ATSULayoutParameters params(adjustedRun, style);
+    ATSULayoutParameters params(adjustedRun);
     params.initialize(this);
 
@@ -504 +503 @@
     FloatRect rect(point.x() + floorf(beforeWidth), point.y(), roundf(afterWidth) - floorf(beforeWidth), h);
 
-    if (style.directionalOverride())
+    if (run.directionalOverride())
         delete []adjustedRun.characters();
 
@@ -510 +509 @@
 }
 
-void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run, const FontStyle& style, const FloatPoint& point, int from, int to) const
+void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run, const FloatPoint& point, int from, int to) const
 {
     OSStatus status;
     
     int drawPortionLength = to - from;
-    TextRun adjustedRun = style.directionalOverride() ? addDirectionalOverride(run, style.rtl()) : run;
-    if (style.directionalOverride())
+    TextRun adjustedRun = run.directionalOverride() ? addDirectionalOverride(run, run.rtl()) : run;
+    if (run.directionalOverride())
         from++;
 
-    ATSULayoutParameters params(TextRun(adjustedRun.characters(), adjustedRun.length()), style);
+    ATSULayoutParameters params(TextRun(adjustedRun.characters(), adjustedRun.length()));
     params.initialize(this, graphicsContext);
     
@@ -541 +540 @@
     disposeATSULayoutParameters(&params);
     
-    if (style.directionalOverride())
+    if (run.directionalOverride())
         delete []adjustedRun.characters();
 }
 
-float Font::floatWidthForComplexText(const TextRun& run, const FontStyle& style) const
+float Font::floatWidthForComplexText(const TextRun& run) const
 {
     if (run.length() == 0)
         return 0;
 
-    ATSULayoutParameters params(run, style);
+    ATSULayoutParameters params(run);
     params.initialize(this);
     
@@ -569 +568 @@
 }
 
-int Font::offsetForPositionForComplexText(const TextRun& run, const FontStyle& style, int x, bool includePartialGlyphs) const
-{
-    TextRun adjustedRun = style.directionalOverride() ? addDirectionalOverride(run, style.rtl()) : run;
-    
-    ATSULayoutParameters params(adjustedRun, style);
+int Font::offsetForPositionForComplexText(const TextRun& run, int x, bool includePartialGlyphs) const
+{
+    TextRun adjustedRun = run.directionalOverride() ? addDirectionalOverride(run, run.rtl()) : run;
+    
+    ATSULayoutParameters params(adjustedRun);
     params.initialize(this);
 
@@ -586 +585 @@
     if (status == noErr) {
         offset = (unsigned)primaryOffset;
-        if (style.directionalOverride() && offset > 0)
+        if (run.directionalOverride() && offset > 0)
             offset--;
     } else
@@ -594 +593 @@
     disposeATSULayoutParameters(&params);
     
-    if (style.directionalOverride())
+    if (run.directionalOverride())
         delete []adjustedRun.characters();
 

trunk/WebCore/platform/graphics/qt/FontQt.cpp

@@ -24 +24 @@
 #include "FontDescription.h"
 #include "FontSelector.h"
-#include "FontStyle.h"
 
 #include "GraphicsContext.h"
@@ -158 +157 @@
 }
 
-static int generateComponents(Vector<TextRunComponent, 1024>* components, const Font &font, const TextRun &run, const FontStyle &style)
+static int generateComponents(Vector<TextRunComponent, 1024>* components, const Font &font, const TextRun &run)
 {
 //     qDebug() << "generateComponents" << QString((const QChar *)run.characters(), run.length());
@@ -164 +163 @@
     int wordSpacing = font.wordSpacing();
     bool smallCaps = font.fontDescription().smallCaps();
-    int padding = style.padding();
+    int padding = run.padding();
     int numSpaces = 0;
     if (padding) {
@@ -184 +183 @@
                 --numSpaces;
             }
-            components->append(TextRunComponent(1, style.rtl(), &font.font(), offset));
+            components->append(TextRunComponent(1, run.rtl(), &font.font(), offset));
             offset += add + letterSpacing + components->last().width;
             start = 1;
@@ -202 +201 @@
                 if (i - start > 0) {
                     components->append(TextRunComponent(run.characters() + start, i - start,
-                                                        style.rtl(), 
+                                                        run.rtl(), 
                                                         f, offset, f == &font.scFont()));
                     offset += components->last().width + letterSpacing;
@@ -212 +211 @@
                     --numSpaces;
                 }
-                components->append(TextRunComponent(1, style.rtl(), &font.font(), offset));
+                components->append(TextRunComponent(1, run.rtl(), &font.font(), offset));
                 offset += wordSpacing + add + components->last().width + letterSpacing;
                 start = i + 1;
@@ -229 +228 @@
             if (i - start > 0) {
                 components->append(TextRunComponent(run.characters() + start, i - start,
-                                                    style.rtl(), 
+                                                    run.rtl(), 
                                                     f, offset, f == &font.scFont()));
                 offset += components->last().width + letterSpacing;
@@ -240 +239 @@
         if (run.length() - start > 0) {
             components->append(TextRunComponent(run.characters() + start, run.length() - start,
-                                                style.rtl(), 
+                                                run.rtl(), 
                                                 f, offset, f == &font.scFont()));
             offset += components->last().width;
@@ -252 +251 @@
                 if (i - start > 0) {
                     components->append(TextRunComponent(run.characters() + start, i - start,
-                                                        style.rtl(), 
+                                                        run.rtl(), 
                                                         f, offset));
                     offset += components->last().width;
@@ -262 +261 @@
                     --numSpaces;
                 }
-                components->append(TextRunComponent(1, style.rtl(), &font.font(), offset));
+                components->append(TextRunComponent(1, run.rtl(), &font.font(), offset));
                 offset += add + components->last().width;
                 if (i)
@@ -271 +270 @@
         if (run.length() - start > 0) {
             components->append(TextRunComponent(run.characters() + start, run.length() - start,
-                                                style.rtl(), 
+                                                run.rtl(), 
                                                 f, offset));
             offset += components->last().width;
@@ -279 +278 @@
 }
 
-void Font::drawText(GraphicsContext* ctx, const TextRun& run, const FontStyle& style, const FloatPoint& point, int from, int to) const
+void Font::drawText(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to) const
 {
     if (to < 0)
@@ -288 +287 @@
 
     Vector<TextRunComponent, 1024> components;
-    int w = generateComponents(&components, *this, run, style);
+    int w = generateComponents(&components, *this, run);
 
     if (from > 0 || to < run.length()) {
-        FloatRect clip = selectionRectForText(run, style,
+        FloatRect clip = selectionRectForText(run,
                                               IntPoint(qRound(point.x()), qRound(point.y())),
                                               QFontMetrics(m_font).height(), from, to);
@@ -299 +298 @@
     }
 
-    if (style.rtl()) {
+    if (run.rtl()) {
         for (int i = 0; i < components.size(); ++i) {
             if (!components.at(i).isSpace()) {
@@ -320 +319 @@
 }
 
-int Font::width(const TextRun& run, const FontStyle& style) const
+int Font::width(const TextRun& run) const
 {
     Vector<TextRunComponent, 1024> components;
-    int w = generateComponents(&components, *this, run, style);
+    int w = generateComponents(&components, *this, run);
 
 //     qDebug() << "     width=" << w;
@@ -329 +328 @@
 }
 
-int Font::width(const TextRun& run) const
-{
-    return width(run, FontStyle());
-}
-
-float Font::floatWidth(const TextRun& run, const FontStyle& style) const
-{
-    return width(run, style);
-}
-
 float Font::floatWidth(const TextRun& run) const
 {
@@ -344 +333 @@
 }
 
-int Font::offsetForPosition(const TextRun& run, const FontStyle& style, int position, bool includePartialGlyphs) const
+int Font::offsetForPosition(const TextRun& run, int position, bool includePartialGlyphs) const
 {
     Vector<TextRunComponent, 1024> components;
-    int w = generateComponents(&components, *this, run, style);
+    int w = generateComponents(&components, *this, run);
 
     int offset = 0;
-    if (style.rtl()) {
+    if (run.rtl()) {
         for (int i = 0; i < components.size(); ++i) {
             int xe = w - components.at(i).offset;
@@ -402 +391 @@
 }
 
-static float cursorToX(const Vector<TextRunComponent, 1024>& components, int width,
-                     const FontStyle& style, int cursor)
+static float cursorToX(const Vector<TextRunComponent, 1024>& components, int width, bool rtl, int cursor)
 {
     int start = 0;
@@ -412 +400 @@
         }
         int xs = components.at(i).offset;
-        if (style.rtl())
+        if (rtl)
             xs = width - xs - components.at(i).width;
         QTextLayout layout(components.at(i).string, *components.at(i).font);
@@ -428 +416 @@
 }
 
-FloatRect Font::selectionRectForText(const TextRun& run, const FontStyle& style, const IntPoint& pt,
+FloatRect Font::selectionRectForText(const TextRun& run, const IntPoint& pt,
                                      int h, int from, int to) const
 {
     Vector<TextRunComponent, 1024> components;
-    int w = generateComponents(&components, *this, run, style);
+    int w = generateComponents(&components, *this, run);
 
     if (from == 0 && to == run.length())
         return FloatRect(pt.x(), pt.y(), w, h);
 
-    float x1 = cursorToX(components, w, style, from);
-    float x2 = cursorToX(components, w, style, to);
+    float x1 = cursorToX(components, w, run.rtl(), from);
+    float x2 = cursorToX(components, w, run.rtl(), to);
     if (x2 < x1)
         qSwap(x1, x2);

trunk/WebCore/platform/graphics/win/FontWin.cpp

@@ -33 +33 @@
 #include "IntRect.h"
 #include "NotImplemented.h"
-#include "FontStyle.h"
 #include "UniscribeController.h"
 #include <ApplicationServices/ApplicationServices.h>
@@ -96 +95 @@
 }
 
-FloatRect Font::selectionRectForComplexText(const TextRun& run, const FontStyle& style, const IntPoint& point, int h,
+FloatRect Font::selectionRectForComplexText(const TextRun& run, const IntPoint& point, int h,
                                             int from, int to) const
 {
-    UniscribeController it(this, run, style);
+    UniscribeController it(this, run);
     it.advance(from);
     float beforeWidth = it.runWidthSoFar();
@@ -106 +105 @@
 
     // Using roundf() rather than ceilf() for the right edge as a compromise to ensure correct caret positioning
-    if (style.rtl()) {
+    if (run.rtl()) {
         it.advance(run.length());
         float totalWidth = it.runWidthSoFar();
@@ -115 +114 @@
 }
 
-void Font::drawComplexText(GraphicsContext* context, const TextRun& run, const FontStyle& style, const FloatPoint& point,
+void Font::drawComplexText(GraphicsContext* context, const TextRun& run, const FloatPoint& point,
                            int from, int to) const
 {
@@ -122 +121 @@
 
     float startX = point.x();
-    UniscribeController controller(this, run, style);
+    UniscribeController controller(this, run);
     controller.advance(from);
     float beforeWidth = controller.runWidthSoFar();
@@ -133 +132 @@
     float afterWidth = controller.runWidthSoFar();
 
-    if (style.rtl()) {
+    if (run.rtl()) {
         controller.advance(run.length());
         startX += controller.runWidthSoFar() - afterWidth;
@@ -141 +140 @@
     // Draw the glyph buffer now at the starting point returned in startX.
     FloatPoint startPoint(startX, point.y());
-    drawGlyphBuffer(context, glyphBuffer, run, style, startPoint);
+    drawGlyphBuffer(context, glyphBuffer, run, startPoint);
 }
 
-float Font::floatWidthForComplexText(const TextRun& run, const FontStyle& style) const
+float Font::floatWidthForComplexText(const TextRun& run) const
 {
-    UniscribeController controller(this, run, style);
+    UniscribeController controller(this, run);
     controller.advance(run.length());
     return controller.runWidthSoFar();
 }
 
-int Font::offsetForPositionForComplexText(const TextRun& run, const FontStyle& style, int x, bool includePartialGlyphs) const
+int Font::offsetForPositionForComplexText(const TextRun& run, int x, bool includePartialGlyphs) const
 {
-    UniscribeController controller(this, run, style);
+    UniscribeController controller(this, run);
     return controller.offsetForPosition(x, includePartialGlyphs);
 }

trunk/WebCore/platform/graphics/wx/FontWx.cpp

@@ -75 +75 @@
 }
 
-FloatRect Font::selectionRectForComplexText(const TextRun& run, const FontStyle& style, const IntPoint& point, int h, int from, int to) const
+FloatRect Font::selectionRectForComplexText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
 {
     notImplemented();
@@ -81 +81 @@
 }
 
-void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run, const FontStyle& style, const FloatPoint& point, int from, int to) const
+void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run, const FloatPoint& point, int from, int to) const
 {
     notImplemented();
 }
 
-float Font::floatWidthForComplexText(const TextRun& run, const FontStyle& style) const
+float Font::floatWidthForComplexText(const TextRun& run) const
 {
     notImplemented();
@@ -92 +92 @@
 }
 
-int Font::offsetForPositionForComplexText(const TextRun& run, const FontStyle& style, int x, bool includePartialGlyphs) const
+int Font::offsetForPositionForComplexText(const TextRun& run, int x, bool includePartialGlyphs) const
 {
     notImplemented();

trunk/WebCore/platform/mac/WebCoreTextRenderer.mm

@@ -31 +31 @@
 #import "GraphicsContext.h"
 #import "IntPoint.h"
-#import "FontStyle.h"
 #import "WebFontCache.h"
 
@@ -49 +48 @@
     Font renderer(f, ![[NSGraphicsContext currentContext] isDrawingToScreen]);
     TextRun run(buffer, length);
-    FontStyle style;
-    style.disableRoundingHacks();
+    run.disableRoundingHacks();
     CGFloat red, green, blue, alpha;
     [[textColor colorUsingColorSpaceName:NSDeviceRGBColorSpace] getRed:&red green:&green blue:&blue alpha:&alpha];
     graphicsContext.setFillColor(makeRGBA((int)(red * 255), (int)(green * 255), (int)(blue * 255), (int)(alpha * 255)));
-    renderer.drawText(&graphicsContext, run, style, FloatPoint(point.x, (flipped ? point.y : (-1.0f * point.y))));
+    renderer.drawText(&graphicsContext, run, FloatPoint(point.x, (flipped ? point.y : (-1.0f * point.y))));
     if (!flipped)
         CGContextScaleCTM(cgContext, 1.0f, -1.0f);
@@ -64 +62 @@
     Font renderer(f, ![[NSGraphicsContext currentContext] isDrawingToScreen]);
     TextRun run(buffer, length);
-    FontStyle style;
-    style.disableRoundingHacks();
-    return renderer.floatWidth(run, style);
+    run.disableRoundingHacks();
+    return renderer.floatWidth(run);
 }
 

trunk/WebCore/platform/win/PopupMenuWin.cpp

@@ -36 +36 @@
 #include "RenderTheme.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 #include <tchar.h>
 #include <windows.h>
@@ -511 +510 @@
         unsigned length = itemText.length();
         const UChar* string = itemText.characters();
-        FontStyle fontStyle(0, 0, 0, itemText.defaultWritingDirection() == WTF::Unicode::RightToLeft);
-        TextRun textRun(string, length);
+        TextRun textRun(string, length, false, 0, 0, itemText.defaultWritingDirection() == WTF::Unicode::RightToLeft);
 
         context.setFillColor(optionTextColor);
@@ -529 +527 @@
             int textX = max(0, client()->clientPaddingLeft() - client()->clientInsetLeft());
             int textY = itemRect.y() + itemFont.ascent() + (itemRect.height() - itemFont.height()) / 2;
-            context.drawBidiText(textRun, IntPoint(textX, textY), fontStyle);
+            context.drawBidiText(textRun, IntPoint(textX, textY));
         }
     }

trunk/WebCore/platform/win/UniscribeController.cpp

@@ -31 +31 @@
 #include "Font.h"
 #include "FontData.h"
-#include "FontStyle.h"
 #include <wtf/MathExtras.h>
 
@@ -40 +39 @@
 // take the GlyphBuffer as an arg so that we don't have to populate the glyph buffer when
 // measuring.
-UniscribeController::UniscribeController(const Font* font, const TextRun& run, const FontStyle& style)
+UniscribeController::UniscribeController(const Font* font, const TextRun& run)
 : m_font(*font)
 , m_run(run)
-, m_style(style)
 , m_end(run.length())
 , m_currentCharacter(0)
@@ -52 +50 @@
 , m_offsetPosition(0)
 {
-    m_padding = m_style.padding();
+    m_padding = m_run.padding();
     if (!m_padding)
         m_padPerSpace = 0;
@@ -64 +62 @@
             m_padPerSpace = 0;
         else
-            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
+            m_padPerSpace = ceilf(m_run.padding() / numSpaces);
     }
 
@@ -80 +78 @@
     if (m_computingOffsetPosition) {
         // The point is to the left or to the right of the entire run.
-        if (m_offsetX >= m_runWidthSoFar && m_style.ltr() || m_offsetX < 0 && m_style.rtl())
+        if (m_offsetX >= m_runWidthSoFar && m_run.ltr() || m_offsetX < 0 && m_run.rtl())
             m_offsetPosition = m_end;
     }
@@ -112 +110 @@
         memcpy(smallCapsBuffer.data(), cp, length * sizeof(UChar));
         bool isSmallCaps = false;
-        unsigned indexOfCaseShift = m_style.rtl() ? length - 1 : 0;
-        const UChar* curr = m_style.rtl() ? cp + length  - 1: cp;
-        const UChar* end = m_style.rtl() ? cp - 1: cp + length;
+        unsigned indexOfCaseShift = m_run.rtl() ? length - 1 : 0;
+        const UChar* curr = m_run.rtl() ? cp + length  - 1: cp;
+        const UChar* end = m_run.rtl() ? cp - 1: cp + length;
         while (curr != end) {
             int index = curr - cp;
             UChar c = smallCapsBuffer[index];
             UChar newC;
-            curr = m_style.rtl() ? curr - 1 : curr + 1;
+            curr = m_run.rtl() ? curr - 1 : curr + 1;
             if (U_GET_GC_MASK(c) & U_GC_M_MASK)
                 continue;
@@ -126 +124 @@
                 if (!isSmallCaps) {
                     isSmallCaps = true;
-                    int itemStart = m_style.rtl() ? index : indexOfCaseShift;
-                    int itemLength = m_style.rtl() ? indexOfCaseShift - index : index - indexOfCaseShift;
+                    int itemStart = m_run.rtl() ? index : indexOfCaseShift;
+                    int itemLength = m_run.rtl() ? indexOfCaseShift - index : index - indexOfCaseShift;
                     itemizeShapeAndPlace(smallCapsBuffer.data() + itemStart, itemLength, false, glyphBuffer);
                     indexOfCaseShift = index;
@@ -133 +131 @@
             } else if (isSmallCaps) {
                 isSmallCaps = false;
-                int itemStart = m_style.rtl() ? index : indexOfCaseShift;
-                int itemLength = m_style.rtl() ? indexOfCaseShift - index : index - indexOfCaseShift;
+                int itemStart = m_run.rtl() ? index : indexOfCaseShift;
+                int itemLength = m_run.rtl() ? indexOfCaseShift - index : index - indexOfCaseShift;
                 itemizeShapeAndPlace(smallCapsBuffer.data() + itemStart, itemLength, true, glyphBuffer);
                 indexOfCaseShift = index;
@@ -140 +138 @@
         }
         
-        int itemLength = m_style.rtl() ? indexOfCaseShift + 1 : length - indexOfCaseShift;
+        int itemLength = m_run.rtl() ? indexOfCaseShift + 1 : length - indexOfCaseShift;
         if (itemLength) {
-            int itemStart = m_style.rtl() ? 0 : indexOfCaseShift;
+            int itemStart = m_run.rtl() ? 0 : indexOfCaseShift;
             itemizeShapeAndPlace(smallCapsBuffer.data() + itemStart, itemLength, isSmallCaps, glyphBuffer);
         }
@@ -161 +159 @@
     m_items.resize(numItems + 1);
 
-    if (m_style.rtl()) {
+    if (m_run.rtl()) {
         for (int i = m_items.size() - 2; i >= 0; i--) {
             if (!shapeAndPlaceItem(cp, i, smallCaps, glyphBuffer))
@@ -182 +180 @@
 
     // Set up the correct direction for the run.
-    m_state.uBidiLevel = m_style.rtl();
+    m_state.uBidiLevel = m_run.rtl();
     
     // Lock the correct directional override.
-    m_state.fOverrideDirection = m_style.directionalOverride();
+    m_state.fOverrideDirection = m_run.directionalOverride();
 }
 
@@ -321 +319 @@
         // match the width of the space glyph have the same width as the space glyph.
         if (roundedAdvance == roundedSpaceWidth && (fontData->m_treatAsFixedPitch || glyph == fontData->m_spaceGlyph) &&
-            m_style.applyWordRounding())
+            m_run.applyWordRounding())
             advance = fontData->m_adjustedSpaceWidth;
 
@@ -358 +356 @@
         // to be integer width, so the following words will start on an integer boundary.
         int roundingHackIndex = roundingHackCharacters[k];
-        if (m_style.applyWordRounding() && roundingHackIndex != -1)
+        if (m_run.applyWordRounding() && roundingHackIndex != -1)
             advance = ceilf(advance);
 
@@ -364 +362 @@
         // width so that the total run width will be on an integer boundary.
         int position = m_currentCharacter + len;
-        bool lastGlyph = (k == glyphs.size() - 1) && (m_style.rtl() ? i == 0 : i == m_items.size() - 2) && (position >= m_end);
-        if ((m_style.applyWordRounding() && roundingHackWordBoundaries[k] != -1) ||
-            (m_style.applyRunRounding() && lastGlyph)) { 
+        bool lastGlyph = (k == glyphs.size() - 1) && (m_run.rtl() ? i == 0 : i == m_items.size() - 2) && (position >= m_end);
+        if ((m_run.applyWordRounding() && roundingHackWordBoundaries[k] != -1) ||
+            (m_run.applyRunRounding() && lastGlyph)) { 
             float totalWidth = m_runWidthSoFar + advance;
             advance += ceilf(totalWidth) - totalWidth;
@@ -393 +391 @@
         if (trailing && m_includePartialGlyphs && m_offsetPosition < len - 1) {
             m_offsetPosition += m_currentCharacter + m_items[i].iCharPos;
-            m_offsetX += m_style.rtl() ? -trailing : trailing;
+            m_offsetX += m_run.rtl() ? -trailing : trailing;
         } else {
             m_computingOffsetPosition = false;

trunk/WebCore/platform/win/UniscribeController.h

@@ -39 +39 @@
 class UniscribeController {
 public:
-    UniscribeController(const Font*, const TextRun&, const FontStyle&);
+    UniscribeController(const Font*, const TextRun&);
 
     // Advance and measure/place up to the specified character.
@@ -61 +61 @@
     const Font& m_font;
     const TextRun& m_run;
-    const FontStyle& m_style;
 
     SCRIPT_CONTROL m_control;

trunk/WebCore/platform/win/WebCoreTextRenderer.cpp

@@ -30 +30 @@
 #include "GraphicsContext.h"
 #include "StringTruncator.h"
-#include "FontStyle.h"
 #include <wtf/unicode/Unicode.h>
 
@@ -48 +47 @@
 {
     TextRun run(text.characters(), text.length());
-    FontStyle style;
 
     context.setFillColor(color);
     if (isOneLeftToRightRun(run))
-        font.drawText(&context, run, style, point);
+        font.drawText(&context, run, point);
     else {
         context.setFont(font);
-        context.drawBidiText(run, point, style);
+        context.drawBidiText(run, point);
     }
 
@@ -64 +62 @@
         if (underlinedIndex > 0) {
             TextRun beforeRun(text.characters(), underlinedIndex);
-            beforeWidth = font.width(beforeRun, style);
+            beforeWidth = font.width(beforeRun);
         } else
             beforeWidth = 0;
 
         TextRun underlinedRun(text.characters() + underlinedIndex, 1);
-        int underlinedWidth = font.width(underlinedRun, style);
+        int underlinedWidth = font.width(underlinedRun);
 
         IntPoint underlinePoint(point);

trunk/WebCore/rendering/EllipsisBox.cpp

@@ -26 +26 @@
 #include "GraphicsContext.h"
 #include "HitTestResult.h"
-#include "FontStyle.h"
 
 namespace WebCore {
@@ -48 +47 @@
 
     const String& str = m_str;
-    FontStyle fontStyle(0, 0, 0, false, style->visuallyOrdered());
-    context->drawText(TextRun(str.characters(), str.length()), IntPoint(m_x + tx, m_y + ty + m_baseline), fontStyle);
+    context->drawText(TextRun(str.characters(), str.length(), false, 0, 0, false, style->visuallyOrdered()), IntPoint(m_x + tx, m_y + ty + m_baseline));
 
     if (setShadow)

trunk/WebCore/rendering/InlineTextBox.cpp

@@ -33 +33 @@
 #include "RenderTheme.h"
 #include "Text.h"
-#include "FontStyle.h"
 #include "break_lines.h"
 #include <wtf/AlwaysInline.h>
@@ -97 +96 @@
     const Font& f = textObj->style(m_firstLine)->font();
 
-    IntRect r = enclosingIntRect(f.selectionRectForText(TextRun(textObj->text()->characters() + m_start, m_len),
-                                                        FontStyle(textObj->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride),
+    IntRect r = enclosingIntRect(f.selectionRectForText(TextRun(textObj->text()->characters() + m_start, m_len, textObj->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride),
                                                         IntPoint(tx + m_x, ty + selTop), selHeight, sPos, ePos));
     if (r.x() > tx + m_x + m_width)
@@ -375 +373 @@
     StringImpl* textStr = textObject()->text();
 
-    FontStyle fontStyle(textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || styleToUse->visuallyOrdered());
-
     if (!paintSelectedTextOnly && !paintSelectedTextSeparately) {
         // paint all the text
@@ -384 +380 @@
         if (m_truncation != cNoTruncation)
             endPoint = m_truncation;
-        paintInfo.context->drawText(TextRun(textStr->characters() + m_start, endPoint), IntPoint(m_x + tx, m_y + ty + m_baseline), fontStyle);
+        paintInfo.context->drawText(TextRun(textStr->characters() + m_start, endPoint, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || styleToUse->visuallyOrdered()),
+                                    IntPoint(m_x + tx, m_y + ty + m_baseline));
     } else {
         int sPos, ePos;
@@ -391 +388 @@
             // paint only the text that is not selected
             if (sPos >= ePos)
-                paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len), IntPoint(m_x + tx, m_y + ty + m_baseline), fontStyle);
+                paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || styleToUse->visuallyOrdered()),
+                                            IntPoint(m_x + tx, m_y + ty + m_baseline));
             else {
                 if (sPos - 1 >= 0)
-                    paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len), IntPoint(m_x + tx, m_y + ty + m_baseline), fontStyle,  0, sPos);
+                    paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || styleToUse->visuallyOrdered()),
+                                                IntPoint(m_x + tx, m_y + ty + m_baseline),  0, sPos);
                 if (ePos < m_start + m_len)
-                    paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len), IntPoint(m_x + tx, m_y + ty + m_baseline), fontStyle, ePos);
+                    paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || styleToUse->visuallyOrdered()),
+                                                IntPoint(m_x + tx, m_y + ty + m_baseline), ePos);
             }
         }
@@ -410 +410 @@
                 paintInfo.context->setShadow(IntSize(selectionTextShadow->x, selectionTextShadow->y),
                                              selectionTextShadow->blur, selectionTextShadow->color);
-            paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len), IntPoint(m_x + tx, m_y + ty + m_baseline), fontStyle, sPos, ePos);
+            paintInfo.context->drawText(TextRun(textStr->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || styleToUse->visuallyOrdered()),
+                                        IntPoint(m_x + tx, m_y + ty + m_baseline), sPos, ePos);
             if (selectionTextShadow)
                 paintInfo.context->clearShadow();
@@ -502 +503 @@
     int h = selectionHeight();
     p->clip(IntRect(m_x + tx, y + ty, m_width, h));
-    p->drawHighlightForText(TextRun(textObject()->text()->characters() + m_start, m_len), IntPoint(m_x + tx, y + ty), h, 
-                            FontStyle(textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()), c,
-                            sPos, ePos);
+    p->drawHighlightForText(TextRun(textObject()->text()->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()),
+                            IntPoint(m_x + tx, y + ty), h, c, sPos, ePos);
     p->restore();
 }
@@ -525 +525 @@
     int y = selectionTop();
     int h = selectionHeight();
-    p->drawHighlightForText(TextRun(textObject()->text()->characters() + m_start, m_len),
-                            IntPoint(m_x + tx, y + ty), h, 
-                            FontStyle(textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()), c, sPos, ePos);
+    p->drawHighlightForText(TextRun(textObject()->text()->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()),
+                            IntPoint(m_x + tx, y + ty), h, c, sPos, ePos);
     p->restore();
 }
@@ -614 +613 @@
         int y = selectionTop();
         IntPoint startPoint = IntPoint(m_x + tx, y + ty);
-        FontStyle fontStyle = FontStyle(textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered());
         int startPosition = max(marker.startOffset - m_start, (unsigned)0);
         int endPosition = min(marker.endOffset - m_start, (unsigned)m_len);    
-        TextRun run = TextRun(textObject()->text()->characters() + m_start, m_len);
-        IntRect markerRect = enclosingIntRect(f->selectionRectForText(run, fontStyle, startPoint, selectionHeight(), startPosition, endPosition));
+        TextRun run(textObject()->text()->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered());
+        IntRect markerRect = enclosingIntRect(f->selectionRectForText(run, startPoint, selectionHeight(), startPosition, endPosition));
         object()->document()->setRenderedRectForMarker(object()->node(), marker, markerRect);
     }
@@ -650 +648 @@
     int sPos = max(marker.startOffset - m_start, (unsigned)0);
     int ePos = min(marker.endOffset - m_start, (unsigned)m_len);    
-    TextRun run = TextRun(textObject()->text()->characters() + m_start, m_len);
-    FontStyle renderStyle = FontStyle(textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered());
+    TextRun run(textObject()->text()->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered());
     IntPoint startPoint = IntPoint(m_x + tx, y + ty);
     
     // Always compute and store the rect associated with this marker
-    IntRect markerRect = enclosingIntRect(f->selectionRectForText(run, renderStyle, startPoint, h, sPos, ePos));
+    IntRect markerRect = enclosingIntRect(f->selectionRectForText(run, startPoint, h, sPos, ePos));
     object()->document()->setRenderedRectForMarker(object()->node(), marker, markerRect);
      
@@ -664 +661 @@
         updateGraphicsContext(pt, color, color, 0);  // Don't draw text at all!
         pt->clip(IntRect(tx + m_x, ty + y, m_width, h));
-        pt->drawHighlightForText(run, startPoint, h, renderStyle, color, sPos, ePos);
+        pt->drawHighlightForText(run, startPoint, h, color, sPos, ePos);
         pt->restore();
     }
@@ -802 +799 @@
     RenderStyle *style = text->style(m_firstLine);
     const Font* f = &style->font();
-    return f->offsetForPosition(TextRun(textObject()->text()->characters() + m_start, m_len),
-                                FontStyle(textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()),
+    return f->offsetForPosition(TextRun(textObject()->text()->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride || style->visuallyOrdered()),
                                 _x - m_x, includePartialGlyphs);
 }
@@ -817 +813 @@
     int to = m_reversed ? m_len : offset - m_start;
     // FIXME: Do we need to add rightBearing here?
-    return enclosingIntRect(f.selectionRectForText(TextRun(text->text()->characters() + m_start, m_len),
-                                                   FontStyle(textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride),
+    return enclosingIntRect(f.selectionRectForText(TextRun(text->text()->characters() + m_start, m_len, textObject()->allowTabs(), textPos(), m_toAdd, m_reversed, m_dirOverride),
                                                    IntPoint(m_x, 0), 0, from, to)).right();
 }

trunk/WebCore/rendering/RenderFileUploadControl.cpp

@@ -32 +32 @@
 #include "RenderTheme.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 #include <math.h>
 
@@ -177 +176 @@
         unsigned length = displayedFilename.length();
         const UChar* string = displayedFilename.characters();
-        FontStyle fontStyle(0, 0, 0, style()->direction() == RTL, style()->unicodeBidi() == Override);
-        TextRun textRun(string, length);
+        TextRun textRun(string, length, false, 0, 0, style()->direction() == RTL, style()->unicodeBidi() == Override);
         
         // Determine where the filename should be placed
@@ -199 +197 @@
         
         // Draw the filename
-        paintInfo.context->drawBidiText(textRun, IntPoint(textX, textY), fontStyle);
+        paintInfo.context->drawBidiText(textRun, IntPoint(textX, textY));
         
         if (m_fileChooser->icon()) {
@@ -236 +234 @@
         // (using "0" as the nominal character).
         const UChar ch = '0';
-        float charWidth = style()->font().floatWidth(TextRun(&ch, 1), FontStyle(0, 0, 0, false, false, false));
+        float charWidth = style()->font().floatWidth(TextRun(&ch, 1, false, 0, 0, false, false, false));
         m_maxPrefWidth = (int)ceilf(charWidth * defaultWidthNumChars);
     }

trunk/WebCore/rendering/RenderImage.cpp

@@ -39 +39 @@
 #include "Page.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 
 using namespace std;

trunk/WebCore/rendering/RenderListBox.cpp

@@ -47 +47 @@
 #include "RenderTheme.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 #include <math.h>
 
@@ -102 +101 @@
         
         float width = 0;
-        FontStyle fontStyle(0, 0, 0, false, false, false, false);
         for (int i = 0; i < size; ++i) {
             HTMLElement* element = listItems[i];
@@ -118 +116 @@
                 
             if (!text.isEmpty()) {
-                float textWidth = itemFont.floatWidth(TextRun(text.impl()), fontStyle);
+                float textWidth = itemFont.floatWidth(TextRun(text.impl(), 0, 0, 0, false, false, false, false));
                 width = max(width, textWidth);
             }
@@ -339 +337 @@
     unsigned length = itemText.length();
     const UChar* string = itemText.characters();
-    FontStyle fontStyle(0, 0, 0, itemStyle->direction() == RTL, itemStyle->unicodeBidi() == Override, false, false);
-    TextRun textRun(string, length);
+    TextRun textRun(string, length, 0, 0, 0, itemStyle->direction() == RTL, itemStyle->unicodeBidi() == Override, false, false);
 
     // Draw the item text
     if (itemStyle->visibility() != HIDDEN)
-        paintInfo.context->drawBidiText(textRun, r.location(), fontStyle);
+        paintInfo.context->drawBidiText(textRun, r.location());
 }
 

trunk/WebCore/rendering/RenderMenuList.cpp

@@ -37 +37 @@
 #include "RenderText.h"
 #include "RenderTheme.h"
-#include "FontStyle.h"
 #include <math.h>
 
@@ -141 +140 @@
             String text = static_cast<HTMLOptionElement*>(element)->optionText();
             if (!text.isEmpty())
-                maxOptionWidth = max(maxOptionWidth, style()->font().floatWidth(text, FontStyle()));
+                maxOptionWidth = max(maxOptionWidth, style()->font().floatWidth(text));
         }
     }

trunk/WebCore/rendering/RenderText.cpp

@@ -34 +34 @@
 #include "Text.h"
 #include "TextBreakIterator.h"
-#include "FontStyle.h"
 #include "break_lines.h"
 #include <wtf/AlwaysInline.h>
@@ -413 +412 @@
     }
 
-    return f.width(TextRun(text()->characters() + start, len), FontStyle(allowTabs(), xPos));
+    return f.width(TextRun(text()->characters() + start, len, allowTabs(), xPos));
 }
 
@@ -672 +671 @@
                 currMaxWidth = 0;
             } else {
-                currMaxWidth += f.width(TextRun(txt + i, 1), FontStyle(allowTabs(), leadWidth + currMaxWidth));
+                currMaxWidth += f.width(TextRun(txt + i, 1, allowTabs(), leadWidth + currMaxWidth));
                 needsWordSpacing = isSpace && !previousCharacterIsSpace && i == len - 1;
             }
@@ -1026 +1025 @@
             w = widthFromCache(f, from, len, xPos);
     } else
-        w = f.width(TextRun(text()->characters() + from, len), FontStyle(allowTabs(), xPos));
+        w = f.width(TextRun(text()->characters() + from, len, allowTabs(), xPos));
 
     return w;

trunk/WebCore/rendering/RenderText.h

@@ -128 +128 @@
     InlineTextBox* findNextInlineTextBox(int offset, int& pos) const;
 
-    int allowTabs() const { return !style()->collapseWhiteSpace(); }
+    bool allowTabs() const { return !style()->collapseWhiteSpace(); }
 
     void checkConsistency() const;

trunk/WebCore/rendering/RenderTextControl.cpp

@@ -47 +47 @@
 #include "Text.h"
 #include "TextIterator.h"
-#include "FontStyle.h"
 #include "htmlediting.h"
 #include "visible_units.h"
@@ -850 +849 @@
         // (using "0" as the nominal character).
         const UChar ch = '0';
-        float charWidth = style()->font().floatWidth(TextRun(&ch, 1), FontStyle(0, 0, 0, false, false, false));
+        float charWidth = style()->font().floatWidth(TextRun(&ch, 1, false, 0, 0, false, false, false));
         int factor;
         int scrollbarSize = 0;

trunk/WebCore/rendering/SVGInlineTextBox.cpp

@@ -36 +36 @@
 #include "SVGRootInlineBox.h"
 #include "Text.h"
-#include "FontStyle.h"
 
 #include <float.h>
@@ -75 +74 @@
 float SVGInlineTextBox::calculateGlyphWidth(RenderStyle* style, int offset) const
 {
-    return style->font().floatWidth(TextRun(textObject()->text()->characters() + offset, 1), svgFontStyleForInlineTextBox(style, this, 0));
+    return style->font().floatWidth(svgTextRunForInlineTextBox(textObject()->text()->characters() + offset, 1, style, this, 0));
 }
 
@@ -380 +379 @@
 
     IntPoint origin((int) svgChar.x, (int) svgChar.y);
-    TextRun run(chars, length);
-    FontStyle style = svgFontStyleForInlineTextBox(styleToUse, this, svgChar.x);
-
-    paintInfo.context->drawText(run, origin, style);
+    TextRun run = svgTextRunForInlineTextBox(chars, length, styleToUse, this, svgChar.x);
+
+    paintInfo.context->drawText(run, origin);
 
     if (paintInfo.phase != PaintPhaseSelection) {
@@ -461 +459 @@
 
     int adjust = startPos >= boxStartOffset ? boxStartOffset : 0;
-    p->drawHighlightForText(TextRun(textObject()->text()->characters() + start() + boxStartOffset, length),
-                            IntPoint((int) svgChar.x, (int) svgChar.y - f->ascent()), f->ascent() + f->descent(),
-                            svgFontStyleForInlineTextBox(style, this, svgChar.x), color,
-                            startPos - adjust, endPos - adjust);
+    p->drawHighlightForText(svgTextRunForInlineTextBox(textObject()->text()->characters() + start() + boxStartOffset, length, style, this, svgChar.x),
+                            IntPoint((int) svgChar.x, (int) svgChar.y - f->ascent()),
+                            f->ascent() + f->descent(), color, startPos - adjust, endPos - adjust);
 
     p->restore();

trunk/WebCore/rendering/SVGRootInlineBox.cpp

@@ -41 +41 @@
 #include "SVGURIReference.h"
 #include "Text.h"
-#include "FontStyle.h"
 #include "UnicodeRange.h"
 
@@ -520 +519 @@
             // Paint decorations, that have to be drawn before the text gets drawn
             if (textDecorations != TDNONE && m_paintInfo.phase != PaintPhaseSelection) {
-                textWidth = styleToUse->font().width(TextRun(stringStart, stringLength), styleToUse);
+                textWidth = styleToUse->font().width(svgTextRunForInlineTextBox(stringStart, stringLength, styleToUse, textBox, (*it).x));
                 decorationOrigin = IntPoint((int) (*it).x, (int) (*it).y - styleToUse->font().ascent());
                 info = m_rootBox->retrievePaintServersForTextDecoration(text);
@@ -623 +622 @@
     RenderStyle* style = text->style();
 
-    return style->font().floatWidth(TextRun(text->characters() + textBox->start() + range.startOffset, range.endOffset - range.startOffset), svgFontStyleForInlineTextBox(style, textBox, 0));
+    return style->font().floatWidth(svgTextRunForInlineTextBox(text->characters() + textBox->start() + range.startOffset, range.endOffset - range.startOffset, style, textBox, 0));
 }
 
@@ -639 +638 @@
 }
 
-FontStyle svgFontStyleForInlineTextBox(RenderStyle* style, const InlineTextBox* textBox, float xPos)
+TextRun svgTextRunForInlineTextBox(const UChar* c, int len, RenderStyle* style, const InlineTextBox* textBox, float xPos)
 {
     ASSERT(textBox);
     ASSERT(style);
 
-    FontStyle fontStyle(false, static_cast<int>(xPos), textBox->toAdd(), textBox->m_reversed, textBox->m_dirOverride || style->visuallyOrdered());
+    TextRun run(c, len, false, static_cast<int>(xPos), textBox->toAdd(), textBox->m_reversed, textBox->m_dirOverride || style->visuallyOrdered());
 
     // We handle letter & word spacing ourselves
-    fontStyle.disableSpacing();
-    return fontStyle;
+    run.disableSpacing();
+    return run;
 }
 

trunk/WebCore/rendering/SVGRootInlineBox.h

@@ -76 +76 @@
 
 // Shared with SVGRenderTreeAsText / SVGInlineTextBox
-FontStyle svgFontStyleForInlineTextBox(RenderStyle* style, const InlineTextBox* textBox, float xPos);
+TextRun svgTextRunForInlineTextBox(const UChar*, int len, RenderStyle* style, const InlineTextBox* textBox, float xPos);
 FloatPoint topLeftPositionOfCharacterRange(Vector<SVGChar>::iterator start, Vector<SVGChar>::iterator end);
 float cummulatedWidthOfInlineBoxCharacterRange(SVGInlineBoxCharacterRange& range);