Changeset 121102 in webkit

Timestamp:

Jun 23, 2012 2:23:12 PM (12 years ago)

Author:

mitz@apple.com

Message:

RenderText’s minimum preferred width is incorrect automatic hyphenation is used
​https://bugs.webkit.org/show_bug.cgi?id=89814

Reviewed by Sam Weinig.

Source/WebCore:

Test: fast/text/hyphen-min-preferred-width.html

• rendering/RenderText.cpp:

(WebCore::maxWordFragmentWidth): Added this helper function. It returns the width of the
widest hyphenated fragment of the word (except for the suffix after the last hyphen) and
the offset of the last hyphenation opportunity.
(WebCore::RenderText::computePreferredLogicalWidths): Changed this function to consider the
widths of hyphenated word fragments rather than entire words when computing the minimum
width. Because hyphenating and measuring all fragments is expensive, hyphenation is only
attempted if the unhyphenated word is wider than the current minimum width.

LayoutTests:

• fast/text/hyphen-min-preferred-width-expected.html: Added.
• fast/text/hyphen-min-preferred-width.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/text/hyphen-min-preferred-width-expected.html (added)
• LayoutTests/fast/text/hyphen-min-preferred-width.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/rendering/RenderText.cpp (modified) (5 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2012-06-23  Dan Bernstein  <mitz@apple.com>
+
+        RenderText’s minimum preferred width is incorrect automatic hyphenation is used
+        https://bugs.webkit.org/show_bug.cgi?id=89814
+
+        Reviewed by Sam Weinig.
+
+        * fast/text/hyphen-min-preferred-width-expected.html: Added.
+        * fast/text/hyphen-min-preferred-width.html: Added.
+
 2012-06-23  Kenneth Russell  <kbr@google.com>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-06-23  Dan Bernstein  <mitz@apple.com>
+
+        RenderText’s minimum preferred width is incorrect automatic hyphenation is used
+        https://bugs.webkit.org/show_bug.cgi?id=89814
+
+        Reviewed by Sam Weinig.
+
+        Test: fast/text/hyphen-min-preferred-width.html
+
+        * rendering/RenderText.cpp:
+        (WebCore::maxWordFragmentWidth): Added this helper function. It returns the width of the
+        widest hyphenated fragment of the word (except for the suffix after the last hyphen) and
+        the offset of the last hyphenation opportunity.
+        (WebCore::RenderText::computePreferredLogicalWidths): Changed this function to consider the
+        widths of hyphenated word fragments rather than entire words when computing the minimum
+        width. Because hyphenating and measuring all fragments is expensive, hyphenation is only
+        attempted if the unhyphenated word is wider than the current minimum width.
+
 2012-06-23  Sheriff Bot  <webkit.review.bot@gmail.com>
 

trunk/Source/WebCore/rendering/RenderText.cpp

@@ -31 +31 @@
 #include "FontTranscoder.h"
 #include "FrameView.h"
+#include "Hyphenation.h"
 #include "InlineTextBox.h"
 #include "Range.h"
@@ -889 +890 @@
 }
 
