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 "TextRun.h" 29 #include <wtf/MathExtras.h> 30 31 #if USE(ICU_UNICODE) 32 #include <unicode/unorm.h> 33 #endif 34 35 using namespace WTF; 36 using namespace Unicode; 37 using namespace std; 38 39 namespace WebCore { 40 41 // According to http://www.unicode.org/Public/UNIDATA/UCD.html#Canonical_Combining_Class_Values 42 static const uint8_t hiraganaKatakanaVoicingMarksCombiningClass = 8; 43 44 WidthIterator::WidthIterator(const Font* font, const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, bool accountForGlyphBounds, bool forTextEmphasis) 45 : m_font(font) 46 , m_run(run) 47 , m_end(run.length()) 48 , m_currentCharacter(0) 49 , m_runWidthSoFar(0) 50 , m_isAfterExpansion(!run.allowsLeadingExpansion()) 51 , m_fallbackFonts(fallbackFonts) 52 , m_accountForGlyphBounds(accountForGlyphBounds) 53 , m_maxGlyphBoundingBoxY(numeric_limits<float>::min()) 54 , m_minGlyphBoundingBoxY(numeric_limits<float>::max()) 55 , m_firstGlyphOverflow(0) 56 , m_lastGlyphOverflow(0) 57 , m_forTextEmphasis(forTextEmphasis) 58 { 59 // If the padding is non-zero, count the number of spaces in the run 60 // and divide that by the padding for per space addition. 61 m_expansion = m_run.expansion(); 62 if (!m_expansion) 63 m_expansionPerOpportunity = 0; 64 else { 65 bool isAfterExpansion = m_isAfterExpansion; 66 unsigned expansionOpportunityCount = Font::expansionOpportunityCount(m_run.characters(), m_end, m_run.ltr() ? LTR : RTL, isAfterExpansion); 67 if (isAfterExpansion && !m_run.allowsTrailingExpansion()) 68 expansionOpportunityCount--; 69 70 if (!expansionOpportunityCount) 71 m_expansionPerOpportunity = 0; 72 else 73 m_expansionPerOpportunity = m_expansion / expansionOpportunityCount; 74 } 75 } 76 77 void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer) 78 { 79 if (offset > m_end) 80 offset = m_end; 81 82 int currentCharacter = m_currentCharacter; 83 const UChar* cp = m_run.data(currentCharacter); 84 85 bool rtl = m_run.rtl(); 86 bool hasExtraSpacing = (m_font->letterSpacing() || m_font->wordSpacing() || m_expansion) && !m_run.spacingDisabled(); 87 88 FloatRect bounds; 89 90 const SimpleFontData* primaryFont = m_font->primaryFont(); 91 const SimpleFontData* lastFontData = primaryFont; 92 93 while (currentCharacter < offset) { 94 UChar32 c = *cp; 95 unsigned clusterLength = 1; 96 if (c >= 0x3041) { 97 if (c <= 0x30FE) { 98 // Deal with Hiragana and Katakana voiced and semi-voiced syllables. 99 // Normalize into composed form, and then look for glyph with base + combined mark. 100 // Check above for character range to minimize performance impact. 101 UChar32 normalized = normalizeVoicingMarks(currentCharacter); 102 if (normalized) { 103 c = normalized; 104 clusterLength = 2; 105 } 106 } else if (U16_IS_SURROGATE(c)) { 107 if (!U16_IS_SURROGATE_LEAD(c)) 108 break; 109 110 // Do we have a surrogate pair? If so, determine the full Unicode (32 bit) 111 // code point before glyph lookup. 112 // Make sure we have another character and it's a low surrogate. 113 if (currentCharacter + 1 >= m_run.length()) 114 break; 115 UChar low = cp[1]; 116 if (!U16_IS_TRAIL(low)) 117 break; 118 c = U16_GET_SUPPLEMENTARY(c, low); 119 clusterLength = 2; 120 } 121 } 122 123 const GlyphData& glyphData = m_font->glyphDataForCharacter(c, rtl); 124 Glyph glyph = glyphData.glyph; 125 const SimpleFontData* fontData = glyphData.fontData; 126 127 ASSERT(fontData); 128 129 // Now that we have a glyph and font data, get its width. 130 float width; 131 if (c == '\t' && m_run.allowTabs()) { 132 float tabWidth = m_font->tabWidth(*fontData); 133 width = tabWidth - fmodf(m_run.xPos() + m_runWidthSoFar, tabWidth); 134 } else { 135 width = fontData->widthForGlyph(glyph); 136 137 #if ENABLE(SVG) 138 // SVG uses horizontalGlyphStretch(), when textLength is used to stretch/squeeze text. 139 width *= m_run.horizontalGlyphStretch(); 140 #endif 141 } 142 143 if (fontData != lastFontData && width) { 144 lastFontData = fontData; 145 if (m_fallbackFonts && fontData != primaryFont) { 146 // FIXME: This does a little extra work that could be avoided if 147 // glyphDataForCharacter() returned whether it chose to use a small caps font. 148 if (!m_font->isSmallCaps() || c == toUpper(c)) 149 m_fallbackFonts->add(fontData); 150 else { 151 const GlyphData& uppercaseGlyphData = m_font->glyphDataForCharacter(toUpper(c), rtl); 152 if (uppercaseGlyphData.fontData != primaryFont) 153 m_fallbackFonts->add(uppercaseGlyphData.fontData); 154 } 155 } 156 } 157 158 if (hasExtraSpacing) { 159 // Account for letter-spacing. 160 if (width && m_font->letterSpacing()) 161 width += m_font->letterSpacing(); 162 163 static bool expandAroundIdeographs = Font::canExpandAroundIdeographsInComplexText(); 164 bool treatAsSpace = Font::treatAsSpace(c); 165 if (treatAsSpace || (expandAroundIdeographs && Font::isCJKIdeographOrSymbol(c))) { 166 // Distribute the run's total expansion evenly over all expansion opportunities in the run. 167 if (m_expansion) { 168 if (!treatAsSpace && !m_isAfterExpansion) { 169 // Take the expansion opportunity before this ideograph. 170 m_expansion -= m_expansionPerOpportunity; 171 m_runWidthSoFar += m_expansionPerOpportunity; 172 if (glyphBuffer) { 173 if (glyphBuffer->isEmpty()) 174 glyphBuffer->add(fontData->spaceGlyph(), fontData, m_expansionPerOpportunity); 175 else 176 glyphBuffer->expandLastAdvance(m_expansionPerOpportunity); 177 } 178 } 179 if (m_run.allowsTrailingExpansion() || (m_run.ltr() && currentCharacter + clusterLength < static_cast<size_t>(m_run.length())) 180 || (m_run.rtl() && currentCharacter)) { 181 m_expansion -= m_expansionPerOpportunity; 182 width += m_expansionPerOpportunity; 183 m_isAfterExpansion = true; 184 } 185 } else 186 m_isAfterExpansion = false; 187 188 // Account for word spacing. 189 // We apply additional space between "words" by adding width to the space character. 190 if (treatAsSpace && currentCharacter && !Font::treatAsSpace(cp[-1]) && m_font->wordSpacing()) 191 width += m_font->wordSpacing(); 192 } else 193 m_isAfterExpansion = false; 194 } 195 196 if (m_accountForGlyphBounds) { 197 bounds = fontData->boundsForGlyph(glyph); 198 if (!currentCharacter) 199 m_firstGlyphOverflow = max<float>(0, -bounds.x()); 200 } 201 202 if (m_forTextEmphasis && !Font::canReceiveTextEmphasis(c)) 203 glyph = 0; 204 205 // Advance past the character we just dealt with. 206 cp += clusterLength; 207 currentCharacter += clusterLength; 208 209 m_runWidthSoFar += width; 210 211 if (glyphBuffer) 212 glyphBuffer->add(glyph, fontData, width); 213 214 if (m_accountForGlyphBounds) { 215 m_maxGlyphBoundingBoxY = max(m_maxGlyphBoundingBoxY, bounds.maxY()); 216 m_minGlyphBoundingBoxY = min(m_minGlyphBoundingBoxY, bounds.y()); 217 m_lastGlyphOverflow = max<float>(0, bounds.maxX() - width); 218 } 219 } 220 221 m_currentCharacter = currentCharacter; 222 } 223 224 bool WidthIterator::advanceOneCharacter(float& width, GlyphBuffer* glyphBuffer) 225 { 226 int oldSize = glyphBuffer->size(); 227 advance(m_currentCharacter + 1, glyphBuffer); 228 float w = 0; 229 for (int i = oldSize; i < glyphBuffer->size(); ++i) 230 w += glyphBuffer->advanceAt(i); 231 width = w; 232 return glyphBuffer->size() > oldSize; 233 } 234 235 UChar32 WidthIterator::normalizeVoicingMarks(int currentCharacter) 236 { 237 if (currentCharacter + 1 < m_end) { 238 if (combiningClass(m_run[currentCharacter + 1]) == hiraganaKatakanaVoicingMarksCombiningClass) { 239 #if USE(ICU_UNICODE) 240 // Normalize into composed form using 3.2 rules. 241 UChar normalizedCharacters[2] = { 0, 0 }; 242 UErrorCode uStatus = U_ZERO_ERROR; 243 int32_t resultLength = unorm_normalize(m_run.data(currentCharacter), 2, 244 UNORM_NFC, UNORM_UNICODE_3_2, &normalizedCharacters[0], 2, &uStatus); 245 if (resultLength == 1 && uStatus == 0) 246 return normalizedCharacters[0]; 247 #elif USE(QT4_UNICODE) 248 QString tmp(reinterpret_cast<const QChar*>(m_run.data(currentCharacter)), 2); 249 QString res = tmp.normalized(QString::NormalizationForm_C, QChar::Unicode_3_2); 250 if (res.length() == 1) 251 return res.at(0).unicode(); 252 #endif 253 } 254 } 255 return 0; 256 } 257 258 } 259
