Changeset 237844 in webkit


Ignore:
Timestamp:
Nov 5, 2018 8:32:44 PM (5 years ago)
Author:
mmaxfield@apple.com
Message:

Clean up text decoration drawing code
​https://bugs.webkit.org/show_bug.cgi?id=191245

Reviewed by Zalan Bujtas.

This is some general clean up of the text decorations code. There is no behavior change.

This patch modifies GraphicsContext::drawLineForText() & friends to accept a FloatRect instead of a FloatPoint + float width.
This is helpful because it allows for easier bounding box calculations.
This patch also removes some redundant computations that the skip:ink codepath was performing.
This patch also refactors the wavy decoration parameters to not use out params.

No new tests because there is no behavior change.

  • platform/graphics/GraphicsContext.cpp:

(WebCore::GraphicsContext::computeUnderlineBoundsForText):
(WebCore::GraphicsContext::computeLineBoundsAndAntialiasingModeForText):

  • platform/graphics/GraphicsContext.h:
  • platform/graphics/GraphicsContextImpl.h:
  • platform/graphics/cg/GraphicsContextCG.cpp:

(WebCore::GraphicsContext::drawLineForText):
(WebCore::GraphicsContext::drawLinesForText):

  • platform/graphics/displaylists/DisplayListItems.cpp:

(WebCore::DisplayList::DrawLinesForText::apply const):
(WebCore::DisplayList::DrawLinesForText::localBounds const):
(WebCore::DisplayList::operator<<):

  • platform/graphics/displaylists/DisplayListItems.h:

(WebCore::DisplayList::DrawLinesForText::create):
(WebCore::DisplayList::DrawLinesForText::thickness const):
(WebCore::DisplayList::DrawLinesForText::DrawLinesForText):

  • platform/graphics/displaylists/DisplayListRecorder.cpp:

(WebCore::DisplayList::Recorder::drawLinesForText):

  • platform/graphics/displaylists/DisplayListRecorder.h:
  • rendering/InlineTextBox.cpp:

(WebCore::InlineTextBox::paintMarkedTextDecoration):
(WebCore::InlineTextBox::paintCompositionUnderline const):

  • rendering/SimpleLineLayoutFunctions.cpp:

(WebCore::SimpleLineLayout::paintFlow):

  • rendering/TextDecorationPainter.cpp:

(WebCore::strokeWavyTextDecoration):
(WebCore::translateIntersectionPointsToSkipInkBoundaries):
(WebCore::TextDecorationPainter::TextDecorationPainter):
(WebCore::TextDecorationPainter::paintTextDecoration):
(WebCore::drawSkipInkUnderline): Deleted.

  • rendering/TextDecorationPainter.h:

(WebCore::TextDecorationPainter::setInlineTextBox):
(WebCore::TextDecorationPainter::setWidth):
(WebCore::TextDecorationPainter::setFont): Deleted.
(WebCore::TextDecorationPainter::setBaseline): Deleted.

  • style/InlineTextBoxStyle.cpp:

(WebCore::getWavyStrokeParameters):
(WebCore::visualOverflowForDecorations):

  • style/InlineTextBoxStyle.h:
