Underline Thickness is not uniform

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 42 matching lines @@
 #include "wtf/text/StringBuilder.h"
 
 using namespace std;
 
 namespace WebCore {
 
 struct SameSizeAsInlineTextBox : public InlineBox {
     unsigned variables[1];
     unsigned short variables2[2];
     void* pointers[2];
+    float u;
 };
 
 COMPILE_ASSERT(sizeof(InlineTextBox) == sizeof(SameSizeAsInlineTextBox), InlineTextBox_should_stay_small);
 
 typedef WTF::HashMap<const InlineTextBox*, LayoutRect> InlineTextBoxOverflowMap;
 static InlineTextBoxOverflowMap* gTextBoxesWithOverflow;
 
 static const int misspellingLineThickness = 3;
 
 void InlineTextBox::destroy()
@@ skipping 670 matching lines @@
             int startOffset = combinedText ? 0 : sPos;
             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
+    // lets only store decorations style and underline thickness, painting of decoration style will be done later
     TextDecoration textDecorations = styleToUse->textDecorationsInEffect();
     if (textDecorations != TextDecorationNone && paintInfo.phase != PaintPhaseSelection) {
-        updateGraphicsContext(context, textFillColor, textStrokeColor, textStrokeWidth);
-        if (combinedText)
-            context->concatCTM(rotation(boxRect, Clockwise));
-        paintDecoration(context, boxOrigin, textDecorations, textShadow);
-        if (combinedText)
-            context->concatCTM(rotation(boxRect, Counterclockwise));
-    }
+        float textDecorationThickness = styleToUse->fontMetrics().underlineThickness();

[leviw_travelin_and_unemployed, 2014/03/21 20:43:08]

Don't copy and paste this block of code. If you need it in both places create a
function.

+        int fontHeightInt = (int)(styleToUse->fontMetrics().floatHeight() + 0.5);
+        if ((textDecorationThickness == 0.f) || (textDecorationThickness >= (fontHeightInt >> 1)))
+            textDecorationThickness = std::max(1.f, styleToUse->computedFontSize() / 10.f);
 
-    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();
-
-            for (size_t index = 0; index < numUnderlines; ++index) {
-                const CompositionUnderline& underline = underlines[index];
-
-                if (underline.endOffset <= start())
-                    // underline is completely before this run.  This might be an underline that sits
-                    // before the first run we draw, or underlines that were within runs we skipped
-                    // due to truncation.
-                    continue;
-
-                if (underline.startOffset <= end()) {
-                    // underline intersects this run.  Paint it.
-                    paintCompositionUnderline(context, boxOrigin, underline);
-                    if (underline.endOffset > end() + 1)
-                        // underline also runs into the next run. Bail now, no more marker advancement.
-                        break;
-                } else
-                    // underline is completely after this run, bail.  A later run will paint it.
-                    break;
-            }
-        }
+        setDecorationThickness(textDecorationThickness);
     }
 
     if (shouldRotate)
         context->concatCTM(rotation(boxRect, Counterclockwise));
 }
 
 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos)
 {
     int startPos, endPos;
     if (renderer().selectionState() == RenderObject::SelectionInside) {
@@ skipping 285 matching lines @@
         context->setShouldAntialias(antialiasDecoration);
         // Fall through
     default:
         context->drawLineForText(start, width, isPrinting);
 
         if (decoration.style == TextDecorationStyleDouble)
             context->drawLineForText(start + FloatPoint(0, doubleOffset), width, isPrinting);
     }
 }
 
