Proper support for multiple text decorations.

Source/core/rendering/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * 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.
  *
@@ skipping 24 matching lines @@
 #include "core/rendering/AbstractInlineTextBox.h"
 #include "core/rendering/EllipsisBox.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/PaintInfo.h"
 #include "core/rendering/RenderBR.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderCombineText.h"
 #include "core/rendering/RenderRubyRun.h"
 #include "core/rendering/RenderRubyText.h"
 #include "core/rendering/RenderTheme.h"
+#include "core/rendering/style/AppliedTextDecorationList.h"
 #include "core/rendering/style/ShadowList.h"
 #include "core/rendering/svg/SVGTextRunRenderingContext.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/WidthIterator.h"
 #include "platform/graphics/DrawLooperBuilder.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 
@@ skipping 689 matching lines @@
             int endOffset = combinedText ? objectReplacementCharacterTextRun.length() : ePos;
             int paintRunLength = combinedText ? endOffset : length;
             paintTextWithShadows(context, rendererToUse, combinedText ? combinedText->originalFont() : font, emphasisMarkTextRun, emphasisMark, emphasisMarkOffset, startOffset, endOffset, paintRunLength, emphasisMarkTextOrigin, boxRect, selectionShadow, selectionStrokeWidth > 0, isHorizontal());
 
             if (combinedText)
                 context->concatCTM(rotation(boxRect, Counterclockwise));
         }
     }
 
     // Paint decorations