+static float maxWordFragmentWidth(RenderText* renderer, RenderStyle* style, const Font& font, const UChar* word, int wordLength, int minimumPrefixLength, int minimumSuffixLength, int& suffixStart)
+{
+    suffixStart = 0;
+    if (wordLength <= minimumSuffixLength)
+        return 0;
+
+    Vector<int, 8> hyphenLocations;
+    int hyphenLocation = wordLength - minimumSuffixLength;
+    while ((hyphenLocation = lastHyphenLocation(word, wordLength, hyphenLocation, style->locale())) >= minimumPrefixLength)
+        hyphenLocations.append(hyphenLocation);
+
+    if (hyphenLocations.isEmpty())
+        return 0;
+
+    hyphenLocations.reverse();
+
+    float minimumFragmentWidthToConsider = font.pixelSize() * 5 / 4 + hyphenWidth(renderer, font);
+    float maxFragmentWidth = 0;
+    for (size_t k = 0; k < hyphenLocations.size(); ++k) {
+        int fragmentLength = hyphenLocations[k] - suffixStart;
+        StringBuilder fragmentWithHyphen;
+        fragmentWithHyphen.append(word + suffixStart, fragmentLength);
+        fragmentWithHyphen.append(style->hyphenString());
+
+        TextRun run = RenderBlock::constructTextRun(renderer, font, fragmentWithHyphen.characters(), fragmentWithHyphen.length(), style);
+        run.setCharactersLength(fragmentWithHyphen.length());
+        run.setCharacterScanForCodePath(!renderer->canUseSimpleFontCodePath());
+        float fragmentWidth = font.width(run);
+
+        // Narrow prefixes are ignored. See tryHyphenating in RenderBlockLineLayout.cpp.
+        if (fragmentWidth <= minimumFragmentWidthToConsider)
+            continue;
+
+        suffixStart += fragmentLength;
+        maxFragmentWidth = max(maxFragmentWidth, fragmentWidth);
+    }
+
+    return maxFragmentWidth;
+}
+
 void RenderText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
 {
@@ -926 +967 @@
     // space, then subtract its width.
     float wordTrailingSpaceWidth = f.typesettingFeatures() & Kerning ? f.width(RenderBlock::constructTextRun(this, f, &space, 1, styleToUse)) : 0;
+
+    // If automatic hyphenation is allowed, we keep track of the width of the widest word (or word
+    // fragment) encountered so far, and only try hyphenating words that are wider.
+    float maxWordWidth = numeric_limits<float>::max();
+    int minimumPrefixLength = 0;
+    int minimumSuffixLength = 0;
+    if (styleToUse->hyphens() == HyphensAuto && canHyphenate(styleToUse->locale())) {
+        maxWordWidth = 0;
+
+        // Map 'hyphenate-limit-{before,after}: auto;' to 2.
+        minimumPrefixLength = styleToUse->hyphenationLimitBefore();
+        if (minimumPrefixLength < 0)
+            minimumPrefixLength = 2;
+
+        minimumSuffixLength = styleToUse->hyphenationLimitAfter();
+        if (minimumSuffixLength < 0)
+            minimumSuffixLength = 2;
+    }
 
     int firstGlyphLeftOverflow = -1;
@@ -1006 +1065 @@
             }
 
+            if (w > maxWordWidth) {
+                int suffixStart;
+                float maxFragmentWidth = maxWordFragmentWidth(this, styleToUse, f, txt + i, wordLen, minimumPrefixLength, minimumSuffixLength, suffixStart);
+
+                if (suffixStart) {
+                    float suffixWidth;
+                    if (wordTrailingSpaceWidth && isSpace)
+                        suffixWidth = widthFromCache(f, i + suffixStart, wordLen - suffixStart + 1, leadWidth + currMaxWidth, 0, 0) - wordTrailingSpaceWidth;
+                    else
+                        suffixWidth = widthFromCache(f, i + suffixStart, wordLen - suffixStart, leadWidth + currMaxWidth, 0, 0);
+
+                    maxFragmentWidth = max(maxFragmentWidth, suffixWidth);
+
+                    currMinWidth += maxFragmentWidth - w;
+                    maxWordWidth = max(maxWordWidth, maxFragmentWidth);
+                } else
+                    maxWordWidth = w;
+            }
+
             if (firstGlyphLeftOverflow < 0)
                 firstGlyphLeftOverflow = glyphOverflow.left;
@@ -1033 +1111 @@
                 if (hasBreak)
                     m_hasBreakableChar = true;
-                m_beginMinWidth = hasBreak ? 0 : w;
+                m_beginMinWidth = hasBreak ? 0 : currMinWidth;
             }
-            m_endMinWidth = w;
+            m_endMinWidth = currMinWidth;
 
             if (currMinWidth > m_minWidth)