Reviewed by Darin Adler.
authormitz@apple.com <mitz@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 1 Dec 2007 16:28:57 +0000 (16:28 +0000)
committermitz@apple.com <mitz@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 1 Dec 2007 16:28:57 +0000 (16:28 +0000)
        - 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:

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

30 files changed:
WebCore/ChangeLog
WebCore/WebCore.xcodeproj/project.pbxproj
WebCore/platform/graphics/Font.cpp
WebCore/platform/graphics/Font.h
WebCore/platform/graphics/FontStyle.h [deleted file]
WebCore/platform/graphics/GraphicsContext.cpp
WebCore/platform/graphics/GraphicsContext.h
WebCore/platform/graphics/StringTruncator.cpp
WebCore/platform/graphics/gtk/FontGtk.cpp
WebCore/platform/graphics/mac/FontMac.mm
WebCore/platform/graphics/qt/FontQt.cpp
WebCore/platform/graphics/win/FontWin.cpp
WebCore/platform/graphics/wx/FontWx.cpp
WebCore/platform/mac/WebCoreTextRenderer.mm
WebCore/platform/win/PopupMenuWin.cpp
WebCore/platform/win/UniscribeController.cpp
WebCore/platform/win/UniscribeController.h
WebCore/platform/win/WebCoreTextRenderer.cpp
WebCore/rendering/EllipsisBox.cpp
WebCore/rendering/InlineTextBox.cpp
WebCore/rendering/RenderFileUploadControl.cpp
WebCore/rendering/RenderImage.cpp
WebCore/rendering/RenderListBox.cpp
WebCore/rendering/RenderMenuList.cpp
WebCore/rendering/RenderText.cpp
WebCore/rendering/RenderText.h
WebCore/rendering/RenderTextControl.cpp
WebCore/rendering/SVGInlineTextBox.cpp
WebCore/rendering/SVGRootInlineBox.cpp
WebCore/rendering/SVGRootInlineBox.h

index a34b690434baf026e083fea2ac04c77e4a5ef496..f8e7c8e234b80b1ad36f2a8aa5cf72b05c5e4f4b 100644 (file)
@@ -1,3 +1,131 @@
+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>
 
         Reviewed by Simon.
index 8a16febd4bb54c3db6ae160c157bfbff06398aed..f470aa3d2964c33837741a4e9ada04cd74763759 100644 (file)
                B24055650B5BE640002A28C0 /* DOMSVGElementInstanceInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = B24055630B5BE640002A28C0 /* DOMSVGElementInstanceInternal.h */; };
                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 */; };
                B266CD4D0C3AEC6500EB08D2 /* JSSVGException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B266CD4B0C3AEC6500EB08D2 /* JSSVGException.cpp */; };
                B24055630B5BE640002A28C0 /* DOMSVGElementInstanceInternal.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = DOMSVGElementInstanceInternal.h; sourceTree = "<group>"; };
                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>"; };
                B266CD4B0C3AEC6500EB08D2 /* JSSVGException.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSSVGException.cpp; sourceTree = "<group>"; };
                B2A015910AF6CD53006BCE0E /* graphics */ = {
                        isa = PBXGroup;
                        children = (
-                               B25E96BD0D00975100CFD296 /* FontStyle.h */,
                                B23540F00D00782E002382FA /* StringTruncator.cpp */,
                                B23540F10D00782E002382FA /* StringTruncator.h */,
                                B2C3DA4F0D006CD600EF6F26 /* Font.cpp */,
                                B2C3DA6E0D006CD600EF6F26 /* GlyphPageTreeNode.h in Headers */,
                                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 */,
                                B2AFFC940D00A5DF0030074D /* ShapeArabic.h in Headers */,
index 5a2eb7af90a2735cd7de6d7f17f6980febdfdb6d..48864cbeca35dbec86ebe8e2eb30a68d5a0b296b 100644 (file)
@@ -32,7 +32,6 @@
 #include "FontFallbackList.h"
 #include "IntPoint.h"
 #include "GlyphBuffer.h"
-#include "FontStyle.h"
 #include <wtf/unicode/Unicode.h>
 #include <wtf/MathExtras.h>
 
@@ -62,7 +61,7 @@ const uint8_t Font::gRoundingHackCharacterTable[256] = {
 Font::CodePath Font::codePath = Auto;
 
 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);
     bool advanceOneCharacter(float& width, GlyphBuffer* glyphBuffer = 0);
@@ -72,8 +71,6 @@ struct WidthIterator {
     const TextRun& m_run;
     int m_end;
 
-    const FontStyle& m_style;
-    
     unsigned m_currentCharacter;
     float m_runWidthSoFar;
     float m_padding;
@@ -84,18 +81,17 @@ private:
     UChar32 normalizeVoicingMarks(int currentCharacter);
 };
 
-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)
     , 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.
-    m_padding = m_style.padding();
+    m_padding = m_run.padding();
     if (!m_padding)
         m_padPerSpace = 0;
     else {
@@ -107,7 +103,7 @@ WidthIterator::WidthIterator(const Font* font, const TextRun& run, const FontSty
         if (numSpaces == 0)
             m_padPerSpace = 0;
         else
-            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
+            m_padPerSpace = ceilf(m_run.padding() / numSpaces);
     }
 }
 
@@ -119,7 +115,7 @@ void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
     int currentCharacter = m_currentCharacter;
     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;
 
     float runWidthSoFar = m_runWidthSoFar;
@@ -163,20 +159,20 @@ 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_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);
             // 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_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())
                 width += m_font->letterSpacing();
@@ -215,13 +211,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_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;
         }
@@ -510,12 +506,7 @@ void Font::update(PassRefPtr<FontSelector> fontSelector) const
 
 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));
 }
 
 int Font::ascent() const
@@ -618,13 +609,13 @@ bool Font::canUseGlyphCache(const TextRun& run) const
 
 }
 
