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;
+    TextDecorationStyle t;
 };
 
 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, styleToUse->textDecorationStyle(), textShadow);
-        if (combinedText)
-            context->concatCTM(rotation(boxRect, Counterclockwise));
-    }
+        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);
 
-    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;
-            }
-        }
+        setUnderlineThickness(textDecorationThickness);
+        setTextDecoration(styleToUse->textDecorationStyle());
     }
 
     if (shouldRotate)
         context->concatCTM(rotation(boxRect, Counterclockwise));
 }
 
 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos)
 {
     int startPos, endPos;
     if (renderer().selectionState() == RenderObject::SelectionInside) {
@@ skipping 103 matching lines @@
         break;
     case TextDecorationStyleDotted:
         strokeStyle = DottedStroke;
         break;
     case TextDecorationStyleDashed:
         strokeStyle = DashedStroke;
         break;
     case TextDecorationStyleWavy:
         strokeStyle = WavyStroke;
         break;
+    case TextDecorationStyleNone:
+        break;
     }
 
     return strokeStyle;
 }
 
 static int computeUnderlineOffset(const TextUnderlinePosition underlinePosition, const FontMetrics& fontMetrics, const InlineTextBox* inlineTextBox, const float textDecorationThickness)
 {
     // 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));
@@ skipping 130 matching lines @@
             controlPoint2.setX(x + step);
             x += 2 * step;
             path.addBezierCurveTo(controlPoint1, controlPoint2, FloatPoint(x, yAxis));
         }
     }
 
     context->setShouldAntialias(true);
     context->strokePath(path);
 }
 
-void InlineTextBox::paintDecoration(GraphicsContext* context, const FloatPoint& boxOrigin, TextDecoration deco, TextDecorationStyle decorationStyle, const ShadowList* shadowList)
+void InlineTextBox::paintDecoration(GraphicsContext* context, const FloatPoint& boxOrigin, TextDecoration deco, TextDecorationStyle decorationStyle, const ShadowList* shadowList, float underlineThickness)
 {
     GraphicsContextStateSaver stateSaver(*context);
 
     if (m_truncation == cFullTruncation)
         return;
 
     FloatPoint localOrigin = boxOrigin;
 
     float width = m_logicalWidth;
     if (m_truncation != cNoTruncation) {
@@ skipping 14 matching lines @@
     bool linesAreOpaque = !isPrinting && (!(deco & TextDecorationUnderline) || underline.alpha() == 255) && (!(deco & TextDecorationOverline) || overline.alpha() == 255) && (!(deco & TextDecorationLineThrough) || linethrough.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 (!underlineThickness) {
+        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 = underlineThickness;
+    }
 
     context->setStrokeThickness(textDecorationThickness);
 
     switch (decorationStyle) {
     case TextDecorationStyleDotted:
     case TextDecorationStyleDashed:
         context->setShouldAntialias(RenderBoxModelObject::shouldAntialiasLines(context));
         break;
     case TextDecorationStyleSolid:
     case TextDecorationStyleDouble:
     case TextDecorationStyleWavy:
+    case TextDecorationStyleNone:
         break;
     }
 
     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());
@@ skipping 68 matching lines @@
             }
             default:
                 context->drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + 2 * baseline / 3), width, isPrinting);
                 if (decorationStyle == TextDecorationStyleDouble)
                     context->drawLineForText(FloatPoint(localOrigin.x(), localOrigin.y() + doubleOffset + 2 * baseline / 3), width, isPrinting);
             }
         }
     }
 }
 
+void InlineTextBox::paintDecorationStyle(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom, float underlineThickness)
+{
+    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();
+    TextDecorationStyle decorationStyle = styleToUse->textDecorationStyle();
+    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, decorationStyle, textShadow, underlineThickness);
+
+    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 * underlineThickness, TextDecorationStyle * style)
+{
+    *underlineThickness = 0;
+    if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(&renderer()) || renderer().style()->visibility() != VISIBLE
+        || m_truncation == cFullTruncation || paintInfo.phase == PaintPhaseOutline || !m_len)
+        return;
+
+    *underlineThickness = getUnderlineThickness();
+    *style = getTextDecorations();
+}
+
 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