-void InlineTextBox::paintDecoration(GraphicsContext* context, const FloatPoint& boxOrigin, TextDecoration deco, const ShadowList* shadowList)
+void InlineTextBox::paintDecoration(GraphicsContext* context, const FloatPoint& boxOrigin, TextDecoration deco, const ShadowList* shadowList, float decorationThickness)
 {
     GraphicsContextStateSaver stateSaver(*context);
 
     if (m_truncation == cFullTruncation)
         return;
 
     FloatPoint localOrigin = boxOrigin;
 
     float width = m_logicalWidth;
     if (m_truncation != cNoTruncation) {
@@ skipping 15 matching lines @@
     bool linesAreOpaque = !isPrinting && (!(deco & TextDecorationUnderline) || underline.color.alpha() == 255) && (!(deco & TextDecorationOverline) || overline.color.alpha() == 255) && (!(deco & TextDecorationLineThrough) || linethrough.color.alpha() == 255);
 
     RenderStyle* styleToUse = renderer().style(isFirstLineStyle());
     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);
+    float textDecorationThickness = 0;
+    if (!decorationThickness) {

[leviw_travelin_and_unemployed, 2014/03/21 20:43:08]

I don't fully understand the case when we have to recalculate this (as in, it's
not passed in). Help me understand.

+        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);
+    } else {
+        textDecorationThickness = decorationThickness;
+    }
 
     context->setStrokeThickness(textDecorationThickness);
 
     bool antialiasDecoration = shouldSetDecorationAntialias(overline.style, underline.style, linethrough.style)
         && RenderBoxModelObject::shouldAntialiasLines(context);
 
     float extraOffset = 0;
     if (!linesAreOpaque && shadowCount > 1) {
         FloatRect clipRect(localOrigin, FloatSize(width, baseline + 2));
         for (size_t i = shadowCount; i--; ) {
@@ skipping 35 matching lines @@
         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);
         }
     }
 }
 
+void InlineTextBox::paintDecorationStyle(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom, float decorationThickness)

[leviw_travelin_and_unemployed, 2014/03/21 20:43:08]

Whoa... This is a *ton* of code duplication, no?