-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.
     GlyphBuffer glyphBuffer;
 
     float startX = point.x();
-    WidthIterator it(this, run, style);
+    WidthIterator it(this, run);
     it.advance(from);
     float beforeWidth = it.m_runWidthSoFar;
     it.advance(to, &glyphBuffer);
@@ -635,7 +626,7 @@ void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const Fo
     
     float afterWidth = it.m_runWidthSoFar;
 
-    if (style.rtl()) {
+    if (run.rtl()) {
         float finalRoundingWidth = it.m_finalRoundingWidth;
         it.advance(run.length());
         startX += finalRoundingWidth + it.m_runWidthSoFar - afterWidth;
@@ -643,18 +634,18 @@ void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const Fo
         startX += beforeWidth;
 
     // 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);
 
     // Calculate the starting point of the glyphs to be displayed by adding
     // 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.
     const FontData* fontData = glyphBuffer.fontDataAt(0);
@@ -679,7 +670,7 @@ void Font::drawGlyphBuffer(GraphicsContext* context, const GlyphBuffer& glyphBuf
     drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint);
 }
 
-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.
     if (m_fontList && m_fontList->loadingCustomFonts())
@@ -687,43 +678,43 @@ void Font::drawText(GraphicsContext* context, const TextRun& run, const FontStyl
     
     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);
+        drawComplexText(context, run, point, from, to);
 }
 
-float Font::floatWidth(const TextRun& run, const FontStyle& style) const
+float Font::floatWidth(const TextRun& run) const
 {
     if (canUseGlyphCache(run))
-        return floatWidthForSimpleText(run, style, 0);
-    return floatWidthForComplexText(run, style);
+        return floatWidthForSimpleText(run, 0);
+    return floatWidthForComplexText(run);
 }
 
-float Font::floatWidthForSimpleText(const TextRun& run, const FontStyle& style, GlyphBuffer* glyphBuffer) const
+float Font::floatWidthForSimpleText(const TextRun& run, GlyphBuffer* glyphBuffer) const
 {
-    WidthIterator it(this, run, style);
+    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);
+        return selectionRectForSimpleText(run, point, h, from, to);
+    return selectionRectForComplexText(run, point, h, from, to);
 }
 
-FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FontStyle& style, const IntPoint& point, int h, int from, int to) const
+FloatRect Font::selectionRectForSimpleText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
 {
-    WidthIterator it(this, run, style);
+    WidthIterator it(this, run);
     it.advance(from);
     float beforeWidth = it.m_runWidthSoFar;
     it.advance(to);
     float afterWidth = it.m_runWidthSoFar;
 
     // 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;
         return FloatRect(point.x() + floorf(totalWidth - afterWidth), point.y(), roundf(totalWidth - beforeWidth) - floorf(totalWidth - afterWidth), h);
@@ -732,22 +723,22 @@ FloatRect Font::selectionRectForSimpleText(const TextRun& run, const FontStyle&
     }
 }
 
-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);
+        return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
+    return offsetForPositionForComplexText(run, x, includePartialGlyphs);
 }
 
-int Font::offsetForPositionForSimpleText(const TextRun& run, const FontStyle& style, int x, bool includePartialGlyphs) const
+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;
             float w;
index 67c41dfea5ce06ce8ef488e84737149545fe7aa2..af703dccfc9d06577c7376f5774734f35125b2ac 100644 (file)
@@ -46,29 +46,76 @@ class GlyphBuffer;
 class GlyphPageTreeNode;
 class GraphicsContext;
 class IntPoint;
-class FontStyle;
 
 struct GlyphData;
 
 class TextRun {
 public:
-    TextRun(const UChar* c, int len)
-    :m_characters(c), m_len(len)
-    {}
+    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)
-    :m_characters(s.characters()), m_len(s.length())
-    {}
+    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]; }
     const UChar* data(int i) const { return &m_characters[i]; }
 
     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;
 };
 
 class Font {
@@ -95,15 +142,13 @@ public:
     
     void update(PassRefPtr<FontSelector>) const;
 
-    void drawText(GraphicsContext*, const TextRun&, const FontStyle&, const FloatPoint&, int from = 0, int to = -1) const;
+    void drawText(GraphicsContext*, const TextRun&, const FloatPoint&, int from = 0, int to = -1) const;
 
-    int width(const TextRun&, const FontStyle&) 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(); }
 
@@ -150,16 +195,16 @@ public:
 
 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;
     
diff --git a/WebCore/platform/graphics/FontStyle.h b/WebCore/platform/graphics/FontStyle.h
deleted file mode 100644 (file)
index 08cc681..0000000
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2006 Apple Computer, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public License
- * along with this library; see the file COPYING.LIB.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#ifndef FontStyle_h
-#define FontStyle_h
-
-namespace WebCore {
-
-class FontStyle {
-public:
-    FontStyle(bool allowTabs = false, int xpos = 0, int padding = 0, bool rtl = false, bool directionalOverride = false,
-              bool applyRunRounding = true, bool applyWordRounding = true)
-        : m_allowTabs(allowTabs)
-        , m_xpos(xpos)
-        , m_padding(padding)
-        , m_rtl(rtl)
-        , m_directionalOverride(directionalOverride)
-        , m_applyRunRounding(applyRunRounding)
-        , m_applyWordRounding(applyWordRounding)
-        , m_disableSpacing(false)
-    {
-    }
-
-    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:
-    bool m_allowTabs;
-    int m_xpos;
-    int m_padding;
-    bool m_rtl;
-    bool m_directionalOverride;
-    bool m_applyRunRounding;
-    bool m_applyWordRounding;
-    bool m_disableSpacing;
-};
-
-}
-
-#endif
index b28acfb680a80fc120341a479f419b7af4e64a9b..eeb88ed70c59d7a0112aab28cbf11b0321de83b9 100644 (file)
@@ -28,7 +28,6 @@
 
 #include "BidiResolver.h"
 #include "Font.h"