-    TextDecoration textDecorations = styleToUse->textDecorationsInEffect();
-    if (textDecorations != TextDecorationNone && paintInfo.phase != PaintPhaseSelection) {
+    if (styleToUse->hasAppliedTextDecorations() && paintInfo.phase != PaintPhaseSelection) {
         updateGraphicsContext(context, textFillColor, textStrokeColor, textStrokeWidth);
         if (combinedText)
             context->concatCTM(rotation(boxRect, Clockwise));
-        paintDecoration(context, boxOrigin, textDecorations, textShadow);
+        paintDecoration(context, boxOrigin, styleToUse, textShadow);
         if (combinedText)
             context->concatCTM(rotation(boxRect, Counterclockwise));
     }
 
     if (paintInfo.phase == PaintPhaseForeground) {
         paintDocumentMarkers(context, boxOrigin, styleToUse, font, false);
 
         if (useCustomUnderlines) {
             const Vector<CompositionUnderline>& underlines = renderer().frame()->inputMethodController().customCompositionUnderlines();
             size_t numUnderlines = underlines.size();
@@ skipping 139 matching lines @@
         strokeStyle = DashedStroke;
         break;
     case TextDecorationStyleWavy:
         strokeStyle = WavyStroke;
         break;
     }
 
     return strokeStyle;
 }
 
-static int computeUnderlineOffset(const TextUnderlinePosition underlinePosition, const FontMetrics& fontMetrics, const InlineTextBox* inlineTextBox, const float textDecorationThickness)
+int InlineTextBox::computeUnderlineOffset(RenderStyle* style, const float textDecorationThickness)
 {
+    const TextUnderlinePosition underlinePosition = style->textUnderlinePosition();
+    const FontMetrics& fontMetrics = style->fontMetrics();
+
     // Compute the gap between the font and the underline. Use at least one
     // pixel gap, if underline is thick then use a bigger gap.
     const int gap = std::max<int>(1, ceilf(textDecorationThickness / 2.f));
 
     // FIXME: We support only horizontal text for now.
     switch (underlinePosition) {
     case TextUnderlinePositionAuto:
         return fontMetrics.ascent() + gap; // Position underline near the alphabetic baseline.
     case TextUnderlinePositionUnder: {
         // Position underline relative to the under edge of the lowest element's content box.
-        const float offset = inlineTextBox->root().maxLogicalTop() - inlineTextBox->logicalTop();
+        const float offset = root().maxLogicalTop() - logicalTop();
         if (offset > 0)
-            return inlineTextBox->logicalHeight() + gap + offset;
-        return inlineTextBox->logicalHeight() + gap;
+            return logicalHeight() + gap + offset;
+        return logicalHeight() + gap;
     }
     }
 
     ASSERT_NOT_REACHED();
     return fontMetrics.ascent() + gap;
 }
 
 static void adjustStepToDecorationLength(float& step, float& controlPointDistance, float length)
 {
     ASSERT(step > 0);
@@ skipping 114 matching lines @@
 
     context->setShouldAntialias(true);
     context->strokePath(path);
 }
 
 static bool shouldSetDecorationAntialias(TextDecorationStyle decorationStyle)
 {
     return decorationStyle == TextDecorationStyleDotted || decorationStyle == TextDecorationStyleDashed;
 }
 
-static bool shouldSetDecorationAntialias(TextDecorationStyle underline, TextDecorationStyle overline, TextDecorationStyle linethrough)
+static void getDecorationMetaData(const AppliedTextDecorationList* decorations, bool& linesAreOpaque, bool& setDecorationAntialias)

[esprehn, 2014/03/31 17:41:24]

I might use a struct instead of all these out params.

 {
-    return shouldSetDecorationAntialias(underline) || shouldSetDecorationAntialias(overline) || shouldSetDecorationAntialias(linethrough);
+    for (size_t i = 0; i < decorations->size(); ++i) {

[esprehn, 2014/03/31 17:41:24]

Pass decorations by reference.

+        const AppliedTextDecoration& d = decorations->at(i);
+        linesAreOpaque &= (d.color().alpha() == 255);
+        setDecorationAntialias |= shouldSetDecorationAntialias(d.style());
+    }
 }
 
-static void paintAppliedDecoration(GraphicsContext* context, FloatPoint start, float width, float doubleOffset, int wavyOffsetFactor,
-    RenderObject::AppliedTextDecoration decoration, float thickness, bool antialiasDecoration, bool isPrinting)
+struct PaintAppliedDecorationData {
+    RenderStyle* style;
+    FloatPoint start;
+    float width;
+    float doubleOffset;
+    float thickness;
+    bool antialias;
+    bool isPrinting;
+    int baseline;

[esprehn, 2014/03/31 17:41:24]

Do we need a constructor that zero inits this thing?

+};
+
+static void paintAppliedDecorationStyle(GraphicsContext* context, const AppliedTextDecoration& decoration, const PaintAppliedDecorationData& d, int wavyOffsetFactor)

[esprehn, 2014/03/31 17:41:24]

Don't use single letter variable names.

 {
-    context->setStrokeStyle(textDecorationStyleToStrokeStyle(decoration.style));
-    context->setStrokeColor(decoration.color);
+    context->setStrokeStyle(textDecorationStyleToStrokeStyle(decoration.style()));
+    context->setStrokeColor(decoration.color());
 
-    switch (decoration.style) {
+    switch (decoration.style()) {
     case TextDecorationStyleWavy:
-        strokeWavyTextDecoration(context, start + FloatPoint(0, doubleOffset * wavyOffsetFactor), start + FloatPoint(width, doubleOffset * wavyOffsetFactor), thickness);
+        strokeWavyTextDecoration(context, d.start + FloatPoint(0, d.doubleOffset * wavyOffsetFactor), d.start + FloatPoint(d.width, d.doubleOffset * wavyOffsetFactor), d.thickness);
         break;
     case TextDecorationStyleDotted:
     case TextDecorationStyleDashed:
-        context->setShouldAntialias(antialiasDecoration);
+        context->setShouldAntialias(d.antialias);
         // Fall through
     default:
-        context->drawLineForText(start, width, isPrinting);
+        context->drawLineForText(d.start, d.width, d.isPrinting);
 
-        if (decoration.style == TextDecorationStyleDouble)
-            context->drawLineForText(start + FloatPoint(0, doubleOffset), width, isPrinting);
+        if (decoration.style() == TextDecorationStyleDouble)
+            context->drawLineForText(d.start + FloatPoint(0, d.doubleOffset), d.width, d.isPrinting);
     }
 }
 
-void InlineTextBox::paintDecoration(GraphicsContext* context, const FloatPoint& boxOrigin, TextDecoration deco, const ShadowList* shadowList)
+void InlineTextBox::paintAppliedDecoration(GraphicsContext* context, const AppliedTextDecoration& decoration, const PaintAppliedDecorationData& d)
+{
+    PaintAppliedDecorationData data = d;
+    int wavyOffsetFactor = 1;
+
+    switch (decoration.line()) {
+    case TextDecorationUnderline:
+        data.start += FloatPoint(0, computeUnderlineOffset(d.style, d.thickness));
+        break;
+    case TextDecorationOverline:
+        data.doubleOffset *= -1;
+        break;
+    case TextDecorationLineThrough:
+        data.start += FloatPoint(0, (2 * d.baseline / 3));
+        wavyOffsetFactor = 0;
+        break;
+    default:
+        return;
+    }
+
+    paintAppliedDecorationStyle(context, decoration, data, wavyOffsetFactor);
+}
+
+void InlineTextBox::paintDecoration(GraphicsContext* context, const FloatPoint& boxOrigin, RenderStyle* styleToUse, const ShadowList* shadowList)
 {
     GraphicsContextStateSaver stateSaver(*context);
 
     if (m_truncation == cFullTruncation)
         return;
 
     FloatPoint localOrigin = boxOrigin;
 
     float width = m_logicalWidth;
     if (m_truncation != cNoTruncation) {
         width = toRenderText(renderer()).width(m_start, m_truncation, textPos(), isLeftToRightDirection() ? LTR : RTL, isFirstLineStyle());
         if (!isLeftToRightDirection())
             localOrigin.move(m_logicalWidth - width, 0);
     }
 
-    // Get the text decoration colors.
-    RenderObject::AppliedTextDecoration underline, overline, linethrough;
+    const AppliedTextDecorationList* decorations = styleToUse->appliedTextDecorations();
 
-    renderer().getTextDecorations(deco, underline, overline, linethrough, true);
-    if (isFirstLineStyle())
-        renderer().getTextDecorations(deco, underline, overline, linethrough, true, true);
+    // If appliedTextUnderline() is true, we must paint an extra underline
+    // before painting the other decorations.
+    AppliedTextDecoration underline;
+    if (styleToUse->appliedTextUnderline()) {
+        Color color = renderer().getUnderlineColor(true, isFirstLineStyle());

[esprehn, 2014/03/31 17:41:24]

this boolean argument is confusing, can we use an enum or something?

+        underline = AppliedTextDecoration(TextDecorationUnderline, TextDecorationStyleSolid, color);
+    }
 
     // Use a special function for underlines to get the positioning exactly right.
     bool isPrinting = textRenderer().document().printing();
 
-    bool linesAreOpaque = !isPrinting && (!(deco & TextDecorationUnderline) || underline.color.alpha() == 255) && (!(deco & TextDecorationOverline) || overline.color.alpha() == 255) && (!(deco & TextDecorationLineThrough) || linethrough.color.alpha() == 255);
+    bool linesAreOpaque = !isPrinting;
+    bool setDecorationAntialias = false;
 
-    RenderStyle* styleToUse = renderer().style(isFirstLineStyle());
+    if (decorations)
+        getDecorationMetaData(decorations, linesAreOpaque, setDecorationAntialias);
+
     int baseline = styleToUse->fontMetrics().ascent();
 
     size_t shadowCount = shadowList ? shadowList->shadows().size() : 0;
     // Set the thick of the line to be 10% (or something else ?)of the computed font size and not less than 1px.
     // Using computedFontSize should take care of zoom as well.
 
     // Update Underline thickness, in case we have Faulty Font Metrics calculating underline thickness by old method.
     float textDecorationThickness = styleToUse->fontMetrics().underlineThickness();
     int fontHeightInt  = (int)(styleToUse->fontMetrics().floatHeight() + 0.5);
     if ((textDecorationThickness == 0.f) || (textDecorationThickness >= (fontHeightInt >> 1)))
         textDecorationThickness = std::max(1.f, styleToUse->computedFontSize() / 10.f);
 
     context->setStrokeThickness(textDecorationThickness);
 
-    bool antialiasDecoration = shouldSetDecorationAntialias(overline.style, underline.style, linethrough.style)
-        && RenderBoxModelObject::shouldAntialiasLines(context);
+    bool antialiasDecoration = setDecorationAntialias && RenderBoxModelObject::shouldAntialiasLines(context);
 
     float extraOffset = 0;
     if (!linesAreOpaque && shadowCount > 1) {
         FloatRect clipRect(localOrigin, FloatSize(width, baseline + 2));
         for (size_t i = shadowCount; i--; ) {
             const ShadowData& s = shadowList->shadows()[i];
             FloatRect shadowRect(localOrigin, FloatSize(width, baseline + 2));
             shadowRect.inflate(s.blur());
             float shadowX = isHorizontal() ? s.x() : s.y();
             float shadowY = isHorizontal() ? s.y() : -s.x();
@@ skipping 13 matching lines @@
                 // The last set of lines paints normally inside the clip.
                 localOrigin.move(0, -extraOffset);
                 extraOffset = 0;
             }
             const ShadowData& shadow = shadowList->shadows()[i];
             float shadowX = isHorizontal() ? shadow.x() : shadow.y();
             float shadowY = isHorizontal() ? shadow.y() : -shadow.x();
             context->setShadow(FloatSize(shadowX, shadowY - extraOffset), shadow.blur(), shadow.color());
         }
 
+        PaintAppliedDecorationData data;
+        data.style = styleToUse;
+        data.start = localOrigin;
+        data.width = width;
         // Offset between lines - always non-zero, so lines never cross each other.
-        float doubleOffset = textDecorationThickness + 1.f;
+        data.doubleOffset = textDecorationThickness + 1.f;
+        data.thickness = textDecorationThickness;
+        data.antialias = antialiasDecoration;
+        data.isPrinting = isPrinting;
+        data.baseline = baseline;
 
-        if (deco & TextDecorationUnderline) {
-            const int underlineOffset = computeUnderlineOffset(styleToUse->textUnderlinePosition(), styleToUse->fontMetrics(), this, textDecorationThickness);
-            paintAppliedDecoration(context, localOrigin + FloatPoint(0, underlineOffset), width, doubleOffset, 1, underline, textDecorationThickness, antialiasDecoration, isPrinting);
-        }
-        if (deco & TextDecorationOverline) {
-            paintAppliedDecoration(context, localOrigin, width, -doubleOffset, 1, overline, textDecorationThickness, antialiasDecoration, isPrinting);
-        }
-        if (deco & TextDecorationLineThrough) {
-            const float lineThroughOffset = 2 * baseline / 3;
-            paintAppliedDecoration(context, localOrigin + FloatPoint(0, lineThroughOffset), width, doubleOffset, 0, linethrough, textDecorationThickness, antialiasDecoration, isPrinting);
-        }
+        if (styleToUse->appliedTextUnderline())
+            paintAppliedDecoration(context, underline, data);
+
+        if (decorations)
+            for (size_t i = 0; i < decorations->size(); ++i)
+                paintAppliedDecoration(context, decorations->at(i), data);
     }
 }
 
 static GraphicsContext::DocumentMarkerLineStyle lineStyleForMarkerType(DocumentMarker::MarkerType markerType)
 {
     switch (markerType) {
     case DocumentMarker::Spelling:
         return GraphicsContext::DocumentMarkerSpellingLineStyle;
     case DocumentMarker::Grammar:
         return GraphicsContext::DocumentMarkerGrammarLineStyle;
@@ skipping 367 matching lines @@
     printedCharacters = fprintf(stderr, "\t%s %p", obj.renderName(), &obj);
     const int rendererCharacterOffset = 24;
     for (; printedCharacters < rendererCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
 }
 
 #endif
 
 } // namespace WebCore