Home | History | Annotate | Download | only in graphics 
      1 /*
      2  * Copyright (C) 2003, 2006, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
      3  * Copyright (C) 2008 Holger Hans Peter Freyther
      4  *
      5  * This library is free software; you can redistribute it and/or
      6  * modify it under the terms of the GNU Library General Public
      7  * License as published by the Free Software Foundation; either
      8  * version 2 of the License, or (at your option) any later version.
      9  *
     10  * This library is distributed in the hope that it will be useful,
     11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13  * Library General Public License for more details.
     14  *
     15  * You should have received a copy of the GNU Library General Public License
     16  * along with this library; see the file COPYING.LIB.  If not, write to
     17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     18  * Boston, MA 02110-1301, USA.
     19  *
     20  */
     21 
     22 #include "config.h"
     23 #include "core/platform/graphics/WidthIterator.h"
     24 
     25 #include "core/platform/graphics/Font.h"
     26 #include "core/platform/graphics/GlyphBuffer.h"
     27 #include "core/platform/graphics/Latin1TextIterator.h"
     28 #include "core/platform/graphics/SimpleFontData.h"
     29 #include "core/platform/graphics/SurrogatePairAwareTextIterator.h"
     30 #include "wtf/MathExtras.h"
     31 
     32 using namespace WTF;
     33 using namespace Unicode;
     34 using namespace std;
     35 
     36 namespace WebCore {
     37 
     38 WidthIterator::WidthIterator(const Font* font, const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, bool accountForGlyphBounds, bool forTextEmphasis)
     39     : m_font(font)
     40     , m_run(run)
     41     , m_currentCharacter(0)
     42     , m_runWidthSoFar(0)
     43     , m_isAfterExpansion(!run.allowsLeadingExpansion())
     44     , m_finalRoundingWidth(0)
     45     , m_typesettingFeatures(font->typesettingFeatures())
     46     , m_fallbackFonts(fallbackFonts)
     47     , m_accountForGlyphBounds(accountForGlyphBounds)
     48     , m_maxGlyphBoundingBoxY(numeric_limits<float>::min())
     49     , m_minGlyphBoundingBoxY(numeric_limits<float>::max())
     50     , m_firstGlyphOverflow(0)
     51     , m_lastGlyphOverflow(0)
     52     , m_forTextEmphasis(forTextEmphasis)
     53 {
     54     // If the padding is non-zero, count the number of spaces in the run
     55     // and divide that by the padding for per space addition.
     56     m_expansion = m_run.expansion();
     57     if (!m_expansion)
     58         m_expansionPerOpportunity = 0;
     59     else {
     60         bool isAfterExpansion = m_isAfterExpansion;
     61         unsigned expansionOpportunityCount = m_run.is8Bit() ? Font::expansionOpportunityCount(m_run.characters8(), m_run.length(), m_run.ltr() ? LTR : RTL, isAfterExpansion) : Font::expansionOpportunityCount(m_run.characters16(), m_run.length(), m_run.ltr() ? LTR : RTL, isAfterExpansion);
     62         if (isAfterExpansion && !m_run.allowsTrailingExpansion())
     63             expansionOpportunityCount--;
     64 
     65         if (!expansionOpportunityCount)
     66             m_expansionPerOpportunity = 0;
     67         else
     68             m_expansionPerOpportunity = m_expansion / expansionOpportunityCount;
     69     }
     70 }
     71 
     72 GlyphData WidthIterator::glyphDataForCharacter(UChar32 character, bool mirror, int currentCharacter, unsigned& advanceLength)
     73 {
     74     ASSERT(m_font);
     75 
     76 #if ENABLE(SVG_FONTS)
     77     if (TextRun::RenderingContext* renderingContext = m_run.renderingContext())
     78         return renderingContext->glyphDataForCharacter(*m_font, m_run, *this, character, mirror, currentCharacter, advanceLength);
     79 #else
     80     UNUSED_PARAM(currentCharacter);
     81     UNUSED_PARAM(advanceLength);
     82 #endif
     83 
     84     return m_font->glyphDataForCharacter(character, mirror);
     85 }
     86 
     87 struct OriginalAdvancesForCharacterTreatedAsSpace {
     88 public:
     89     OriginalAdvancesForCharacterTreatedAsSpace(bool isSpace, float advanceBefore, float advanceAt)
     90         : characterIsSpace(isSpace)
     91         , advanceBeforeCharacter(advanceBefore)
     92         , advanceAtCharacter(advanceAt)
     93     {
     94     }
     95 
     96     bool characterIsSpace;
     97     float advanceBeforeCharacter;
     98     float advanceAtCharacter;
     99 };
    100 
    101 typedef Vector<pair<int, OriginalAdvancesForCharacterTreatedAsSpace>, 64> CharactersTreatedAsSpace;
    102 
    103 static inline float applyFontTransforms(GlyphBuffer* glyphBuffer, bool ltr, int& lastGlyphCount, const SimpleFontData* fontData, TypesettingFeatures typesettingFeatures, CharactersTreatedAsSpace& charactersTreatedAsSpace)
    104 {
    105     ASSERT(typesettingFeatures & (Kerning | Ligatures));
    106 
    107     if (!glyphBuffer)
    108         return 0;
    109 
    110     int glyphBufferSize = glyphBuffer->size();
    111     if (glyphBuffer->size() <= lastGlyphCount + 1)
    112         return 0;
    113 
    114     GlyphBufferAdvance* advances = glyphBuffer->advances(0);
    115     float widthDifference = 0;
    116     for (int i = lastGlyphCount; i < glyphBufferSize; ++i)
    117         widthDifference -= advances[i].width();
    118 
    119     if (!ltr)
    120         glyphBuffer->reverse(lastGlyphCount, glyphBufferSize - lastGlyphCount);
    121 
    122     fontData->applyTransforms(glyphBuffer->glyphs(lastGlyphCount), advances + lastGlyphCount, glyphBufferSize - lastGlyphCount, typesettingFeatures);
    123 
    124     if (!ltr)
    125         glyphBuffer->reverse(lastGlyphCount, glyphBufferSize - lastGlyphCount);
    126 
    127     for (size_t i = 0; i < charactersTreatedAsSpace.size(); ++i) {
    128         int spaceOffset = charactersTreatedAsSpace[i].first;
    129         const OriginalAdvancesForCharacterTreatedAsSpace& originalAdvances = charactersTreatedAsSpace[i].second;
    130         if (spaceOffset && !originalAdvances.characterIsSpace)
    131             glyphBuffer->advances(spaceOffset - 1)->setWidth(originalAdvances.advanceBeforeCharacter);
    132         glyphBuffer->advances(spaceOffset)->setWidth(originalAdvances.advanceAtCharacter);
    133     }
    134     charactersTreatedAsSpace.clear();
    135 
    136     for (int i = lastGlyphCount; i < glyphBufferSize; ++i)
    137         widthDifference += advances[i].width();
    138 
    139     lastGlyphCount = glyphBufferSize;
    140     return widthDifference;
    141 }
    142 
    143 template <typename TextIterator>
    144 inline unsigned WidthIterator::advanceInternal(TextIterator& textIterator, GlyphBuffer* glyphBuffer)
    145 {
    146     bool rtl = m_run.rtl();
    147     bool hasExtraSpacing = (m_font->letterSpacing() || m_font->wordSpacing() || m_expansion) && !m_run.spacingDisabled();
    148 
    149     float widthSinceLastRounding = m_runWidthSoFar;
    150     m_runWidthSoFar = floorf(m_runWidthSoFar);
    151     widthSinceLastRounding -= m_runWidthSoFar;
    152 
    153     float lastRoundingWidth = m_finalRoundingWidth;
    154     FloatRect bounds;
    155 
    156     const SimpleFontData* primaryFont = m_font->primaryFont();
    157     const SimpleFontData* lastFontData = primaryFont;
    158     int lastGlyphCount = glyphBuffer ? glyphBuffer->size() : 0;
    159 
    160     UChar32 character = 0;
    161     unsigned clusterLength = 0;
    162     CharactersTreatedAsSpace charactersTreatedAsSpace;
    163     while (textIterator.consume(character, clusterLength)) {
    164         unsigned advanceLength = clusterLength;
    165         const GlyphData& glyphData = glyphDataForCharacter(character, rtl, textIterator.currentCharacter(), advanceLength);
    166         Glyph glyph = glyphData.glyph;
    167         const SimpleFontData* fontData = glyphData.fontData;
    168 
    169         ASSERT(fontData);
    170 
    171         // Now that we have a glyph and font data, get its width.
    172         float width;
    173         if (character == '\t' && m_run.allowTabs())
    174             width = m_font->tabWidth(*fontData, m_run.tabSize(), m_run.xPos() + m_runWidthSoFar + widthSinceLastRounding);
    175         else {
    176             width = fontData->widthForGlyph(glyph);
    177 
    178             // SVG uses horizontalGlyphStretch(), when textLength is used to stretch/squeeze text.
    179             width *= m_run.horizontalGlyphStretch();
    180 
    181             // We special case spaces in two ways when applying word rounding.
    182             // First, we round spaces to an adjusted width in all fonts.
    183             // Second, in fixed-pitch fonts we ensure that all characters that
    184             // match the width of the space character have the same width as the space character.
    185             if (m_run.applyWordRounding() && width == fontData->spaceWidth() && (fontData->pitch() == FixedPitch || glyph == fontData->spaceGlyph()))
    186                 width = fontData->adjustedSpaceWidth();
    187         }
    188 
    189         if (fontData != lastFontData && width) {
    190             if (shouldApplyFontTransforms())
    191                 m_runWidthSoFar += applyFontTransforms(glyphBuffer, m_run.ltr(), lastGlyphCount, lastFontData, m_typesettingFeatures, charactersTreatedAsSpace);
    192 
    193             lastFontData = fontData;
    194             if (m_fallbackFonts && fontData != primaryFont) {
    195                 // FIXME: This does a little extra work that could be avoided if
    196                 // glyphDataForCharacter() returned whether it chose to use a small caps font.
    197                 if (!m_font->isSmallCaps() || character == toUpper(character))
    198                     m_fallbackFonts->add(fontData);
    199                 else {
    200                     const GlyphData& uppercaseGlyphData = m_font->glyphDataForCharacter(toUpper(character), rtl);
    201                     if (uppercaseGlyphData.fontData != primaryFont)
    202                         m_fallbackFonts->add(uppercaseGlyphData.fontData);
    203                 }
    204             }
    205         }
    206 
    207         if (hasExtraSpacing) {
    208             // Account for letter-spacing.
    209             if (width && m_font->letterSpacing())
    210                 width += m_font->letterSpacing();
    211 
    212             static bool expandAroundIdeographs = Font::canExpandAroundIdeographsInComplexText();
    213             bool treatAsSpace = Font::treatAsSpace(character);
    214             if (treatAsSpace || (expandAroundIdeographs && Font::isCJKIdeographOrSymbol(character))) {
    215                 // Distribute the run's total expansion evenly over all expansion opportunities in the run.
    216                 if (m_expansion) {
    217                     float previousExpansion = m_expansion;
    218                     if (!treatAsSpace && !m_isAfterExpansion) {
    219                         // Take the expansion opportunity before this ideograph.
    220                         m_expansion -= m_expansionPerOpportunity;
    221                         float expansionAtThisOpportunity = !m_run.applyWordRounding() ? m_expansionPerOpportunity : roundf(previousExpansion) - roundf(m_expansion);
    222                         m_runWidthSoFar += expansionAtThisOpportunity;
    223                         if (glyphBuffer) {
    224                             if (glyphBuffer->isEmpty()) {
    225                                 if (m_forTextEmphasis)
    226                                     glyphBuffer->add(fontData->zeroWidthSpaceGlyph(), fontData, m_expansionPerOpportunity);
    227                                 else
    228                                     glyphBuffer->add(fontData->spaceGlyph(), fontData, expansionAtThisOpportunity);
    229                             } else
    230                                 glyphBuffer->expandLastAdvance(expansionAtThisOpportunity);
    231                         }
    232                         previousExpansion = m_expansion;
    233                     }
    234                     if (m_run.allowsTrailingExpansion() || (m_run.ltr() && textIterator.currentCharacter() + advanceLength < static_cast<size_t>(m_run.length()))
    235                         || (m_run.rtl() && textIterator.currentCharacter())) {
    236                         m_expansion -= m_expansionPerOpportunity;
    237                         width += !m_run.applyWordRounding() ? m_expansionPerOpportunity : roundf(previousExpansion) - roundf(m_expansion);
    238                         m_isAfterExpansion = true;
    239                     }
    240                 } else
    241                     m_isAfterExpansion = false;
    242 
    243                 // Account for word spacing.
    244                 // We apply additional space between "words" by adding width to the space character.
    245                 if (treatAsSpace && (character != '\t' || !m_run.allowTabs()) && (textIterator.currentCharacter() || character == noBreakSpace) && m_font->wordSpacing())
    246                     width += m_font->wordSpacing();
    247             } else
    248                 m_isAfterExpansion = false;
    249         }
    250 
    251         if (shouldApplyFontTransforms() && glyphBuffer && Font::treatAsSpace(character))
    252             charactersTreatedAsSpace.append(make_pair(glyphBuffer->size(),
    253                 OriginalAdvancesForCharacterTreatedAsSpace(character == ' ', glyphBuffer->size() ? glyphBuffer->advanceAt(glyphBuffer->size() - 1) : 0, width)));
    254 
    255         if (m_accountForGlyphBounds) {
    256             bounds = fontData->boundsForGlyph(glyph);
    257             if (!textIterator.currentCharacter())
    258                 m_firstGlyphOverflow = max<float>(0, -bounds.x());
    259         }
    260 
    261         if (m_forTextEmphasis && !Font::canReceiveTextEmphasis(character))
    262             glyph = 0;
    263 
    264         // Advance past the character we just dealt with.
    265         textIterator.advance(advanceLength);
    266 
    267         float oldWidth = width;
    268 
    269         // Force characters that are used to determine word boundaries for the rounding hack
    270         // to be integer width, so following words will start on an integer boundary.
    271         if (m_run.applyWordRounding() && Font::isRoundingHackCharacter(character)) {
    272             width = ceilf(width);
    273 
    274             // Since widthSinceLastRounding can lose precision if we include measurements for
    275             // preceding whitespace, we bypass it here.
    276             m_runWidthSoFar += width;
    277 
    278             // Since this is a rounding hack character, we should have reset this sum on the previous
    279             // iteration.
    280             ASSERT(!widthSinceLastRounding);
    281         } else {
    282             // Check to see if the next character is a "rounding hack character", if so, adjust
    283             // width so that the total run width will be on an integer boundary.
    284             if ((m_run.applyWordRounding() && textIterator.currentCharacter() < m_run.length() && Font::isRoundingHackCharacter(*(textIterator.characters())))
    285                 || (m_run.applyRunRounding() && textIterator.currentCharacter() >= m_run.length())) {
    286                 float totalWidth = widthSinceLastRounding + width;
    287                 widthSinceLastRounding = ceilf(totalWidth);
    288                 width += widthSinceLastRounding - totalWidth;
    289                 m_runWidthSoFar += widthSinceLastRounding;
    290                 widthSinceLastRounding = 0;
    291             } else
    292                 widthSinceLastRounding += width;
    293         }
    294 
    295         if (glyphBuffer)
    296             glyphBuffer->add(glyph, fontData, (rtl ? oldWidth + lastRoundingWidth : width));
    297 
    298         lastRoundingWidth = width - oldWidth;
    299 
    300         if (m_accountForGlyphBounds) {
    301             m_maxGlyphBoundingBoxY = max(m_maxGlyphBoundingBoxY, bounds.maxY());
    302             m_minGlyphBoundingBoxY = min(m_minGlyphBoundingBoxY, bounds.y());
    303             m_lastGlyphOverflow = max<float>(0, bounds.maxX() - width);
    304         }
    305     }
    306 
    307     if (shouldApplyFontTransforms())
    308         m_runWidthSoFar += applyFontTransforms(glyphBuffer, m_run.ltr(), lastGlyphCount, lastFontData, m_typesettingFeatures, charactersTreatedAsSpace);
    309 
    310     unsigned consumedCharacters = textIterator.currentCharacter() - m_currentCharacter;
    311     m_currentCharacter = textIterator.currentCharacter();
    312     m_runWidthSoFar += widthSinceLastRounding;
    313     m_finalRoundingWidth = lastRoundingWidth;
    314     return consumedCharacters;
    315 }
    316 
    317 unsigned WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
    318 {
    319     int length = m_run.length();
    320 
    321     if (offset > length)
    322         offset = length;
    323 
    324     if (m_currentCharacter >= static_cast<unsigned>(offset))
    325         return 0;
    326 
    327     if (m_run.is8Bit()) {
    328         Latin1TextIterator textIterator(m_run.data8(m_currentCharacter), m_currentCharacter, offset, length);
    329         return advanceInternal(textIterator, glyphBuffer);
    330     }
    331 
    332     SurrogatePairAwareTextIterator textIterator(m_run.data16(m_currentCharacter), m_currentCharacter, offset, length);
    333     return advanceInternal(textIterator, glyphBuffer);
    334 }
    335 
    336 bool WidthIterator::advanceOneCharacter(float& width, GlyphBuffer& glyphBuffer)
    337 {
    338     int oldSize = glyphBuffer.size();
    339     advance(m_currentCharacter + 1, &glyphBuffer);
    340     float w = 0;
    341     for (int i = oldSize; i < glyphBuffer.size(); ++i)
    342         w += glyphBuffer.advanceAt(i);
    343     width = w;
    344     return glyphBuffer.size() > oldSize;
    345 }
    346 
    347 }
    348