-#include "FontStyle.h"
 
 using namespace std;
 
@@ -242,27 +241,22 @@ void GraphicsContext::drawImage(Image* image, const IntRect& dest, const IntRect
 }
 
 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);
+    font().drawText(this, run, point, from, to);
 }
 
-void GraphicsContext::drawBidiText(const TextRun& run, const IntPoint& point, const FontStyle& style)
+void GraphicsContext::drawBidiText(const TextRun& run, const IntPoint& point)
 {
     if (paintingDisabled())
         return;
 
     BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
-    WTF::Unicode::Direction paragraphDirection = style.ltr() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
+    WTF::Unicode::Direction paragraphDirection = run.ltr() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
 
-    bidiResolver.setStatus(BidiStatus(paragraphDirection, paragraphDirection, paragraphDirection, new BidiContext(style.ltr() ? 0 : 1, paragraphDirection, style.directionalOverride())));
+    bidiResolver.setStatus(BidiStatus(paragraphDirection, paragraphDirection, paragraphDirection, new BidiContext(run.ltr() ? 0 : 1, paragraphDirection, run.directionalOverride())));
 
     bidiResolver.createBidiRunsForLine(TextRunIterator(&run, 0), TextRunIterator(&run, run.length()));
 
@@ -272,29 +266,29 @@ void GraphicsContext::drawBidiText(const TextRun& run, const IntPoint& point, co
     FloatPoint currPoint = point;
     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());
+        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, subrunStyle, currPoint);
+        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);
     }
 
     bidiResolver.deleteRuns();
 }
 
-void GraphicsContext::drawHighlightForText(const TextRun& run, const IntPoint& point, int h, const FontStyle& style, const Color& backgroundColor, int from, int to)
+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, style, point, h, from, to), backgroundColor);
+    fillRect(font().selectionRectForText(run, point, h, from, to), backgroundColor);
 }
 
 void GraphicsContext::initFocusRing(int width, int offset)
index 94901d82ef9f7f607e1e6561ffd3f22dcf8ac8f7..71eeffd95884badb1d0831b1a3bff869c27e35d5 100644 (file)
@@ -86,7 +86,6 @@ namespace WebCore {
     class KURL;
     class Path;
     class TextRun;
-    class FontStyle;
 
     // These bits can be ORed together for a total of 8 possible text drawing modes.
     const int cTextInvisible = 0;
@@ -173,9 +172,8 @@ namespace WebCore {
         void setTextDrawingMode(int);
 
         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&);
         
index e362f93d83d40846fdc456445768aa0dac388fa0..0490a9ff165f12ad825ff05fe3781bde496dbd22 100644 (file)
@@ -33,7 +33,6 @@
 #include "Font.h"
 #include "FontPlatformData.h"
 #include "TextBreakIterator.h"
-#include "FontStyle.h"
 #include <wtf/Assertions.h>
 #include <wtf/Vector.h>
 
@@ -96,10 +95,9 @@ static unsigned rightTruncateToBuffer(const String& string, unsigned length, uns
 static float stringWidth(const Font& renderer, const UChar* characters, unsigned length, bool disableRoundingHacks)
 {
     TextRun run(characters, length);
-    FontStyle style;
     if (disableRoundingHacks)
-        style.disableRoundingHacks();
-    return renderer.floatWidth(run, style);
+        run.disableRoundingHacks();
+    return renderer.floatWidth(run);
 }
 
 static String truncateString(const String& string, float maxWidth, const Font& font, TruncationFunction truncateToBuffer, bool disableRoundingHacks)
index b51f26f2c3187f076e3379209deea8aa96cf37ca..59181f8f64394c6add769653d1434b6fed0cfd73 100644 (file)
@@ -61,24 +61,24 @@ void Font::drawGlyphs(GraphicsContext* graphicsContext, const FontData* font, co
     cairo_show_glyphs(context, glyphs, numGlyphs);
 }
 
-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();
     return 0.0f;
 }
 
-int Font::offsetForPositionForComplexText(const TextRun&, const FontStyle&, int, bool) const
+int Font::offsetForPositionForComplexText(const TextRun&, int, bool) const
 {
     notImplemented();
     return 0;
 }
 
-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();
     return FloatRect();
index b5f1deab898fca34f9bc85a2b12db583316bee63..b0548a8d688b810b528ec8b39c8e474d00ac339d 100644 (file)
@@ -34,7 +34,6 @@
 #import "GraphicsContext.h"
 #import "IntRect.h"
 #import "Logging.h"
-#import "FontStyle.h"
 #import "WebCoreSystemInterface.h"
 #import "WebCoreTextRenderer.h"
 #import "ShapeArabic.h"
@@ -57,9 +56,8 @@ namespace WebCore {
 
 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)
         , m_charBuffer(0)
@@ -71,7 +69,6 @@ struct ATSULayoutParameters
     void initialize(const Font*, const GraphicsContext* = 0);
 
     const TextRun& m_run;
-    const FontStyle& m_style;
     
     const Font* m_font;
     
@@ -92,7 +89,9 @@ static TextRun addDirectionalOverride(const TextRun& run, bool rtl)
     memcpy(&charactersWithOverride[1], run.data(0), sizeof(UChar) * run.length());
     charactersWithOverride[run.length() + 1] = popDirectionalFormatting;
 
-    return TextRun(charactersWithOverride, run.length() + 2);
+    TextRun result = run;
+    result.setText(charactersWithOverride, run.length() + 2);
+    return result;
 }
 
 static void initializeATSUStyle(const FontData* fontData)
@@ -156,7 +155,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
     ItemCount count;
     ATSLayoutRecord *layoutRecords;
 