Location:
trunk/Source/WebCore
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r237843 r237844  
     12018-11-05  Myles C. Maxfield  <mmaxfield@apple.com>
     2
     3        Clean up text decoration drawing code
     4        https://bugs.webkit.org/show_bug.cgi?id=191245
     5
     6        Reviewed by Zalan Bujtas.
     7
     8        This is some general clean up of the text decorations code. There is no behavior change.
     9
     10        This patch modifies GraphicsContext::drawLineForText() & friends to accept a FloatRect instead of a FloatPoint + float width.
     11        This is helpful because it allows for easier bounding box calculations.
     12        This patch also removes some redundant computations that the skip:ink codepath was performing.
     13        This patch also refactors the wavy decoration parameters to not use out params.
     14
     15        No new tests because there is no behavior change.
     16
     17        * platform/graphics/GraphicsContext.cpp:
     18        (WebCore::GraphicsContext::computeUnderlineBoundsForText):
     19        (WebCore::GraphicsContext::computeLineBoundsAndAntialiasingModeForText):
     20        * platform/graphics/GraphicsContext.h:
     21        * platform/graphics/GraphicsContextImpl.h:
     22        * platform/graphics/cg/GraphicsContextCG.cpp:
     23        (WebCore::GraphicsContext::drawLineForText):
     24        (WebCore::GraphicsContext::drawLinesForText):
     25        * platform/graphics/displaylists/DisplayListItems.cpp:
     26        (WebCore::DisplayList::DrawLinesForText::apply const):
     27        (WebCore::DisplayList::DrawLinesForText::localBounds const):
     28        (WebCore::DisplayList::operator<<):
     29        * platform/graphics/displaylists/DisplayListItems.h:
     30        (WebCore::DisplayList::DrawLinesForText::create):
     31        (WebCore::DisplayList::DrawLinesForText::thickness const):
     32        (WebCore::DisplayList::DrawLinesForText::DrawLinesForText):
     33        * platform/graphics/displaylists/DisplayListRecorder.cpp:
     34        (WebCore::DisplayList::Recorder::drawLinesForText):
     35        * platform/graphics/displaylists/DisplayListRecorder.h:
     36        * rendering/InlineTextBox.cpp:
     37        (WebCore::InlineTextBox::paintMarkedTextDecoration):
     38        (WebCore::InlineTextBox::paintCompositionUnderline const):
     39        * rendering/SimpleLineLayoutFunctions.cpp:
     40        (WebCore::SimpleLineLayout::paintFlow):
     41        * rendering/TextDecorationPainter.cpp:
     42        (WebCore::strokeWavyTextDecoration):
     43        (WebCore::translateIntersectionPointsToSkipInkBoundaries):
     44        (WebCore::TextDecorationPainter::TextDecorationPainter):
     45        (WebCore::TextDecorationPainter::paintTextDecoration):
     46        (WebCore::drawSkipInkUnderline): Deleted.
     47        * rendering/TextDecorationPainter.h:
     48        (WebCore::TextDecorationPainter::setInlineTextBox):
     49        (WebCore::TextDecorationPainter::setWidth):
     50        (WebCore::TextDecorationPainter::setFont): Deleted.
     51        (WebCore::TextDecorationPainter::setBaseline): Deleted.
     52        * style/InlineTextBoxStyle.cpp:
     53        (WebCore::getWavyStrokeParameters):
     54        (WebCore::visualOverflowForDecorations):
     55        * style/InlineTextBoxStyle.h:
     56
    1572018-11-05  Myles C. Maxfield  <mmaxfield@apple.com>
    258

  • trunk/Source/WebCore/platform/graphics/GraphicsContext.cpp

    r237266 r237844  
    10841084#endif
    10851085
    1086 FloatRect GraphicsContext::computeUnderlineBoundsForText(const FloatPoint& point, float width, bool printing)
     1086FloatRect GraphicsContext::computeUnderlineBoundsForText(const FloatRect& rect, bool printing)
    10871087{
    10881088    Color dummyColor;
    1089     return computeLineBoundsAndAntialiasingModeForText(point, width, printing, dummyColor);
    1090 }
    1091 
    1092 FloatRect GraphicsContext::computeLineBoundsAndAntialiasingModeForText(const FloatPoint& point, float width, bool printing, Color& color)
    1093 {
    1094     FloatPoint origin = point;
    1095     float thickness = std::max(strokeThickness(), 0.5f);
     1089    return computeLineBoundsAndAntialiasingModeForText(rect, printing, dummyColor);
     1090}
     1091
     1092FloatRect GraphicsContext::computeLineBoundsAndAntialiasingModeForText(const FloatRect& rect, bool printing, Color& color)
     1093{
     1094    FloatPoint origin = rect.location();
     1095    float thickness = std::max(rect.height(), 0.5f);
    10961096    if (printing)
    1097         return FloatRect(origin, FloatSize(width, thickness));
     1097        return FloatRect(origin, FloatSize(rect.width(), thickness));
    10981098
    10991099    AffineTransform transform = getCTM(GraphicsContext::DefinitelyIncludeDeviceScale);
    … …  
    11091109    }
    11101110
    1111     FloatPoint devicePoint = transform.mapPoint(point);
     1111    FloatPoint devicePoint = transform.mapPoint(rect.location());
    11121112    // Visual overflow might occur here due to integral roundf/ceilf. visualOverflowForDecorations adjusts the overflow value for underline decoration.
    11131113    FloatPoint deviceOrigin = FloatPoint(roundf(devicePoint.x()), ceilf(devicePoint.y()));
    11141114    if (auto inverse = transform.inverse())
    11151115        origin = inverse.value().mapPoint(deviceOrigin);
    1116     return FloatRect(origin, FloatSize(width, thickness));
     1116    return FloatRect(origin, FloatSize(rect.width(), thickness));
    11171117}
    11181118

  • trunk/Source/WebCore/platform/graphics/GraphicsContext.h

    r237765 r237844  
    419419    FloatRect roundToDevicePixels(const FloatRect&, RoundingMode = RoundAllSides);
    420420
    421     FloatRect computeUnderlineBoundsForText(const FloatPoint&, float width, bool printing);
    422     WEBCORE_EXPORT void drawLineForText(const FloatPoint&, float width, bool printing, bool doubleLines = false, StrokeStyle = SolidStroke);
    423     void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines = false, StrokeStyle = SolidStroke);
     421    FloatRect computeUnderlineBoundsForText(const FloatRect&, bool printing);
     422    WEBCORE_EXPORT void drawLineForText(const FloatRect&, bool printing, bool doubleLines = false, StrokeStyle = SolidStroke);
     423    void drawLinesForText(const FloatPoint&, float thickness, const DashArray& widths, bool printing, bool doubleLines = false, StrokeStyle = SolidStroke);
    424424    void drawDotsForDocumentMarker(const FloatRect&, DocumentMarkerLineStyle);
    425425
    … …  
    627627    void platformFillRoundedRect(const FloatRoundedRect&, const Color&);
    628628
    629     FloatRect computeLineBoundsAndAntialiasingModeForText(const FloatPoint&, float width, bool printing, Color&);
     629    FloatRect computeLineBoundsAndAntialiasingModeForText(const FloatRect&, bool printing, Color&);
    630630
    631631    float dashedLineCornerWidthForStrokeWidth(float) const;

  • trunk/Source/WebCore/platform/graphics/GraphicsContextImpl.h

    r237765 r237844  
    7979    virtual void drawRect(const FloatRect&, float borderThickness) = 0;
    8080    virtual void drawLine(const FloatPoint&, const FloatPoint&) = 0;
    81     virtual void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines, float strokeThickness) = 0;
     81    virtual void drawLinesForText(const FloatPoint&, float thickness, const DashArray& widths, bool printing, bool doubleLines) = 0;
    8282    virtual void drawDotsForDocumentMarker(const FloatRect&, DocumentMarkerLineStyle) = 0;
    8383    virtual void drawEllipse(const FloatRect&) = 0;

  • trunk/Source/WebCore/platform/graphics/cairo/CairoOperations.cpp

    r237765 r237844  
    10241024}
    10251025
    1026 void drawLinesForText(PlatformContextCairo& platformContext, const FloatPoint& point, const DashArray& widths, bool printing, bool doubleUnderlines, const Color& color, float strokeThickness)
     1026void drawLinesForText(PlatformContextCairo& platformContext, const FloatPoint& point, float strokeThickness, const DashArray& widths, bool printing, bool doubleUnderlines, const Color& color)
    10271027{
    10281028    Color modifiedColor = color;

  • trunk/Source/WebCore/platform/graphics/cairo/CairoOperations.h

    r237765 r237844  
    145145void drawRect(PlatformContextCairo&, const FloatRect&, float, const Color&, StrokeStyle, const Color&);
    146146void drawLine(PlatformContextCairo&, const FloatPoint&, const FloatPoint&, StrokeStyle, const Color&, float, bool);
    147 void drawLinesForText(PlatformContextCairo&, const FloatPoint&, const DashArray&, bool, bool, const Color&, float);
     147void drawLinesForText(PlatformContextCairo&, const FloatPoint&, float thickness, const DashArray&, bool, bool, const Color&);
    148148void drawDotsForDocumentMarker(PlatformContextCairo&, const FloatRect&, DocumentMarkerLineStyle);
    149149void drawEllipse(PlatformContextCairo&, const FloatRect&, const Color&, StrokeStyle, const Color&, float);

  • trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp

    r237765 r237844  
    316316}
    317317
    318 void GraphicsContext::drawLineForText(const FloatPoint& origin, float width, bool printing, bool doubleUnderlines, StrokeStyle)
    319 {
    320     drawLinesForText(origin, DashArray { width, 0 }, printing, doubleUnderlines);
    321 }
    322 
    323 void GraphicsContext::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleUnderlines, StrokeStyle)
     318void GraphicsContext::drawLineForText(const FloatRect& rect, bool printing, bool doubleUnderlines, StrokeStyle)
     319{
     320    drawLinesForText(rect.location(), rect.height(), DashArray { rect.width(), 0 }, printing, doubleUnderlines);
     321}
     322
     323void GraphicsContext::drawLinesForText(const FloatPoint& point, float thickness, const DashArray& widths, bool printing, bool doubleUnderlines, StrokeStyle)
    324324{
    325325    if (paintingDisabled())
    … …  
    330330
    331331    if (m_impl) {
    332         m_impl->drawLinesForText(point, widths, printing, doubleUnderlines, strokeThickness());
    333         return;
    334     }
    335 
    336     ASSERT(hasPlatformContext());
    337     Cairo::drawLinesForText(*platformContext(), point, widths, printing, doubleUnderlines, m_state.strokeColor, m_state.strokeThickness);
     332        m_impl->drawLinesForText(point, thickness, widths, printing, doubleUnderlines);
     333        return;
     334    }
     335
     336    ASSERT(hasPlatformContext());
     337    Cairo::drawLinesForText(*platformContext(), point, thickness, widths, printing, doubleUnderlines, m_state.strokeColor);
    338338}
    339339

  • trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp

    r237765 r237844  
    297297}
    298298
    299 void GraphicsContextImplCairo::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleUnderlines, float strokeThickness)
    300 {
    301     UNUSED_PARAM(strokeThickness);
    302     auto& state = graphicsContext().state();
    303     Cairo::drawLinesForText(m_platformContext, point, widths, printing, doubleUnderlines, state.strokeColor, state.strokeThickness);
     299void GraphicsContextImplCairo::drawLinesForText(const FloatPoint& point, float thickness, const DashArray& widths, bool printing, bool doubleUnderlines)
     300{
     301    auto& state = graphicsContext().state();
     302    Cairo::drawLinesForText(m_platformContext, point, thickness, widths, printing, doubleUnderlines, state.strokeColor);
    304303}
    305304

  • trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h

    r237765 r237844  
    8080    void drawRect(const FloatRect&, float) override;
    8181    void drawLine(const FloatPoint&, const FloatPoint&) override;
    82     void drawLinesForText(const FloatPoint&, const DashArray&, bool, bool, float) override;
     82    void drawLinesForText(const FloatPoint&, float thickness, const DashArray&, bool, bool) override;
    8383    void drawDotsForDocumentMarker(const FloatRect&, DocumentMarkerLineStyle) override;
    8484    void drawEllipse(const FloatRect&) override;

  • trunk/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp

    r237405 r237844  
    15711571}
    15721572
    1573 void GraphicsContext::drawLineForText(const FloatPoint& point, float width, bool printing, bool doubleLines, StrokeStyle strokeStyle)
     1573void GraphicsContext::drawLineForText(const FloatRect& rect, bool printing, bool doubleLines, StrokeStyle strokeStyle)
    15741574{
    15751575    DashArray widths;
    1576     widths.append(width);
     1576    widths.append(rect.width());
    15771577    widths.append(0);
    1578     drawLinesForText(point, widths, printing, doubleLines, strokeStyle);
    1579 }
    1580 
    1581 void GraphicsContext::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleLines, StrokeStyle strokeStyle)
     1578    drawLinesForText(rect.location(), rect.height(), widths, printing, doubleLines, strokeStyle);
     1579}
     1580
     1581void GraphicsContext::drawLinesForText(const FloatPoint& point, float thickness, const DashArray& widths, bool printing, bool doubleLines, StrokeStyle strokeStyle)
    15821582{
    15831583    if (paintingDisabled())
    … …  
    15881588
    15891589    if (m_impl) {
    1590         m_impl->drawLinesForText(point, widths, printing, doubleLines, strokeThickness());
     1590        m_impl->drawLinesForText(point, thickness, widths, printing, doubleLines);
    15911591        return;
    15921592    }
    … …  
    15941594    Color localStrokeColor(strokeColor());
    15951595
    1596     FloatRect bounds = computeLineBoundsAndAntialiasingModeForText(point, widths.last(), printing, localStrokeColor);
     1596    FloatRect bounds = computeLineBoundsAndAntialiasingModeForText(FloatRect(point, FloatSize(widths.last(), thickness)), printing, localStrokeColor);
    15971597    bool fillColorIsNotEqualToStrokeColor = fillColor() != localStrokeColor;
    15981598   

  • trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp

    r237765 r237844  
    594594void DrawLinesForText::apply(GraphicsContext& context) const
    595595{
    596     context.drawLinesForText(point(), m_widths, m_printing, m_doubleLines);
     596    context.drawLinesForText(point(), m_thickness, m_widths, m_printing, m_doubleLines);
    597597}
    598598
    … …  
    604604        return FloatRect();
    605605
    606     FloatRect result(point(), FloatSize(m_widths.last(), m_strokeWidth));
     606    FloatRect result(point(), FloatSize(m_widths.last(), m_thickness));
    607607    result.inflate(1); // Account for pixel snapping. FIXME: This isn't perfect, as it doesn't take the CTM into account.
    608608    return result;
    … …  
    615615    ts.dumpProperty("local-anchor", item.localAnchor());
    616616    ts.dumpProperty("point", item.point());
     617    ts.dumpProperty("thickness", item.thickness());
    617618    ts.dumpProperty("double", item.doubleLines());
    618619    ts.dumpProperty("widths", item.widths());

  • trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h

    r237765 r237844  
    792792class DrawLinesForText : public DrawingItem {
    793793public:
    794     static Ref<DrawLinesForText> create(const FloatPoint& blockLocation, const FloatSize& localAnchor, const DashArray& widths, bool printing, bool doubleLines, float strokeWidth)
    795     {
    796         return adoptRef(*new DrawLinesForText(blockLocation, localAnchor, widths, printing, doubleLines, strokeWidth));
     794    static Ref<DrawLinesForText> create(const FloatPoint& blockLocation, const FloatSize& localAnchor, float thickness, const DashArray& widths, bool printing, bool doubleLines)
     795    {
     796        return adoptRef(*new DrawLinesForText(blockLocation, localAnchor, thickness, widths, printing, doubleLines));
    797797    }
    798798
    … …  
    801801    const FloatSize& localAnchor() const { return m_localAnchor; }
    802802    FloatPoint point() const { return m_blockLocation + m_localAnchor; }
     803    float thickness() const { return m_thickness; }
    803804    const DashArray& widths() const { return m_widths; }
    804805    bool isPrinting() const { return m_printing; }
    … …  
    806807
    807808private:
    808     DrawLinesForText(const FloatPoint& blockLocation, const FloatSize& localAnchor, const DashArray& widths, bool printing, bool doubleLines, float strokeWidth)
     809    DrawLinesForText(const FloatPoint& blockLocation, const FloatSize& localAnchor, float thickness, const DashArray& widths, bool printing, bool doubleLines)
    809810        : DrawingItem(ItemType::DrawLinesForText)
    810811        , m_blockLocation(blockLocation)
    811812        , m_localAnchor(localAnchor)
    812813        , m_widths(widths)
    813         , m_strokeWidth(strokeWidth)
     814        , m_thickness(thickness)
    814815        , m_printing(printing)
    815816        , m_doubleLines(doubleLines)
    … …  
    824825    FloatSize m_localAnchor;
    825826    DashArray m_widths;
    826     float m_strokeWidth;
     827    float m_thickness;
    827828    bool m_printing;
    828829    bool m_doubleLines;

  • trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp

    r237765 r237844  
    231231}
    232232
    233 void Recorder::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleLines, float strokeThickness)
    234 {
    235     DrawingItem& newItem = downcast<DrawingItem>(appendItem(DrawLinesForText::create(FloatPoint(), toFloatSize(point), widths, printing, doubleLines, strokeThickness)));
     233void Recorder::drawLinesForText(const FloatPoint& point, float thickness, const DashArray& widths, bool printing, bool doubleLines)
     234{
     235    DrawingItem& newItem = downcast<DrawingItem>(appendItem(DrawLinesForText::create(FloatPoint(), toFloatSize(point), thickness, widths, printing, doubleLines)));
    236236    updateItemExtent(newItem);
    237237}

  • trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h

    r237765 r237844  
    9898    void drawRect(const FloatRect&, float borderThickness) override;
    9999    void drawLine(const FloatPoint&, const FloatPoint&) override;
    100     void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines, float strokeThickness) override;
     100    void drawLinesForText(const FloatPoint&, float thickness, const DashArray& widths, bool printing, bool doubleLines) override;
    101101    void drawDotsForDocumentMarker(const FloatRect&, DocumentMarkerLineStyle) override;
    102102    void drawEllipse(const FloatRect&) override;

  • trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp

    r237765 r237844  
    632632}
    633633
    634 void CairoOperationRecorder::drawLinesForText(const FloatPoint& point, const DashArray& widths, bool printing, bool doubleUnderlines, float strokeThickness)
    635 {
    636     struct DrawLinesForText final : PaintingOperation, OperationData<FloatPoint, DashArray, bool, bool, Color, float> {
     634void CairoOperationRecorder::drawLinesForText(const FloatPoint& point, float thickness, const DashArray& widths, bool printing, bool doubleUnderlines)
     635{
     636    struct DrawLinesForText final : PaintingOperation, OperationData<FloatPoint, float, DashArray, bool, bool, Color> {
    637637        virtual ~DrawLinesForText() = default;
    638638
    … …  
    648648    };
    649649
    650     UNUSED_PARAM(strokeThickness);
    651     auto& state = graphicsContext().state();
    652     append(createCommand<DrawLinesForText>(point, widths, printing, doubleUnderlines, state.strokeColor, state.strokeThickness));
     650    auto& state = graphicsContext().state();
     651    append(createCommand<DrawLinesForText>(point, thickness, widths, printing, doubleUnderlines, state.strokeColor));
    653652}
    654653

  • trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h

    r237765 r237844  
    7373    void drawRect(const WebCore::FloatRect&, float) override;
    7474    void drawLine(const WebCore::FloatPoint&, const WebCore::FloatPoint&) override;
    75     void drawLinesForText(const WebCore::FloatPoint&, const DashArray&, bool, bool, float) override;
     75    void drawLinesForText(const WebCore::FloatPoint&, float thickness, const DashArray&, bool, bool) override;
    7676    void drawDotsForDocumentMarker(const WebCore::FloatRect&, WebCore::DocumentMarkerLineStyle) override;
    7777    void drawEllipse(const WebCore::FloatRect&) override;

  • trunk/Source/WebCore/platform/win/WebCoreTextRenderer.cpp

    r195180 r237844  
    7373
    7474        context.setStrokeColor(color);
    75         context.drawLineForText(underlinePoint, underlinedWidth, false);
     75        context.drawLineForText(FloatRect(underlinePoint, FloatSize(underlinedWidth, font.size() / 16)), false);
    7676    }
    7777}

  • trunk/Source/WebCore/rendering/InlineTextBox.cpp

    r237834 r237844  
    10911091
    10921092    // 2. Paint
    1093     TextDecorationPainter decorationPainter { context, lineStyle().textDecorationsInEffect(), renderer(), isFirstLine(), markedText.style.textDecorationStyles };
     1093    TextDecorationPainter decorationPainter { context, lineStyle().textDecorationsInEffect(), renderer(), isFirstLine(), lineFont(), markedText.style.textDecorationStyles };
    10941094    decorationPainter.setInlineTextBox(this);
    1095     decorationPainter.setFont(lineFont());
    10961095    decorationPainter.setWidth(snappedSelectionRect.width());
    1097     decorationPainter.setBaseline(lineStyle().fontMetrics().ascent());
    10981096    decorationPainter.setIsHorizontal(isHorizontal());
    10991097    if (markedText.style.textShadow) {
    … …  
    12011199    context.setStrokeColor(underlineColor);
    12021200    context.setStrokeThickness(lineThickness);
    1203     context.drawLineForText(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + logicalHeight() - lineThickness), width, renderer().document().printing());
     1201    context.drawLineForText(FloatRect(boxOrigin.x() + start, boxOrigin.y() + logicalHeight() - lineThickness, width, lineThickness), renderer().document().printing());
    12041202}
    12051203

  • trunk/Source/WebCore/rendering/SimpleLineLayoutFunctions.cpp

    r234619 r237844  
    9898        const RenderText* textRenderer = childrenOfType<RenderText>(flow).first();
    9999        if (textRenderer) {
    100             textDecorationPainter.emplace(paintInfo.context(), style.textDecorationsInEffect(), *textRenderer, false);
    101             textDecorationPainter->setFont(style.fontCascade());
    102             textDecorationPainter->setBaseline(style.fontMetrics().ascent());
     100            textDecorationPainter.emplace(paintInfo.context(), style.textDecorationsInEffect(), *textRenderer, false, style.fontCascade());
    103101        }
    104102    }

  • trunk/Source/WebCore/rendering/TextDecorationPainter.cpp

    r235560 r237844  
    8282 *                 step
    8383 */
    84 static void strokeWavyTextDecoration(GraphicsContext& context, const FloatPoint& start, const FloatPoint& end, float strokeThickness, float fontSize)
    85 {
    86     FloatPoint p1 = start;
    87     FloatPoint p2 = end;
    88     context.adjustLineToPixelBoundaries(p1, p2, strokeThickness, context.strokeStyle());
     84static void strokeWavyTextDecoration(GraphicsContext& context, const FloatRect& rect, float fontSize)
     85{
     86    FloatPoint p1 = rect.minXMinYCorner();
     87    FloatPoint p2 = rect.maxXMinYCorner();
     88    context.adjustLineToPixelBoundaries(p1, p2, rect.height(), context.strokeStyle());
    8989
    9090    Path path;
    9191    path.moveTo(p1);
    9292
    93     float controlPointDistance;
    94     float step;
    95     getWavyStrokeParameters(fontSize, controlPointDistance, step);
    96 
    97     bool isVerticalLine = (p1.x() == p2.x());
    98 
    99     if (isVerticalLine) {
    100         ASSERT(p1.x() == p2.x());
    101 
    102         float xAxis = p1.x();
    103         float y1;
    104         float y2;
    105 
    106         if (p1.y() < p2.y()) {
    107             y1 = p1.y();
    108             y2 = p2.y();
    109         } else {
    110             y1 = p2.y();
    111             y2 = p1.y();
    112         }
    113 
    114         adjustStepToDecorationLength(step, controlPointDistance, y2 - y1);
    115         FloatPoint controlPoint1(xAxis + controlPointDistance, 0);
    116         FloatPoint controlPoint2(xAxis - controlPointDistance, 0);
    117 
    118         for (float y = y1; y + 2 * step <= y2;) {
    119             controlPoint1.setY(y + step);
    120             controlPoint2.setY(y + step);
    121             y += 2 * step;
    122             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(xAxis, y));
    123         }
    124     } else {
    125         ASSERT(p1.y() == p2.y());
    126 
    127         float yAxis = p1.y();
    128         float x1;
    129         float x2;
    130 
    131         if (p1.x() < p2.x()) {
    132             x1 = p1.x();
    133             x2 = p2.x();
    134         } else {
    135             x1 = p2.x();
    136             x2 = p1.x();
    137         }
    138 
    139         adjustStepToDecorationLength(step, controlPointDistance, x2 - x1);
    140         FloatPoint controlPoint1(0, yAxis + controlPointDistance);
    141         FloatPoint controlPoint2(0, yAxis - controlPointDistance);
    142 
    143         for (float x = x1; x + 2 * step <= x2;) {
    144             controlPoint1.setX(x + step);
    145             controlPoint2.setX(x + step);
    146             x += 2 * step;
    147             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
    148         }
     93    auto wavyStrokeParameters = getWavyStrokeParameters(fontSize);
     94
     95    ASSERT(p1.y() == p2.y());
     96
     97    float yAxis = p1.y();
     98    float x1 = std::min(p1.x(), p2.x());
     99    float x2 = std::max(p1.x(), p2.x());
     100
     101    adjustStepToDecorationLength(wavyStrokeParameters.step, wavyStrokeParameters.controlPointDistance, x2 - x1);
     102    FloatPoint controlPoint1(0, yAxis + wavyStrokeParameters.controlPointDistance);
     103    FloatPoint controlPoint2(0, yAxis - wavyStrokeParameters.controlPointDistance);
     104
     105    for (float x = x1; x + 2 * wavyStrokeParameters.step <= x2;) {
     106        controlPoint1.setX(x + wavyStrokeParameters.step);
     107        controlPoint2.setX(x + wavyStrokeParameters.step);
     108        x += 2 * wavyStrokeParameters.step;
     109        path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
    149110    }
    150111
    151112    context.setShouldAntialias(true);
     113    auto strokeThickness = context.strokeThickness();
     114    context.setStrokeThickness(rect.height());
    152115    context.strokePath(path);
     116    context.setStrokeThickness(strokeThickness);
    153117}
    154118
    … …  
    203167   
    204168    return result;
    205 }
    206 
    207 static void drawSkipInkUnderline(GraphicsContext& context, const FontCascade& font, const TextRun& textRun, const FloatPoint& textOrigin, const FloatPoint& localOrigin,
    208     float underlineOffset, float width, bool isPrinting, bool doubleLines, StrokeStyle strokeStyle)
    209 {
    210     FloatPoint adjustedLocalOrigin = localOrigin;
    211     adjustedLocalOrigin.move(0, underlineOffset);
    212     FloatRect underlineBoundingBox = context.computeUnderlineBoundsForText(adjustedLocalOrigin, width, isPrinting);
    213     DashArray intersections = font.dashesForIntersectionsWithRect(textRun, textOrigin, underlineBoundingBox);
    214     DashArray a = translateIntersectionPointsToSkipInkBoundaries(intersections, underlineBoundingBox.height(), width);
    215     ASSERT(!(a.size() % 2));
    216     context.drawLinesForText(adjustedLocalOrigin, a, isPrinting, doubleLines, strokeStyle);
    217169}
    218170#endif
    … …  
    248200}
    249201
    250 TextDecorationPainter::TextDecorationPainter(GraphicsContext& context, OptionSet<TextDecoration> decorations, const RenderText& renderer, bool isFirstLine, std::optional<Styles> styles)
     202TextDecorationPainter::TextDecorationPainter(GraphicsContext& context, OptionSet<TextDecoration> decorations, const RenderText& renderer, bool isFirstLine, const FontCascade& font, std::optional<Styles> styles)
    251203    : m_context { context }
    252204    , m_decorations { decorations }
    253205    , m_wavyOffset { wavyOffsetFromDecoration() }
    254206    , m_isPrinting { renderer.document().printing() }
     207    , m_font { font }
    255208    , m_styles { styles ? *WTFMove(styles) : stylesForRenderer(renderer, decorations, isFirstLine, PseudoId::None) }
    256209    , m_lineStyle { isFirstLine ? renderer.firstLineStyle() : renderer.style() }
    … …  
    264217    UNUSED_PARAM(textOrigin);
    265218#endif
    266     ASSERT(m_font);
     219    const auto& fontMetrics = m_lineStyle.fontMetrics();
    267220    float textDecorationThickness = textDecorationStrokeThickness(m_lineStyle.computedFontPixelSize());
    268     m_context.setStrokeThickness(textDecorationThickness);
    269221    FloatPoint localOrigin = boxOrigin;
    270222
    271     auto paintDecoration = [&] (OptionSet<TextDecoration> decoration, TextDecorationStyle style, const Color& color, const FloatPoint& start, const FloatPoint& end, int offset) {
     223    auto paintDecoration = [&] (TextDecoration decoration, TextDecorationStyle style, const Color& color, const FloatRect& rect) {
    272224        m_context.setStrokeColor(color);
    273225
    … …  
    275227
    276228        if (style == TextDecorationStyle::Wavy)
    277             strokeWavyTextDecoration(m_context, start, end, textDecorationThickness, m_lineStyle.computedFontPixelSize());
     229            strokeWavyTextDecoration(m_context, rect, m_lineStyle.computedFontPixelSize());
    278230        else if (decoration == TextDecoration::Underline || decoration == TextDecoration::Overline) {
    279231#if ENABLE(CSS3_TEXT_DECORATION_SKIP_INK)
    280232            if ((m_lineStyle.textDecorationSkip() == TextDecorationSkip::Ink || m_lineStyle.textDecorationSkip() == TextDecorationSkip::Auto) && m_isHorizontal) {
    281                 if (!m_context.paintingDisabled())
    282                     drawSkipInkUnderline(m_context, *m_font, textRun, textOrigin, localOrigin, offset, m_width, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
     233                if (!m_context.paintingDisabled()) {
     234                    FloatRect underlineBoundingBox = m_context.computeUnderlineBoundsForText(rect, m_isPrinting);
     235                    DashArray intersections = m_font.dashesForIntersectionsWithRect(textRun, textOrigin, underlineBoundingBox);
     236                    DashArray boundaries = translateIntersectionPointsToSkipInkBoundaries(intersections, underlineBoundingBox.height(), rect.width());
     237                    ASSERT(!(boundaries.size() % 2));
     238                    // We don't use underlineBoundingBox here because drawLinesForText() will run computeUnderlineBoundsForText() internally.
     239                    m_context.drawLinesForText(rect.location(), rect.height(), boundaries, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
     240                }
    283241            } else
    284242                // FIXME: Need to support text-decoration-skip: none.
    285243#endif
    286                 m_context.drawLineForText(start, m_width, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
     244                m_context.drawLineForText(rect, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
    287245           
    288246        } else {
    289247            ASSERT(decoration == TextDecoration::LineThrough);
    290             m_context.drawLineForText(start, m_width, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
     248            m_context.drawLineForText(rect, m_isPrinting, style == TextDecorationStyle::Double, strokeStyle);
    291249        }
    292250    };
    … …  
    299257    bool clipping = !areLinesOpaque && m_shadow && m_shadow->next();
    300258    if (clipping) {
    301         FloatRect clipRect(localOrigin, FloatSize(m_width, m_baseline + 2));
     259        FloatRect clipRect(localOrigin, FloatSize(m_width, fontMetrics.ascent() + 2));
    302260        for (const ShadowData* shadow = m_shadow; shadow; shadow = shadow->next()) {
    303261            int shadowExtent = shadow->paintingExtent();
    304             FloatRect shadowRect(localOrigin, FloatSize(m_width, m_baseline + 2));
     262            FloatRect shadowRect(localOrigin, FloatSize(m_width, fontMetrics.ascent() + 2));
    305263            shadowRect.inflate(shadowExtent);
    306264            int shadowX = m_isHorizontal ? shadow->x() : shadow->y();
    … …  
    312270        m_context.save();
    313271        m_context.clip(clipRect);
    314         extraOffset += m_baseline + 2;
     272        extraOffset += fontMetrics.ascent() + 2;
    315273        localOrigin.move(0, extraOffset);
    316274    }
    … …  
    338296            int offset = computeUnderlineOffset(m_lineStyle.textUnderlinePosition(), m_lineStyle.fontMetrics(), m_inlineTextBox, textDecorationThickness);
    339297            float wavyOffset = m_styles.underlineStyle == TextDecorationStyle::Wavy ? m_wavyOffset : 0;
    340             FloatPoint start = localOrigin + FloatSize(0, offset + wavyOffset);
    341             FloatPoint end = localOrigin + FloatSize(m_width, offset + wavyOffset);
    342             paintDecoration(TextDecoration::Underline, m_styles.underlineStyle, m_styles.underlineColor, start, end, offset);
     298            FloatRect rect(localOrigin, FloatSize(m_width, textDecorationThickness));
     299            rect.move(0, offset + wavyOffset);
     300            paintDecoration(TextDecoration::Underline, m_styles.underlineStyle, m_styles.underlineColor, rect);
    343301        }
    344302        if (m_decorations.contains(TextDecoration::Overline)) {
    345303            float wavyOffset = m_styles.overlineStyle == TextDecorationStyle::Wavy ? m_wavyOffset : 0;
    346             FloatPoint start = localOrigin - FloatSize(0, wavyOffset);
    347             FloatPoint end = localOrigin + FloatSize(m_width, -wavyOffset);
    348             paintDecoration(TextDecoration::Overline, m_styles.overlineStyle, m_styles.overlineColor, start, end, 0);
     304            FloatRect rect(localOrigin, FloatSize(m_width, textDecorationThickness));
     305            rect.move(0, -wavyOffset);
     306            paintDecoration(TextDecoration::Overline, m_styles.overlineStyle, m_styles.overlineColor, rect);
    349307        }
    350308        if (m_decorations.contains(TextDecoration::LineThrough)) {
    351             FloatPoint start = localOrigin + FloatSize(0, 2 * m_baseline / 3);
    352             FloatPoint end = localOrigin + FloatSize(m_width, 2 * m_baseline / 3);
    353             paintDecoration(TextDecoration::LineThrough, m_styles.linethroughStyle, m_styles.linethroughColor, start, end, 0);
     309            FloatRect rect(localOrigin, FloatSize(m_width, textDecorationThickness));
     310            rect.move(0, 2 * fontMetrics.floatAscent() / 3);
     311            paintDecoration(TextDecoration::LineThrough, m_styles.linethroughStyle, m_styles.linethroughColor, rect);
    354312        }
    355313    } while (shadow);

  • trunk/Source/WebCore/rendering/TextDecorationPainter.h

    r232229 r237844  
    4343public:
    4444    struct Styles;
    45     TextDecorationPainter(GraphicsContext&, OptionSet<TextDecoration> decorations, const RenderText&, bool isFirstLine, std::optional<Styles> = std::nullopt);
     45    TextDecorationPainter(GraphicsContext&, OptionSet<TextDecoration> decorations, const RenderText&, bool isFirstLine, const FontCascade&, std::optional<Styles> = std::nullopt);
    4646   
    4747    void setInlineTextBox(const InlineTextBox* inlineTextBox) { m_inlineTextBox = inlineTextBox; }
    48     void setFont(const FontCascade& font) { m_font = &font; }
    4948    void setIsHorizontal(bool isHorizontal) { m_isHorizontal = isHorizontal; }
    5049    void setWidth(float width) { m_width = width; }
    51     void setBaseline(float baseline) { m_baseline = baseline; }
    5250    void setTextShadow(const ShadowData* textShadow) { m_shadow = textShadow; }
    5351    void setShadowColorFilter(const FilterOperations* colorFilter) { m_shadowColorFilter = colorFilter; }
    … …  
    7371    float m_wavyOffset;
    7472    float m_width { 0 };
    75     float m_baseline { 0 };
    7673    FloatPoint m_boxOrigin;
    7774    bool m_isPrinting;
    … …  
    8077    const FilterOperations* m_shadowColorFilter { nullptr };
    8178    const InlineTextBox* m_inlineTextBox { nullptr };
    82     const FontCascade* m_font { nullptr };
     79    const FontCascade& m_font;
    8380
    8481    Styles m_styles;

  • trunk/Source/WebCore/style/InlineTextBoxStyle.cpp

    r237835 r237844  
    8484}
    8585   
    86 void getWavyStrokeParameters(float fontSize, float& controlPointDistance, float& step)
     86WavyStrokeParameters getWavyStrokeParameters(float fontSize)
    8787{
    88     // Distance between decoration's axis and Bezier curve's control points.
    89     // The height of the curve is based on this distance. Increases the curve's height
    90     // as fontSize increases to make the curve look better.
    91     controlPointDistance = 0.09375 * fontSize;
    92 
    93     // Increment used to form the diamond shape between start point (p1), control
    94     // points and end point (p2) along the axis of the decoration. The curve gets
    95     // wider as font size increases.
    96     step = fontSize / 4.5;
     88    WavyStrokeParameters result;
     89    // More information is in the WavyStrokeParameters definition.
     90    result.controlPointDistance = fontSize * 1.5 / 16;
     91    result.step = fontSize / 4.5;
     92    return result;
    9793}
    9894
    … …  
    111107
    112108    float strokeThickness = textDecorationStrokeThickness(lineStyle.computedFontPixelSize());
    113     float controlPointDistance = 0;
    114     float step;
     109    WavyStrokeParameters wavyStrokeParameters;
    115110    float wavyOffset = 0;
    116111       
    … …  
    120115   
    121116    if (decorationStyle == TextDecorationStyle::Wavy) {
    122         getWavyStrokeParameters(lineStyle.computedFontPixelSize(), controlPointDistance, step);
     117        wavyStrokeParameters = getWavyStrokeParameters(lineStyle.computedFontPixelSize());
    123118        wavyOffset = wavyOffsetFromDecoration();
    124119        overflowResult.left = strokeThickness;
    … …  
    132127        underlineOffset += computeUnderlineOffset(lineStyle.textUnderlinePosition(), lineStyle.fontMetrics(), inlineTextBox, strokeThickness);
    133128        if (decorationStyle == TextDecorationStyle::Wavy) {
    134             extendIntToFloat(overflowResult.bottom, underlineOffset + wavyOffset + controlPointDistance + strokeThickness - height);
    135             extendIntToFloat(overflowResult.top, -(underlineOffset + wavyOffset - controlPointDistance - strokeThickness));
     129            extendIntToFloat(overflowResult.bottom, underlineOffset + wavyOffset + wavyStrokeParameters.controlPointDistance + strokeThickness - height);
     130            extendIntToFloat(overflowResult.top, -(underlineOffset + wavyOffset - wavyStrokeParameters.controlPointDistance - strokeThickness));
    136131        } else {
    137132            extendIntToFloat(overflowResult.bottom, underlineOffset + strokeThickness - height);
    … …  
    141136    if (decoration & TextDecoration::Overline) {
    142137        if (decorationStyle == TextDecorationStyle::Wavy) {
    143             extendIntToFloat(overflowResult.bottom, -wavyOffset + controlPointDistance + strokeThickness - height);
    144             extendIntToFloat(overflowResult.top, wavyOffset + controlPointDistance + strokeThickness);
     138            extendIntToFloat(overflowResult.bottom, -wavyOffset + wavyStrokeParameters.controlPointDistance + strokeThickness - height);
     139            extendIntToFloat(overflowResult.top, wavyOffset + wavyStrokeParameters.controlPointDistance + strokeThickness);
    145140        } else {
    146141            extendIntToFloat(overflowResult.bottom, strokeThickness - height);
    … …  
    151146        float baseline = lineStyle.fontMetrics().floatAscent();
    152147        if (decorationStyle == TextDecorationStyle::Wavy) {
    153             extendIntToFloat(overflowResult.bottom, 2 * baseline / 3 + controlPointDistance + strokeThickness - height);
    154             extendIntToFloat(overflowResult.top, -(2 * baseline / 3 - controlPointDistance - strokeThickness));
     148            extendIntToFloat(overflowResult.bottom, 2 * baseline / 3 + wavyStrokeParameters.controlPointDistance + strokeThickness - height);
     149            extendIntToFloat(overflowResult.top, -(2 * baseline / 3 - wavyStrokeParameters.controlPointDistance - strokeThickness));
    155150        } else {
    156151            extendIntToFloat(overflowResult.bottom, 2 * baseline / 3 + strokeThickness - height);

  • trunk/Source/WebCore/style/InlineTextBoxStyle.h

    r237835 r237844  
    4545}
    4646
     47struct WavyStrokeParameters {
     48    // Distance between decoration's axis and Bezier curve's control points.
     49    // The height of the curve is based on this distance. Increases the curve's height
     50    // as fontSize increases to make the curve look better.
     51    float controlPointDistance { 0 };
     52
     53    // Increment used to form the diamond shape between start point (p1), control
     54    // points and end point (p2) along the axis of the decoration. The curve gets
     55    // wider as font size increases.
     56    float step { 0 };
     57};
     58WavyStrokeParameters getWavyStrokeParameters(float fontSize);
    4759GlyphOverflow visualOverflowForDecorations(const RenderStyle& lineStyle, const InlineTextBox*);
    48 void getWavyStrokeParameters(float fontSize, float& controlPointDistance, float& step);
    4960int computeUnderlineOffset(TextUnderlinePosition, const FontMetrics&, const InlineTextBox*, int textDecorationThickness);
    5061   
Note: See TracChangeset for help on using the changeset viewer.