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 384 matching lines @@
 
     if (!containingBlock->parent()->isRubyRun())
         return true; // Cannot get the ruby text.
 
     RenderRubyText* rubyText = toRenderRubyRun(containingBlock->parent())->rubyText();
 
     // The emphasis marks over are suppressed only if there is a ruby text box and it not empty.
     return !rubyText || !rubyText->firstLineBox();
 }
 
-void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
+bool InlineTextBox::isLogicalStartEndCorrect(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     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);
+        return false;
 
     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);
-
     if (logicalStart >= paintEnd || logicalStart + logicalExtent <= paintStart)
-        return;
+        return false;
 
     bool isPrinting = textRenderer().document().printing();
 
     // Determine whether or not we're selected.
     bool haveSelection = !isPrinting && paintInfo.phase != PaintPhaseTextClip && selectionState() != RenderObject::SelectionNone;
-    if (!haveSelection && paintInfo.phase == PaintPhaseSelection)
+    if (!haveSelection && paintInfo.phase == PaintPhaseSelection) {
         // When only painting the selection, don't bother to paint if there is none.
+        return false;
+    }
+
+    return true;
+}
+void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
+{
+    ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
+
+    if (!isLogicalStartEndCorrect(paintInfo, paintOffset))
         return;
 
+    LayoutPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
+    bool isPrinting = textRenderer().document().printing();
+    bool haveSelection = !isPrinting && paintInfo.phase != PaintPhaseTextClip && selectionState() != RenderObject::SelectionNone;
+
     if (m_truncation != cNoTruncation) {
         if (renderer().containingBlock()->style()->isLeftToRightDirection() != isLeftToRightDirection()) {
             // Make the visible fragment of text hug the edge closest to the rest of the run by moving the origin
             // at which we start drawing text.
             // e.g. In the case of LTR text truncated in an RTL Context, the correct behavior is:
             // |Hello|CBA| -> |...He|CBA|
             // In order to draw the fragment "He" aligned to the right edge of it's box, we need to start drawing
             // farther to the right.
             // NOTE: WebKit's behavior differs from that of IE which appears to just overlay the ellipsis on top of the
             // truncated string i.e.  |Hello|CBA| -> |...lo|CBA|
@@ skipping 237 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();
+        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) {
+        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)
+{
+    ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
+
+    if (!isLogicalStartEndCorrect(paintInfo, paintOffset))
+        return;
+
+    LayoutPoint adjustedPaintOffset = roundedIntPoint(paintOffset);
+    GraphicsContext* context = paintInfo.context;
+    RenderObject& rendererToUse = renderer();
+    RenderStyle* styleToUse = rendererToUse.style(isFirstLineStyle());
+
+    FloatPoint boxOrigin = locationIncludingFlipping();
+    boxOrigin.move(adjustedPaintOffset.x().toFloat(), adjustedPaintOffset.y().toFloat());
+
+    TextDecoration deco = styleToUse->textDecorationsInEffect();
+    const ShadowList* textShadow = (context->printing() || paintInfo.forceBlackText()) ? 0 : styleToUse->textShadow();
+
+    paintDecoration(context, boxOrigin, deco, textShadow, decorationThickness);
+    if (paintInfo.phase == PaintPhaseForeground) {
+        const Font& font = styleToUse->font();
+        bool containsComposition = renderer().node() && renderer().frame()->inputMethodController().compositionNode() == renderer().node();
+        bool useCustomUnderlines = containsComposition && renderer().frame()->inputMethodController().compositionUsesCustomUnderlines();
+
+        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