-    if (params->m_style.applyWordRounding()) {
+    if (params->m_run.applyWordRounding()) {
         status = ATSUDirectGetLayoutDataArrayPtrFromLineRef(iLineRef, kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, true, (void **)&layoutRecords, &count);
         if (status != noErr) {
             *oCallbackStatus = kATSULayoutOperationCallbackStatusContinue;
@@ -176,8 +175,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_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.
         ItemCount lastRoundingChar = 0;
@@ -213,7 +212,7 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
                 if (width && params->m_font->letterSpacing())
                     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;
                             padding = 0;
@@ -236,8 +235,8 @@ static OSStatus overrideLayoutOperation(ATSULayoutOperationSelector iCurrentOper
             if (Font::isRoundingHackCharacter(ch))
                 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 {
                     float roundingWidth = ceilf(lastAdjustedPos) - lastAdjustedPos;
@@ -352,14 +351,14 @@ void ATSULayoutParameters::initialize(const Font* font, const GraphicsContext* g
     CGContextRef cgContext = graphicsContext ? graphicsContext->platformContext() : (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
     
     ATSLineLayoutOptions lineLayoutOptions = kATSLineKeepSpacesOutOfMargin | kATSLineHasNoHangers;
-    Boolean rtl = m_style.rtl();
+    Boolean rtl = m_run.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_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);
 
@@ -416,7 +415,7 @@ void ATSULayoutParameters::initialize(const Font* font, const GraphicsContext* g
                 }
                 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]) {
                     if (!m_charBuffer) {
@@ -455,7 +454,7 @@ void ATSULayoutParameters::initialize(const Font* font, const GraphicsContext* g
         }
         substituteOffset += substituteLength;
     }
-    if (m_style.padding()) {
+    if (m_run.padding()) {
         float numSpaces = 0;
         unsigned k;
         for (k = 0; k < runLength; k++)
@@ -465,7 +464,7 @@ void ATSULayoutParameters::initialize(const Font* font, const GraphicsContext* g
         if (numSpaces == 0)
             m_padPerSpace = 0;
         else
-            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
+            m_padPerSpace = ceilf(m_run.padding() / numSpaces);
     } else
         m_padPerSpace = 0;
 }
@@ -477,15 +476,15 @@ static void disposeATSULayoutParameters(ATSULayoutParameters *params)
     delete []params->m_fonts;
 }
 
-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);
 
     ATSTrapezoid firstGlyphBounds;
@@ -503,22 +502,22 @@ FloatRect Font::selectionRectForComplexText(const TextRun& run, const FontStyle&
     
     FloatRect rect(point.x() + floorf(beforeWidth), point.y(), roundf(afterWidth) - floorf(beforeWidth), h);
 
-    if (style.directionalOverride())
+    if (run.directionalOverride())
         delete []adjustedRun.characters();
 
     return rect;
 }
 
-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);
     
     // ATSUI can't draw beyond -32768 to +32767 so we translate the CTM and tell ATSUI to draw at (0, 0).
@@ -540,16 +539,16 @@ void Font::drawComplexText(GraphicsContext* graphicsContext, const TextRun& run,
 
     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);
     
     OSStatus status;
@@ -568,11 +567,11 @@ float Font::floatWidthForComplexText(const TextRun& run, const FontStyle& style)
            MIN(FixedToFloat(firstGlyphBounds.upperLeft.x), FixedToFloat(firstGlyphBounds.lowerLeft.x));
 }
 
-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
 {
-    TextRun adjustedRun = style.directionalOverride() ? addDirectionalOverride(run, style.rtl()) : run;
+    TextRun adjustedRun = run.directionalOverride() ? addDirectionalOverride(run, run.rtl()) : run;
     
-    ATSULayoutParameters params(adjustedRun, style);
+    ATSULayoutParameters params(adjustedRun);
     params.initialize(this);
 
     UniCharArrayOffset primaryOffset = 0;
@@ -585,7 +584,7 @@ int Font::offsetForPositionForComplexText(const TextRun& run, const FontStyle& s
     unsigned offset;
     if (status == noErr) {
         offset = (unsigned)primaryOffset;
-        if (style.directionalOverride() && offset > 0)
+        if (run.directionalOverride() && offset > 0)
             offset--;
     } else
         // Failed to find offset!  Return 0 offset.
@@ -593,7 +592,7 @@ int Font::offsetForPositionForComplexText(const TextRun& run, const FontStyle& s
 
     disposeATSULayoutParameters(&params);
     
-    if (style.directionalOverride())
+    if (run.directionalOverride())
         delete []adjustedRun.characters();
 
     return offset;
index 57b279c9c43866b6e7ccddd795b2ae192837fe14..6d727282b0350a17744356a446d8ee6f60b8a3e0 100644 (file)
@@ -23,7 +23,6 @@
 #include "Font.h"
 #include "FontDescription.h"
 #include "FontSelector.h"
-#include "FontStyle.h"
 
 #include "GraphicsContext.h"
 #include <QTextLayout>
@@ -157,13 +156,13 @@ void Font::update(PassRefPtr<FontSelector>) const
     // don't think we need this
 }
 
-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());
     int letterSpacing = font.letterSpacing();
     int wordSpacing = font.wordSpacing();
     bool smallCaps = font.fontDescription().smallCaps();
-    int padding = style.padding();
+    int padding = run.padding();
     int numSpaces = 0;
     if (padding) {
         for (int i = 0; i < run.length(); i++)
@@ -183,7 +182,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
                 padding -= add;
                 --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;
 //         qDebug() << "space at 0" << offset;
@@ -201,7 +200,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
 //                 qDebug() << "    treatAsSpace:" << i << start;
                 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;
 //                     qDebug() << "   appending(1) " << components->last().string << components->last().width;
@@ -211,7 +210,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
                     padding -= add;
                     --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;
                 continue;
@@ -228,7 +227,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
             }
             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;
 //                 qDebug() << "   appending(2) " << components->last().string << components->last().width;
@@ -239,7 +238,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
         }
         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;
 //             qDebug() << "   appending(3) " << components->last().string << components->last().width;
@@ -251,7 +250,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
             if (Font::treatAsSpace(run[i])) {
                 if (i - start > 0) {
                     components->append(TextRunComponent(run.characters() + start, i - start,
-                                                        style.rtl(), 
+                                                        run.rtl(), 
                                                         f, offset));
                     offset += components->last().width;
                 }
@@ -261,7 +260,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
                     padding -= add;
                     --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)
                     offset += wordSpacing;
@@ -270,7 +269,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
         }
         if (run.length() - start > 0) {
             components->append(TextRunComponent(run.characters() + start, run.length() - start,
-                                                style.rtl(), 
+                                                run.rtl(), 
                                                 f, offset));
             offset += components->last().width;
         }
@@ -278,7 +277,7 @@ static int generateComponents(Vector<TextRunComponent, 1024>* components, const
     return offset;
 }
 
-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)
         to = run.length();
