2011-06-24 Nikolas Zimmermann <nzimmermann@rim.com>
[WebKit-https.git] / Source / WebCore / platform / graphics / WidthIterator.cpp
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 "WidthIterator.h"
24
25 #include "Font.h"
26 #include "GlyphBuffer.h"
27 #include "SimpleFontData.h"
28 #include "SurrogatePairAwareTextIterator.h"
29 #include "TextRun.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_fallbackFonts(fallbackFonts)
45     , m_accountForGlyphBounds(accountForGlyphBounds)
46     , m_maxGlyphBoundingBoxY(numeric_limits<float>::min())
47     , m_minGlyphBoundingBoxY(numeric_limits<float>::max())
48     , m_firstGlyphOverflow(0)
49     , m_lastGlyphOverflow(0)
50     , m_forTextEmphasis(forTextEmphasis)
51 {
52     // If the padding is non-zero, count the number of spaces in the run
53     // and divide that by the padding for per space addition.
54     m_expansion = m_run.expansion();
55     if (!m_expansion)
56         m_expansionPerOpportunity = 0;
57     else {
58         bool isAfterExpansion = m_isAfterExpansion;
59         unsigned expansionOpportunityCount = Font::expansionOpportunityCount(m_run.characters(), m_run.length(), m_run.ltr() ? LTR : RTL, isAfterExpansion);
60         if (isAfterExpansion && !m_run.allowsTrailingExpansion())
61             expansionOpportunityCount--;
62
63         if (!expansionOpportunityCount)
64             m_expansionPerOpportunity = 0;
65         else
66             m_expansionPerOpportunity = m_expansion / expansionOpportunityCount;
67     }
68 }
69
70 GlyphData WidthIterator::glyphDataForCharacter(UChar32 character, bool mirror, int currentCharacter, unsigned& advanceLength)
71 {
72     ASSERT(m_font);
73
74 #if ENABLE(SVG_FONTS)
75     if (TextRun::RenderingContext* renderingContext = m_run.renderingContext())
76         return renderingContext->glyphDataForCharacter(*m_font, m_run, *this, character, mirror, currentCharacter, advanceLength);
77 #else
78     UNUSED_PARAM(currentCharacter);
79     UNUSED_PARAM(advanceLength);
80 #endif
81
82     return m_font->glyphDataForCharacter(character, mirror);
83 }
84
85 unsigned WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
86 {
87     if (offset > m_run.length())
88         offset = m_run.length();
89
90     if (int(m_currentCharacter) >= offset)
91         return 0;
92
93     bool rtl = m_run.rtl();
94     bool hasExtraSpacing = (m_font->letterSpacing() || m_font->wordSpacing() || m_expansion) && !m_run.spacingDisabled();
95
96     FloatRect bounds;
97
98     const SimpleFontData* primaryFont = m_font->primaryFont();
99     const SimpleFontData* lastFontData = primaryFont;
100
101     UChar32 character = 0;
102     unsigned clusterLength = 0;
103     SurrogatePairAwareTextIterator textIterator(m_run.data(m_currentCharacter), m_currentCharacter, offset, m_run.length());
104     while (textIterator.consume(character, clusterLength)) {
105         unsigned advanceLength = clusterLength;
106         const GlyphData& glyphData = glyphDataForCharacter(character, rtl, textIterator.currentCharacter(), advanceLength);
107         Glyph glyph = glyphData.glyph;
108         const SimpleFontData* fontData = glyphData.fontData;
109
110         ASSERT(fontData);
111
112         // Now that we have a glyph and font data, get its width.
113         float width;
114         if (character == '\t' && m_run.allowTabs()) {
115             float tabWidth = m_font->tabWidth(*fontData);
116             width = tabWidth - fmodf(m_run.xPos() + m_runWidthSoFar, tabWidth);
117         } else {
118             width = fontData->widthForGlyph(glyph);
119
120 #if ENABLE(SVG)
121             // SVG uses horizontalGlyphStretch(), when textLength is used to stretch/squeeze text.
122             width *= m_run.horizontalGlyphStretch();
123 #endif
124         }
125
126         if (fontData != lastFontData && width) {
127             lastFontData = fontData;
128             if (m_fallbackFonts && fontData != primaryFont) {
129                 // FIXME: This does a little extra work that could be avoided if
130                 // glyphDataForCharacter() returned whether it chose to use a small caps font.
131                 if (!m_font->isSmallCaps() || character == toUpper(character))
132                     m_fallbackFonts->add(fontData);
133                 else {
134                     const GlyphData& uppercaseGlyphData = m_font->glyphDataForCharacter(toUpper(character), rtl);
135                     if (uppercaseGlyphData.fontData != primaryFont)
136                         m_fallbackFonts->add(uppercaseGlyphData.fontData);
137                 }
138             }
139         }
140
141         if (hasExtraSpacing) {
142             // Account for letter-spacing.
143             if (width && m_font->letterSpacing())
144                 width += m_font->letterSpacing();
145
146             static bool expandAroundIdeographs = Font::canExpandAroundIdeographsInComplexText();
147             bool treatAsSpace = Font::treatAsSpace(character);
148             if (treatAsSpace || (expandAroundIdeographs && Font::isCJKIdeographOrSymbol(character))) {
149                 // Distribute the run's total expansion evenly over all expansion opportunities in the run.
150                 if (m_expansion) {
151                     if (!treatAsSpace && !m_isAfterExpansion) {
152                         // Take the expansion opportunity before this ideograph.
153                         m_expansion -= m_expansionPerOpportunity;
154                         m_runWidthSoFar += m_expansionPerOpportunity;
155                         if (glyphBuffer) {
156                             if (glyphBuffer->isEmpty())
157                                 glyphBuffer->add(fontData->spaceGlyph(), fontData, m_expansionPerOpportunity);
158                             else
159                                 glyphBuffer->expandLastAdvance(m_expansionPerOpportunity);
160                         }
161                     }
162                     if (m_run.allowsTrailingExpansion() || (m_run.ltr() && textIterator.currentCharacter() + advanceLength < static_cast<size_t>(m_run.length()))
163                         || (m_run.rtl() && textIterator.currentCharacter())) {
164                         m_expansion -= m_expansionPerOpportunity;
165                         width += m_expansionPerOpportunity;
166                         m_isAfterExpansion = true;
167                     }
168                 } else
169                     m_isAfterExpansion = false;
170
171                 // Account for word spacing.
172                 // We apply additional space between "words" by adding width to the space character.
173                 if (treatAsSpace && textIterator.currentCharacter() && !Font::treatAsSpace(textIterator.characters()[-1]) && m_font->wordSpacing())
174                     width += m_font->wordSpacing();
175             } else
176                 m_isAfterExpansion = false;
177         }
178
179         if (m_accountForGlyphBounds) {
180             bounds = fontData->boundsForGlyph(glyph);
181             if (!textIterator.currentCharacter())
182                 m_firstGlyphOverflow = max<float>(0, -bounds.x());
183         }
184
185         if (m_forTextEmphasis && !Font::canReceiveTextEmphasis(character))
186             glyph = 0;
187
188         // Advance past the character we just dealt with.
189         textIterator.advance(advanceLength);
190         m_runWidthSoFar += width;
191
192         if (glyphBuffer)
193             glyphBuffer->add(glyph, fontData, width);
194
195         if (m_accountForGlyphBounds) {
196             m_maxGlyphBoundingBoxY = max(m_maxGlyphBoundingBoxY, bounds.maxY());
197             m_minGlyphBoundingBoxY = min(m_minGlyphBoundingBoxY, bounds.y());
198             m_lastGlyphOverflow = max<float>(0, bounds.maxX() - width);
199         }
200     }
201
202     unsigned consumedCharacters = textIterator.currentCharacter() - m_currentCharacter;
203     m_currentCharacter = textIterator.currentCharacter();
204     return consumedCharacters;
205 }
206
207 bool WidthIterator::advanceOneCharacter(float& width, GlyphBuffer* glyphBuffer)
208 {
209     int oldSize = glyphBuffer->size();
210     advance(m_currentCharacter + 1, glyphBuffer);
211     float w = 0;
212     for (int i = oldSize; i < glyphBuffer->size(); ++i)
213         w += glyphBuffer->advanceAt(i);
214     width = w;
215     return glyphBuffer->size() > oldSize;
216 }
217
218 }