+{
+    if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(&renderer()) || renderer().style()->visibility() != VISIBLE
+        || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
+        return;
+
+    ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
+
+    LayoutUnit logicalLeftSide = logicalLeftVisualOverflow();
+    LayoutUnit logicalRightSide = logicalRightVisualOverflow();
+    LayoutUnit logicalStart = logicalLeftSide + (isHorizontal() ? paintOffset.x() : paintOffset.y());
+    LayoutUnit logicalExtent = logicalRightSide - logicalLeftSide;
+
+    LayoutUnit paintEnd = isHorizontal() ? paintInfo.rect.maxX() : paintInfo.rect.maxY();
+    LayoutUnit paintStart = isHorizontal() ? paintInfo.rect.x() : paintInfo.rect.y();
+
+    LayoutPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
+    bool isPrinting = textRenderer().document().printing();
+
+    if (logicalStart >= paintEnd || logicalStart + logicalExtent <= paintStart)
+        return;
+
+    // Determine whether or not we have composition underlines to draw.
+    bool containsComposition = renderer().node() && renderer().frame()->inputMethodController().compositionNode() == renderer().node();
+    bool useCustomUnderlines = containsComposition && renderer().frame()->inputMethodController().compositionUsesCustomUnderlines();
+
+    // Determine whether or not we're selected.
+    bool haveSelection = !isPrinting && paintInfo.phase != PaintPhaseTextClip && selectionState() != RenderObject::SelectionNone;
+    if (!haveSelection && paintInfo.phase == PaintPhaseSelection) {
+        // When only painting the selection, don't bother to paint if there is none.
+        return;
+    }
+
+    GraphicsContext* context = paintInfo.context;
+    RenderObject& rendererToUse = renderer();
+    RenderStyle* styleToUse = rendererToUse.style(isFirstLineStyle());
+
+    // Set our font.
+    const Font& font = styleToUse->font();
+    FloatPoint boxOrigin = locationIncludingFlipping();
+    // FIXME: Shouldn't these offsets be rounded?
+    boxOrigin.move(adjustedPaintOffset.x().toFloat(), adjustedPaintOffset.y().toFloat());
+    FloatRect boxRect(boxOrigin, LayoutSize(logicalWidth(), logicalHeight()));
+
+    TextDecoration deco = styleToUse->textDecorationsInEffect();
+    const ShadowList* textShadow = (context->printing() || paintInfo.forceBlackText()) ? 0 : styleToUse->textShadow();
+
+    // Determine the text colors and selection colors.
+    Color textFillColor;
+    Color textStrokeColor;
+    Color emphasisMarkColor;
+    float textStrokeWidth = styleToUse->textStrokeWidth();
+
+    if (paintInfo.forceBlackText()) {
+        textFillColor = Color::black;
+        textStrokeColor = Color::black;
+        emphasisMarkColor = Color::black;
+    } else {
+        textFillColor = rendererToUse.resolveColor(styleToUse, CSSPropertyWebkitTextFillColor);
+
+        bool forceBackgroundToWhite = false;
+        if (isPrinting) {
+            if (styleToUse->printColorAdjust() == PrintColorAdjustEconomy)
+                forceBackgroundToWhite = true;
+            if (textRenderer().document().settings() && textRenderer().document().settings()->shouldPrintBackgrounds())
+                forceBackgroundToWhite = false;
+        }
+
+        // Make the text fill color legible against a white background
+        if (forceBackgroundToWhite)
+            textFillColor = correctedTextColor(textFillColor, Color::white);
+
+        textStrokeColor = rendererToUse.resolveColor(styleToUse, CSSPropertyWebkitTextStrokeColor);
+
+        // Make the text stroke color legible against a white background
+        if (forceBackgroundToWhite)
+            textStrokeColor = correctedTextColor(textStrokeColor, Color::white);
+
+        emphasisMarkColor = rendererToUse.resolveColor(styleToUse, CSSPropertyWebkitTextEmphasisColor);
+
+        // Make the text stroke color legible against a white background
+        if (forceBackgroundToWhite)
+            emphasisMarkColor = correctedTextColor(emphasisMarkColor, Color::white);
+    }
+    updateGraphicsContext(context, textFillColor, textStrokeColor, textStrokeWidth);
+    paintDecoration(context, boxOrigin, deco, textShadow, decorationThickness);
+
+    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();
+
+            for (size_t index = 0; index < numUnderlines; ++index) {
+                const CompositionUnderline& underline = underlines[index];
+
+                if (underline.endOffset <= start()) {
+                    // underline is completely before this run. This might be an underline that sits
+                    // before the first run we draw, or underlines that were within runs we skipped
+                    // due to truncation.
+                    continue;
+                }
+
+                if (underline.startOffset <= end()) {
+                    // underline intersects this run. Paint it.
+                    paintCompositionUnderline(context, boxOrigin, underline);
+                    if (underline.endOffset > end() + 1) {
+                        // underline also runs into the next run. Bail now, no more marker advancement.
+                        break;
+                    }
+                } else {
+                    // underline is completely after this run, bail. A later run will paint it.
+                    break;
+                }
+            }
+        }
+    }
+}
+
+void InlineTextBox::getPaintDecorationSyle(PaintInfo& paintInfo, const LayoutPoint& paintOffset, float * decorationThickness)
+{
+    *decorationThickness = 0;
+    if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(&renderer()) || renderer().style()->visibility() != VISIBLE
+        || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
+        return;
+
+    *decorationThickness = getDecorationThickness();
+}
+
 static GraphicsContext::DocumentMarkerLineStyle lineStyleForMarkerType(DocumentMarker::MarkerType markerType)
 {
     switch (markerType) {
     case DocumentMarker::Spelling:
         return GraphicsContext::DocumentMarkerSpellingLineStyle;
     case DocumentMarker::Grammar:
         return GraphicsContext::DocumentMarkerGrammarLineStyle;
     default:
         ASSERT_NOT_REACHED();
         return GraphicsContext::DocumentMarkerSpellingLineStyle;
@@ skipping 364 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