@@ -287,10 +286,10 @@ void Font::drawText(GraphicsContext* ctx, const TextRun& run, const FontStyle& s
     p->setPen(QColor(color));
 
     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);
         QRectF rect(clip.x(), clip.y() - ascent(), clip.width(), clip.height());
@@ -298,7 +297,7 @@ void Font::drawText(GraphicsContext* ctx, const TextRun& run, const FontStyle& s
         p->setClipRect(rect.toRect());
     }
 
-    if (style.rtl()) {
+    if (run.rtl()) {
         for (int i = 0; i < components.size(); ++i) {
             if (!components.at(i).isSpace()) {
                 p->setFont(*components.at(i).font);
@@ -319,37 +318,27 @@ void Font::drawText(GraphicsContext* ctx, const TextRun& run, const FontStyle& s
         p->restore();
 }
 
-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;
     return w;
 }
 
-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
 {
     return width(run);
 }
 
-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;
             int xs = xe - components.at(i).width;
@@ -401,8 +390,7 @@ int Font::offsetForPosition(const TextRun& run, const FontStyle& style, int posi
     return run.length();
 }
 
-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;
     for (int i = 0; i < components.size(); ++i) {
@@ -411,7 +399,7 @@ static float cursorToX(const Vector<TextRunComponent, 1024>& components, int wid
             continue;
         }
         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);
         layout.beginLayout();
@@ -427,17 +415,17 @@ static float cursorToX(const Vector<TextRunComponent, 1024>& components, int wid
     return width;
 }
 
-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);
 
index a9b11f65a18195f65df5559d40eecbc6763d66ec..3206a769f6ff40cc3e0b8d476001b7e011fc9a1e 100644 (file)
@@ -32,7 +32,6 @@
 #include "GraphicsContext.h"
 #include "IntRect.h"
 #include "NotImplemented.h"
-#include "FontStyle.h"
 #include "UniscribeController.h"
 #include <ApplicationServices/ApplicationServices.h>
 #include <WebKitSystemInterface/WebKitSystemInterface.h>
@@ -95,17 +94,17 @@ void Font::drawGlyphs(GraphicsContext* graphicsContext, const FontData* font, co
     wkRestoreFontSmoothingStyle(cgContext, oldFontSmoothingStyle);
 }
 
-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();
     it.advance(to);
     float afterWidth = it.runWidthSoFar();
 
     // 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();
         return FloatRect(point.x() + floorf(totalWidth - afterWidth), point.y(), roundf(totalWidth - beforeWidth) - floorf(totalWidth - afterWidth), h);
@@ -114,14 +113,14 @@ FloatRect Font::selectionRectForComplexText(const TextRun& run, const FontStyle&
     return FloatRect(point.x() + floorf(beforeWidth), point.y(), roundf(afterWidth) - floorf(beforeWidth), h);
 }
 
-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
 {
     // This glyph buffer holds our glyphs + advances + font data for each glyph.
     GlyphBuffer glyphBuffer;
 
     float startX = point.x();
-    UniscribeController controller(this, run, style);
+    UniscribeController controller(this, run);
     controller.advance(from);
     float beforeWidth = controller.runWidthSoFar();
     controller.advance(to, &glyphBuffer);
@@ -132,7 +131,7 @@ void Font::drawComplexText(GraphicsContext* context, const TextRun& run, const F
     
     float afterWidth = controller.runWidthSoFar();
 
-    if (style.rtl()) {
+    if (run.rtl()) {
         controller.advance(run.length());
         startX += controller.runWidthSoFar() - afterWidth;
     } else
@@ -140,19 +139,19 @@ void Font::drawComplexText(GraphicsContext* context, const TextRun& run, const F
 
     // 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);
 }
 
index 0d818b0b403febecc5bd951ef27c5a5d4841d0c0..85cf47b58d6c4fbff17a7522a0b969e1a76cd17f 100644 (file)
@@ -74,24 +74,24 @@ void Font::drawGlyphs(GraphicsContext* graphicsContext, const FontData* font, co
     dc->DrawText(text, (wxCoord)point.x(), ypoint);
 }
 
-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();
     return FloatRect();
 }
 
-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();
     return 0;
 }
 
-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();
     return 0;
index 52c47f89caf61aa2f28132cfae07c1aeae4a01fb..f57f30c21eb4e72a2f05a06a053da5199db2ef10 100644 (file)
@@ -30,7 +30,6 @@
 #import "FontData.h"
 #import "GraphicsContext.h"
 #import "IntPoint.h"
-#import "FontStyle.h"
 #import "WebFontCache.h"
 
 using namespace WebCore;
@@ -48,12 +47,11 @@ void WebCoreDrawTextAtPoint(const UniChar* buffer, unsigned length, NSPoint poin
     FontPlatformData f(font);
     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);
 }
@@ -63,9 +61,8 @@ float WebCoreTextFloatWidth(const UniChar* buffer, unsigned length , NSFont* fon
     FontPlatformData f(font);
     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);
 }
 
 static bool gShouldUseFontSmoothing = true;
index 08c965afb5d9f3f9cd5500317f499fc7e6882f1c..6f64acf547932ca314524ec0a2655b23ec7754ad 100644 (file)
@@ -35,7 +35,6 @@
 #include "PlatformScrollBar.h"
 #include "RenderTheme.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 #include <tchar.h>
 #include <windows.h>
 
@@ -510,8 +509,7 @@ void PopupMenu::paint(const IntRect& damageRect, HDC hdc)
             
         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);
         
@@ -528,7 +526,7 @@ void PopupMenu::paint(const IntRect& damageRect, HDC hdc)
         if (itemStyle->visibility() != HIDDEN) {
             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));
         }
     }
 
index 6eac6b19f3df7f1df7ddcc7d7920442740b1301b..73158510c56ba67002d00a0e354e4a467f496d75 100644 (file)
@@ -30,7 +30,6 @@
 #include "UniscribeController.h"
 #include "Font.h"
 #include "FontData.h"
-#include "FontStyle.h"
 #include <wtf/MathExtras.h>
 
 namespace WebCore {
@@ -39,10 +38,9 @@ namespace WebCore {
 // that does stuff in that method instead of doing everything in the constructor.  Have advance()
 // 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)
 , m_runWidthSoFar(0)
@@ -51,7 +49,7 @@ UniscribeController::UniscribeController(const Font* font, const TextRun& run, c
 , m_offsetX(0)
 , m_offsetPosition(0)
 {
-    m_padding = m_style.padding();
+    m_padding = m_run.padding();
     if (!m_padding)
         m_padPerSpace = 0;
     else {
@@ -63,7 +61,7 @@ UniscribeController::UniscribeController(const Font* font, const TextRun& run, c
         if (numSpaces == 0)
             m_padPerSpace = 0;
         else
-            m_padPerSpace = ceilf(m_style.padding() / numSpaces);
+            m_padPerSpace = ceilf(m_run.padding() / numSpaces);
     }
 
     // Null out our uniscribe structs
@@ -79,7 +77,7 @@ int UniscribeController::offsetForPosition(int x, bool includePartialGlyphs)
     advance(m_run.length());
     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;
     }
     m_computingOffsetPosition = false;
@@ -111,37 +109,37 @@ void UniscribeController::advance(unsigned offset, GlyphBuffer* glyphBuffer)
         Vector<UChar> smallCapsBuffer(length);
         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;
             if (!u_isUUppercase(c) && (newC = u_toupper(c)) != c) {
                 smallCapsBuffer[index] = newC;
                 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;
                 }
             } 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;
             }
         }
         
-        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);
         }
     } else
@@ -160,7 +158,7 @@ void UniscribeController::itemizeShapeAndPlace(const UChar* cp, unsigned length,
     }
     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))
                 return;
@@ -181,10 +179,10 @@ void UniscribeController::resetControlAndState()
     memset(&m_state, 0, sizeof(SCRIPT_STATE));
 
     // 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();
 }
 
 bool UniscribeController::shapeAndPlaceItem(const UChar* cp, unsigned i, bool smallCaps, GlyphBuffer* glyphBuffer)
@@ -320,7 +318,7 @@ bool UniscribeController::shapeAndPlaceItem(const UChar* cp, unsigned i, bool sm
         // Second, in fixed-pitch fonts we ensure that all glyphs that
         // 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;
 
         if (hasExtraSpacing) {
@@ -357,15 +355,15 @@ bool UniscribeController::shapeAndPlaceItem(const UChar* cp, unsigned i, bool sm
         // Force characters that are used to determine word boundaries for the rounding hack
         // 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);
 
         // Check to see if the next character is a "rounding hack character", if so, adjust the
         // 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;
         }
@@ -392,7 +390,7 @@ bool UniscribeController::shapeAndPlaceItem(const UChar* cp, unsigned i, bool sm
                     advances.data(), &item.a, &m_offsetPosition, &trailing);
         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;
             m_offsetPosition += m_currentCharacter + m_items[i].iCharPos;
index a4a030f80bca44db91650d3bf4dee3c5413ef633..4ba7325b99ad2a900e61fc818418fcae8b3833cc 100644 (file)
@@ -38,7 +38,7 @@ namespace WebCore {
 
 class UniscribeController {
 public:
-    UniscribeController(const Font*, const TextRun&, const FontStyle&);
+    UniscribeController(const Font*, const TextRun&);
 
     // Advance and measure/place up to the specified character.
     void advance(unsigned to, GlyphBuffer* = 0);
@@ -60,7 +60,6 @@ private:
 
     const Font& m_font;
     const TextRun& m_run;
-    const FontStyle& m_style;
 
     SCRIPT_CONTROL m_control;
     SCRIPT_STATE m_state;
index 304ca4a6cb405046b6368910d082325f1e263367..2e48815107a48d790c4a635c71fbb74f598457e0 100644 (file)
@@ -29,7 +29,6 @@
 #include "FontDescription.h"
 #include "GraphicsContext.h"
 #include "StringTruncator.h"
-#include "FontStyle.h"
 #include <wtf/unicode/Unicode.h>
 
 namespace WebCore {
@@ -47,14 +46,13 @@ static bool isOneLeftToRightRun(const TextRun& run)
 static void doDrawTextAtPoint(GraphicsContext& context, const String& text, const IntPoint& point, const Font& font, const Color& color, int underlinedIndex)
 {
     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);
     }
 
     if (underlinedIndex >= 0) {
@@ -63,12 +61,12 @@ static void doDrawTextAtPoint(GraphicsContext& context, const String& text, cons
         int beforeWidth;
         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);
         underlinePoint.move(beforeWidth, 1);
index 600e7c90b6c565e6375d5494099f9f132a6feb7d..7f563d5ac344733d2bfc0f8546a9eb654b2c5ddd 100644 (file)
@@ -25,7 +25,6 @@
 #include "Document.h"
 #include "GraphicsContext.h"
 #include "HitTestResult.h"
-#include "FontStyle.h"
 
 namespace WebCore {
 
@@ -47,8 +46,7 @@ void EllipsisBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty)
     }
 
     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)
         context->clearShadow();
index ca67370c6b7db555f1c44dcab13f9df4f5ee7315..14605feb6d7331d1ccfa907500bb1cc8d590fe5a 100644 (file)
@@ -32,7 +32,6 @@
 #include "RenderBlock.h"
 #include "RenderTheme.h"
 #include "Text.h"
-#include "FontStyle.h"
 #include "break_lines.h"
 #include <wtf/AlwaysInline.h>
 
@@ -96,8 +95,7 @@ IntRect InlineTextBox::selectionRect(int tx, int ty, int startPos, int endPos)
     int selHeight = selectionHeight();
     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)
         r.setWidth(0);
@@ -374,8 +372,6 @@ void InlineTextBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty)
 
     StringImpl* textStr = textObject()->text();
 
-    FontStyle fontStyle(textObject()->allowTabs(), 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
@@ -383,19 +379,23 @@ void InlineTextBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty)
         int endPoint = m_len;
         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;
         selectionStartEnd(sPos, ePos);
         if (paintSelectedTextSeparately) {
             // 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);
             }
         }
 
@@ -409,7 +409,8 @@ void InlineTextBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty)
             if (selectionTextShadow)
                 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();
                 
@@ -501,9 +502,8 @@ void InlineTextBox::paintSelection(GraphicsContext* p, int tx, int ty, RenderSty
     int y = selectionTop();
     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();
 }
 
@@ -524,9 +524,8 @@ void InlineTextBox::paintCompositionBackground(GraphicsContext* p, int tx, int t
 
     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();
 }
 
@@ -613,11 +612,10 @@ void InlineTextBox::paintSpellingOrGrammarMarker(GraphicsContext* pt, int tx, in
     if (grammar) {
         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);
     }
     
@@ -649,12 +647,11 @@ void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, int tx, int ty, Do
     
     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);
      
     // Optionally highlight the text
@@ -663,7 +660,7 @@ void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, int tx, int ty, Do
         pt->save();
         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();
     }
 }
@@ -801,8 +798,7 @@ 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->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);
 }
 
@@ -816,8 +812,7 @@ 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->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();
 }
 
index 484371b8a8fc2a43a3a4ea2b85bece856c32eb75..fea756549d828272b1ef9f7721c5b21840c7c383 100644 (file)
@@ -31,7 +31,6 @@
 #include "RenderText.h"
 #include "RenderTheme.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 #include <math.h>
 
 using namespace std;
@@ -176,8 +175,7 @@ void RenderFileUploadControl::paintObject(PaintInfo& paintInfo, int tx, int ty)
         const String& displayedFilename = m_fileChooser->basenameForWidth(style()->font(), maxFilenameWidth());        
         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
         int contentLeft = tx + borderLeft() + paddingLeft();
@@ -198,7 +196,7 @@ void RenderFileUploadControl::paintObject(PaintInfo& paintInfo, int tx, int ty)
         paintInfo.context->setFillColor(style()->color());
         
         // Draw the filename
-        paintInfo.context->drawBidiText(textRun, IntPoint(textX, textY), fontStyle);
+        paintInfo.context->drawBidiText(textRun, IntPoint(textX, textY));
         
         if (m_fileChooser->icon()) {
             // Determine where the icon should be placed
@@ -235,7 +233,7 @@ void RenderFileUploadControl::calcPrefWidths()
         // Figure out how big the filename space needs to be for a given number of characters
         // (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);
     }
 
index b556f8f604a46f2d8e4b4ae8739e109bb319de42..581aac5c38d121bdc6d19ffddf78f63bd29d080b 100644 (file)
@@ -38,7 +38,6 @@
 #include "HitTestResult.h"
 #include "Page.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 
 using namespace std;
 
index 5fd236e27459b0286d8c12fe5daa76f387b0dafb..fcc0d9aa82fe2641e03e70e859109190f91e581d 100644 (file)
@@ -46,7 +46,6 @@
 #include "PlatformScrollBar.h" 
 #include "RenderTheme.h"
 #include "RenderView.h"
-#include "FontStyle.h"
 #include <math.h>
 
 using namespace std;
@@ -101,7 +100,6 @@ void RenderListBox::updateFromElement()
         int size = numItems();
         
         float width = 0;
-        FontStyle fontStyle(0, 0, 0, false, false, false, false);
         for (int i = 0; i < size; ++i) {
             HTMLElement* element = listItems[i];
             String text;
@@ -117,7 +115,7 @@ void RenderListBox::updateFromElement()
             }
                 
             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);
             }
         }
@@ -338,12 +336,11 @@ void RenderListBox::paintItemForeground(PaintInfo& paintInfo, int tx, int ty, in
     
     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());
 }
 
 void RenderListBox::paintItemBackground(PaintInfo& paintInfo, int tx, int ty, int listIndex)
index 370d20b27893f3ba08e59845b1c68510f1d67217..04242e04b37416878b74b1728c7586ff741d65ba 100644 (file)
@@ -36,7 +36,6 @@
 #include "RenderBR.h"
 #include "RenderText.h"
 #include "RenderTheme.h"
-#include "FontStyle.h"
 #include <math.h>
 
 using namespace std;
@@ -140,7 +139,7 @@ void RenderMenuList::updateOptionsWidth()
         if (element->hasTagName(optionTag)) {
             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));
         }
     }
 
index 90b9ee235f419a0a392aeb712e46e67f3ad26bc7..dfd77ee4b650bf779d869ca6c9eb681281f1b39e 100644 (file)
@@ -33,7 +33,6 @@
 #include "RenderLayer.h"
 #include "Text.h"
 #include "TextBreakIterator.h"
-#include "FontStyle.h"
 #include "break_lines.h"
 #include <wtf/AlwaysInline.h>
 
@@ -412,7 +411,7 @@ ALWAYS_INLINE int RenderText::widthFromCache(const Font& f, int start, int len,
         return w;
     }
 
-    return f.width(TextRun(text()->characters() + start, len), FontStyle(allowTabs(), xPos));
+    return f.width(TextRun(text()->characters() + start, lenallowTabs(), xPos));
 }
 
 void RenderText::trimmedPrefWidths(int leadWidth,
@@ -671,7 +670,7 @@ void RenderText::calcPrefWidths(int leadWidth)
                     m_maxWidth = currMaxWidth;
                 currMaxWidth = 0;
             } else {
-                currMaxWidth += f.width(TextRun(txt + i, 1), FontStyle(allowTabs(), leadWidth + currMaxWidth));
+                currMaxWidth += f.width(TextRun(txt + i, 1allowTabs(), leadWidth + currMaxWidth));
                 needsWordSpacing = isSpace && !previousCharacterIsSpace && i == len - 1;
             }
             ASSERT(lastWordBoundary == i);
@@ -1025,7 +1024,7 @@ unsigned int RenderText::width(unsigned int from, unsigned int len, const Font&
         else
             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, lenallowTabs(), xPos));
 
     return w;
 }
index 35b9a4981f6c8cec1b3edd7241c863dbb2a138d5..fceca48053553c720dfd58aa809ed98b003f446a 100644 (file)
@@ -127,7 +127,7 @@ public:
 
     InlineTextBox* findNextInlineTextBox(int offset, int& pos) const;
 
-    int allowTabs() const { return !style()->collapseWhiteSpace(); }
+    bool allowTabs() const { return !style()->collapseWhiteSpace(); }
 
     void checkConsistency() const;
 
index 786d044c95d8f696473e174627c51da609c0496e..58358182c8ca9bd371a4eda309927f3c02570c6b 100644 (file)
@@ -46,7 +46,6 @@
 #include "Settings.h"
 #include "Text.h"
 #include "TextIterator.h"
-#include "FontStyle.h"
 #include "htmlediting.h"
 #include "visible_units.h"
 #include <math.h>
@@ -849,7 +848,7 @@ void RenderTextControl::calcPrefWidths()
         // Figure out how big a text control needs to be for a given number of characters
         // (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;
         if (m_multiLine) {
index 2b385eb31c0aa61c5a42865857e754f19ecb88bd..96695dca3c9355b085409df0d258b633495dfcad 100644 (file)
@@ -35,7 +35,6 @@
 #include "SVGPaintServer.h"
 #include "SVGRootInlineBox.h"
 #include "Text.h"
-#include "FontStyle.h"
 
 #include <float.h>
 
@@ -74,7 +73,7 @@ SVGRootInlineBox* SVGInlineTextBox::svgRootInlineBox() const
 
 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));
 }
 
 float SVGInlineTextBox::calculateGlyphHeight(RenderStyle* style, int offset) const
@@ -379,10 +378,9 @@ void SVGInlineTextBox::paintCharacters(RenderObject::PaintInfo& paintInfo, int t
     }
 
     IntPoint origin((int) svgChar.x, (int) svgChar.y);
-    TextRun run(chars, length);
-    FontStyle style = svgFontStyleForInlineTextBox(styleToUse, this, svgChar.x);
+    TextRun run = svgTextRunForInlineTextBox(chars, length, styleToUse, this, svgChar.x);
 
-    paintInfo.context->drawText(run, origin, style);
+    paintInfo.context->drawText(run, origin);
 
     if (paintInfo.phase != PaintPhaseSelection) {
         paintDocumentMarkers(paintInfo.context, tx, ty, styleToUse, font, false);
@@ -460,10 +458,9 @@ void SVGInlineTextBox::paintSelection(int boxStartOffset, const SVGChar& svgChar
     p->save();
 
     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();
 }
index b55ebf112a166847e417269985e02e27ab8f654c..2d6fcf8ff0abe766fcae11624228767b4604beb6 100644 (file)
@@ -40,7 +40,6 @@
 #include "SVGTextPositioningElement.h"
 #include "SVGURIReference.h"
 #include "Text.h"
-#include "FontStyle.h"
 #include "UnicodeRange.h"
 
 #include <float.h>
@@ -519,7 +518,7 @@ struct SVGRootInlineBoxPaintWalker {
 
             // 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);
             }
@@ -622,7 +621,7 @@ float cummulatedWidthOfInlineBoxCharacterRange(SVGInlineBoxCharacterRange& range
     RenderText* text = textBox->textObject();
     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));
 }
 
 float cummulatedHeightOfInlineBoxCharacterRange(SVGInlineBoxCharacterRange& range)
@@ -638,16 +637,16 @@ float cummulatedHeightOfInlineBoxCharacterRange(SVGInlineBoxCharacterRange& rang
     return (range.endOffset - range.startOffset) * (font.ascent() + font.descent());
 }
 
-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;
 }
 
 static float cummulatedWidthOrHeightOfTextChunk(SVGTextChunk& chunk, bool calcWidthOnly)
index 5a79a8487e6bfa782e46123d38a39abf35bc4eba..19337b6218c66fc5b93cea992da6f537ecd6da9c 100644 (file)
@@ -75,7 +75,7 @@ private:
 };
 
 // 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);
 float cummulatedHeightOfInlineBoxCharacterRange(SVGInlineBoxCharacterRange& range);