Reviewed by Darin Adler.
[WebKit-https.git] / WebCore / platform / graphics / Font.cpp
1 /**
2  * This file is part of the html renderer for KDE.
3  *
4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
6  *           (C) 2000 Dirk Mueller (mueller@kde.org)
7  * Copyright (C) 2003, 2006 Apple Computer, Inc.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  *
24  */
25
26 #include "config.h"
27 #include "Font.h"
28
29 #include "CharacterNames.h"
30 #include "FloatRect.h"
31 #include "FontCache.h"
32 #include "FontFallbackList.h"
33 #include "IntPoint.h"
34 #include "GlyphBuffer.h"
35 #include <wtf/unicode/Unicode.h>
36 #include <wtf/MathExtras.h>
37
38 #if USE(ICU_UNICODE)
39 #include <unicode/unorm.h>
40 #endif
41
42 using namespace WTF;
43 using namespace Unicode;
44
45 namespace WebCore {
46
47 // According to http://www.unicode.org/Public/UNIDATA/UCD.html#Canonical_Combining_Class_Values
48 const uint8_t hiraganaKatakanaVoicingMarksCombiningClass = 8;
49
50 const uint8_t Font::gRoundingHackCharacterTable[256] = {
51     0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*\t*/, 1 /*\n*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
52     1 /*space*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*-*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 /*?*/,
53     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
54     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
55     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
56     1 /*no-break space*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
58     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
59 };
60
61 Font::CodePath Font::codePath = Auto;
62
63 struct WidthIterator {
64     WidthIterator(const Font* font, const TextRun& run);
65
66     void advance(int to, GlyphBuffer* glyphBuffer = 0);
67     bool advanceOneCharacter(float& width, GlyphBuffer* glyphBuffer = 0);
68     
69     const Font* m_font;
70
71     const TextRun& m_run;
72     int m_end;
73
74     unsigned m_currentCharacter;
75     float m_runWidthSoFar;
76     float m_padding;
77     float m_padPerSpace;
78     float m_finalRoundingWidth;
79     
80 private:
81     UChar32 normalizeVoicingMarks(int currentCharacter);
82 };
83
84 WidthIterator::WidthIterator(const Font* font, const TextRun& run)
85     : m_font(font)
86     , m_run(run)
87     , m_end(run.length())
88     , m_currentCharacter(0)
89     , m_runWidthSoFar(0)
90     , m_finalRoundingWidth(0)
91 {
92     // If the padding is non-zero, count the number of spaces in the run
93     // and divide that by the padding for per space addition.
94     m_padding = m_run.padding();
95     if (!m_padding)
96         m_padPerSpace = 0;
97     else {
98         float numSpaces = 0;
99         for (int i = 0; i < run.length(); i++)
100             if (Font::treatAsSpace(m_run[i]))
101                 numSpaces++;
102
103         if (numSpaces == 0)
104             m_padPerSpace = 0;
105         else
106             m_padPerSpace = ceilf(m_run.padding() / numSpaces);
107     }
108 }
109
110 void WidthIterator::advance(int offset, GlyphBuffer* glyphBuffer)
111 {
112     if (offset > m_end)
113         offset = m_end;
114
115     int currentCharacter = m_currentCharacter;
116     const UChar* cp = m_run.data(currentCharacter);
117
118     bool rtl = m_run.rtl();
119     bool hasExtraSpacing = m_font->letterSpacing() || m_font->wordSpacing() || m_padding;
120
121     float runWidthSoFar = m_runWidthSoFar;
122     float lastRoundingWidth = m_finalRoundingWidth;
123     
124     while (currentCharacter < offset) {
125         UChar32 c = *cp;
126         unsigned clusterLength = 1;
127         if (c >= 0x3041) {
128             if (c <= 0x30FE) {
129                 // Deal with Hiragana and Katakana voiced and semi-voiced syllables.
130                 // Normalize into composed form, and then look for glyph with base + combined mark.
131                 // Check above for character range to minimize performance impact.
132                 UChar32 normalized = normalizeVoicingMarks(currentCharacter);
133                 if (normalized) {
134                     c = normalized;
135                     clusterLength = 2;
136                 }
137             } else if (U16_IS_SURROGATE(c)) {
138                 if (!U16_IS_SURROGATE_LEAD(c))
139                     break;
140
141                 // Do we have a surrogate pair?  If so, determine the full Unicode (32 bit)
142                 // code point before glyph lookup.
143                 // Make sure we have another character and it's a low surrogate.
144                 if (currentCharacter + 1 >= m_run.length())
145                     break;
146                 UChar low = cp[1];
147                 if (!U16_IS_TRAIL(low))
148                     break;
149                 c = U16_GET_SUPPLEMENTARY(c, low);
150                 clusterLength = 2;
151             }
152         }
153
154         const GlyphData& glyphData = m_font->glyphDataForCharacter(c, rtl);
155         Glyph glyph = glyphData.glyph;
156         const FontData* fontData = glyphData.fontData;
157
158         ASSERT(fontData);
159
160         // Now that we have a glyph and font data, get its width.
161         float width;
162         if (c == '\t' && m_run.allowTabs()) {
163             float tabWidth = m_font->tabWidth();
164             width = tabWidth - fmodf(m_run.xPos() + runWidthSoFar, tabWidth);
165         } else {
166             width = fontData->widthForGlyph(glyph);
167             // We special case spaces in two ways when applying word rounding.
168             // First, we round spaces to an adjusted width in all fonts.
169             // Second, in fixed-pitch fonts we ensure that all characters that
170             // match the width of the space character have the same width as the space character.
171             if (width == fontData->m_spaceWidth && (fontData->m_treatAsFixedPitch || glyph == fontData->m_spaceGlyph) && m_run.applyWordRounding())
172                 width = fontData->m_adjustedSpaceWidth;
173         }
174
175         if (hasExtraSpacing && !m_run.spacingDisabled()) {
176             // Account for letter-spacing.
177             if (width && m_font->letterSpacing())
178                 width += m_font->letterSpacing();
179
180             if (Font::treatAsSpace(c)) {
181                 // Account for padding. WebCore uses space padding to justify text.
182                 // We distribute the specified padding over the available spaces in the run.
183                 if (m_padding) {
184                     // Use left over padding if not evenly divisible by number of spaces.
185                     if (m_padding < m_padPerSpace) {
186                         width += m_padding;
187                         m_padding = 0;
188                     } else {
189                         width += m_padPerSpace;
190                         m_padding -= m_padPerSpace;
191                     }
192                 }
193
194                 // Account for word spacing.
195                 // We apply additional space between "words" by adding width to the space character.
196                 if (currentCharacter != 0 && !Font::treatAsSpace(cp[-1]) && m_font->wordSpacing())
197                     width += m_font->wordSpacing();
198             }
199         }
200
201         // Advance past the character we just dealt with.
202         cp += clusterLength;
203         currentCharacter += clusterLength;
204
205         // Account for float/integer impedance mismatch between CG and KHTML. "Words" (characters 
206         // followed by a character defined by isRoundingHackCharacter()) are always an integer width.
207         // We adjust the width of the last character of a "word" to ensure an integer width.
208         // If we move KHTML to floats we can remove this (and related) hacks.
209
210         float oldWidth = width;
211
212         // Force characters that are used to determine word boundaries for the rounding hack
213         // to be integer width, so following words will start on an integer boundary.
214         if (m_run.applyWordRounding() && Font::isRoundingHackCharacter(c))
215             width = ceilf(width);
216
217         // Check to see if the next character is a "rounding hack character", if so, adjust
218         // width so that the total run width will be on an integer boundary.
219         if ((m_run.applyWordRounding() && currentCharacter < m_run.length() && Font::isRoundingHackCharacter(*cp))
220                 || (m_run.applyRunRounding() && currentCharacter >= m_end)) {
221             float totalWidth = runWidthSoFar + width;
222             width += ceilf(totalWidth) - totalWidth;
223         }
224
225         runWidthSoFar += width;
226
227         if (glyphBuffer)
228             glyphBuffer->add(glyph, fontData, (rtl ? oldWidth + lastRoundingWidth : width));
229
230         lastRoundingWidth = width - oldWidth;
231     }
232
233     m_currentCharacter = currentCharacter;
234     m_runWidthSoFar = runWidthSoFar;
235     m_finalRoundingWidth = lastRoundingWidth;
236 }
237
238 bool WidthIterator::advanceOneCharacter(float& width, GlyphBuffer* glyphBuffer)
239 {
240     glyphBuffer->clear();
241     advance(m_currentCharacter + 1, glyphBuffer);
242     float w = 0;
243     for (int i = 0; i < glyphBuffer->size(); ++i)
244         w += glyphBuffer->advanceAt(i);
245     width = w;
246     return !glyphBuffer->isEmpty();
247 }
248
249 UChar32 WidthIterator::normalizeVoicingMarks(int currentCharacter)
250 {
251     if (currentCharacter + 1 < m_end) {
252         if (combiningClass(m_run[currentCharacter + 1]) == hiraganaKatakanaVoicingMarksCombiningClass) {
253 #if USE(ICU_UNICODE)
254             // Normalize into composed form using 3.2 rules.
255             UChar normalizedCharacters[2] = { 0, 0 };
256             UErrorCode uStatus = U_ZERO_ERROR;  
257             int32_t resultLength = unorm_normalize(m_run.data(currentCharacter), 2,
258                 UNORM_NFC, UNORM_UNICODE_3_2, &normalizedCharacters[0], 2, &uStatus);
259             if (resultLength == 1 && uStatus == 0)
260                 return normalizedCharacters[0];
261 #elif USE(QT4_UNICODE)
262             QString tmp(reinterpret_cast<const QChar*>(m_run.data(currentCharacter)), 2);
263             QString res = tmp.normalized(QString::NormalizationForm_C, QChar::Unicode_3_2);
264             if (res.length() == 1)
265                 return res.at(0).unicode();
266 #endif
267         }
268     }
269     return 0;
270 }
271
272 // ============================================================================================
273 // Font Implementation (Cross-Platform Portion)
274 // ============================================================================================
275
276 Font::Font()
277     : m_pageZero(0)
278     , m_letterSpacing(0)
279     , m_wordSpacing(0)
280     , m_isPlatformFont(false)
281 {
282 }
283
284 Font::Font(const FontDescription& fd, short letterSpacing, short wordSpacing) 
285     : m_fontDescription(fd)
286     , m_pageZero(0)
287     , m_letterSpacing(letterSpacing)
288     , m_wordSpacing(wordSpacing)
289     , m_isPlatformFont(false)
290 {
291 }
292
293 Font::Font(const FontPlatformData& fontData, bool isPrinterFont)
294     : m_fontList(new FontFallbackList)
295     , m_pageZero(0)
296     , m_letterSpacing(0)
297     , m_wordSpacing(0)
298     , m_isPlatformFont(true)
299 {
300     m_fontDescription.setUsePrinterFont(isPrinterFont);
301     m_fontList->setPlatformFont(fontData);
302 }
303
304 Font::Font(const Font& other)
305     : m_fontDescription(other.m_fontDescription)
306     , m_fontList(other.m_fontList)
307     , m_pages(other.m_pages)
308     , m_pageZero(other.m_pageZero)
309     , m_letterSpacing(other.m_letterSpacing)
310     , m_wordSpacing(other.m_wordSpacing)
311     , m_isPlatformFont(other.m_isPlatformFont)
312 {
313 }
314
315 Font& Font::operator=(const Font& other)
316 {
317     m_fontDescription = other.m_fontDescription;
318     m_fontList = other.m_fontList;
319     m_pages = other.m_pages;
320     m_pageZero = other.m_pageZero;
321     m_letterSpacing = other.m_letterSpacing;
322     m_wordSpacing = other.m_wordSpacing;
323     m_isPlatformFont = other.m_isPlatformFont;
324     return *this;
325 }
326
327 Font::~Font()
328 {
329 }
330
331 bool Font::operator==(const Font& other) const
332 {
333     // Our FontData don't have to be checked, since checking the font description will be fine.
334     // FIXME: This does not work if the font was made with the FontPlatformData constructor.
335     if ((m_fontList && m_fontList->loadingCustomFonts()) ||
336         (other.m_fontList && other.m_fontList->loadingCustomFonts()))
337         return false;
338     
339     FontSelector* first = m_fontList ? m_fontList->fontSelector() : 0;
340     FontSelector* second = other.m_fontList ? other.m_fontList->fontSelector() : 0;
341     
342     return first == second
343            && m_fontDescription == other.m_fontDescription
344            && m_letterSpacing == other.m_letterSpacing
345            && m_wordSpacing == other.m_wordSpacing;
346 }
347     
348 // FIXME: It is unfortunate that this function needs to be passed the original cluster.
349 // It is only required for the platform's FontCache::getFontDataForCharacters(), and it means
350 // that this function is not correct if it transforms the character to uppercase and calls
351 // FontCache::getFontDataForCharacters() afterwards.
352 const GlyphData& Font::glyphDataForCharacter(UChar32 c, bool mirror) const
353 {
354     bool useSmallCapsFont = false;
355     if (m_fontDescription.smallCaps()) {
356         UChar32 upperC = Unicode::toUpper(c);
357         if (upperC != c) {
358             c = upperC;
359             useSmallCapsFont = true;
360         }
361     }
362
363     if (mirror)
364         c = mirroredChar(c);
365
366     unsigned pageNumber = (c / GlyphPage::size);
367
368     GlyphPageTreeNode* node = pageNumber ? m_pages.get(pageNumber) : m_pageZero;
369     if (!node) {
370         node = GlyphPageTreeNode::getRootChild(primaryFont(), pageNumber);
371         if (pageNumber)
372             m_pages.set(pageNumber, node);
373         else
374             m_pageZero = node;
375     }
376
377     GlyphPage* page;
378     if (!useSmallCapsFont) {
379         // Fastest loop, for the common case (not small caps).
380         while (true) {
381             page = node->page();
382             if (page) {
383                 const GlyphData& data = page->glyphDataForCharacter(c);
384                 if (data.fontData)
385                     return data;
386                 if (node->isSystemFallback())
387                     break;
388             }
389
390             // Proceed with the fallback list.
391             node = node->getChild(fontDataAt(node->level()), pageNumber);
392             if (pageNumber)
393                 m_pages.set(pageNumber, node);
394             else
395                 m_pageZero = node;
396         }
397     } else {
398         while (true) {
399             page = node->page();
400             if (page) {
401                 const GlyphData& data = page->glyphDataForCharacter(c);
402                 if (data.fontData) {
403                     // The smallCapsFontData function should not normally return 0.
404                     // But if it does, we will just render the capital letter big.
405                     const FontData* smallCapsFontData = data.fontData->smallCapsFontData(m_fontDescription);
406                     if (!smallCapsFontData)
407                         return data;
408
409                     GlyphPageTreeNode* smallCapsNode = GlyphPageTreeNode::getRootChild(smallCapsFontData, pageNumber);
410                     const GlyphData& data = smallCapsNode->page()->glyphDataForCharacter(c);
411                     if (data.fontData)
412                         return data;
413
414                     // Do not attempt system fallback off the smallCapsFontData. This is the very unlikely case that
415                     // a font has the lowercase character but the small caps font does not have its uppercase version.
416                     return smallCapsFontData->missingGlyphData();
417                 }
418
419                 if (node->isSystemFallback())
420                     break;
421             }
422
423             // Proceed with the fallback list.
424             node = node->getChild(fontDataAt(node->level()), pageNumber);
425             if (pageNumber)
426                 m_pages.set(pageNumber, node);
427             else
428                 m_pageZero = node;
429         }
430     }
431
432     ASSERT(page);
433     ASSERT(node->isSystemFallback());
434
435     // System fallback is character-dependent. When we get here, we
436     // know that the character in question isn't in the system fallback
437     // font's glyph page. Try to lazily create it here.
438     UChar codeUnits[2];
439     int codeUnitsLength;
440     if (c <= 0xFFFF) {
441         UChar c16 = c;
442         if (Font::treatAsSpace(c16))
443             codeUnits[0] = ' ';
444         else if (Font::treatAsZeroWidthSpace(c16))
445             codeUnits[0] = zeroWidthSpace;
446         else
447             codeUnits[0] = c16;
448         codeUnitsLength = 1;
449     } else {
450         codeUnits[0] = U16_LEAD(c);
451         codeUnits[1] = U16_TRAIL(c);
452         codeUnitsLength = 2;
453     }
454     const FontData* characterFontData = FontCache::getFontDataForCharacters(*this, codeUnits, codeUnitsLength);
455     if (useSmallCapsFont)
456         characterFontData = characterFontData->smallCapsFontData(m_fontDescription);
457     if (characterFontData) {
458         // Got the fallback glyph and font.
459         GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData, pageNumber)->page();
460         const GlyphData& data = fallbackPage && fallbackPage->glyphDataForCharacter(c).fontData ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
461         // Cache it so we don't have to do system fallback again next time.
462         if (!useSmallCapsFont)
463             page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
464         return data;
465     }
466
467     // Even system fallback can fail; use the missing glyph in that case.
468     // FIXME: It would be nicer to use the missing glyph from the last resort font instead.
469     const GlyphData& data = primaryFont()->missingGlyphData();
470     if (!useSmallCapsFont)
471         page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
472     return data;
473 }
474
475 const FontData* Font::primaryFont() const
476 {
477     ASSERT(m_fontList);
478     return m_fontList->primaryFont(this);
479 }
480
481 const FontData* Font::fontDataAt(unsigned index) const
482 {
483     ASSERT(m_fontList);
484     return m_fontList->fontDataAt(this, index);
485 }
486
487 const FontData* Font::fontDataForCharacters(const UChar* characters, int length) const
488 {
489     ASSERT(m_fontList);
490     return m_fontList->fontDataForCharacters(this, characters, length);
491 }
492
493 void Font::update(PassRefPtr<FontSelector> fontSelector) const
494 {
495     // FIXME: It is pretty crazy that we are willing to just poke into a RefPtr, but it ends up 
496     // being reasonably safe (because inherited fonts in the render tree pick up the new
497     // style anyway. Other copies are transient, e.g., the state in the GraphicsContext, and
498     // won't stick around long enough to get you in trouble). Still, this is pretty disgusting,
499     // and could eventually be rectified by using RefPtrs for Fonts themselves.
500     if (!m_fontList)
501         m_fontList = new FontFallbackList();
502     m_fontList->invalidate(fontSelector);
503     m_pageZero = 0;
504     m_pages.clear();
505 }
506
507 int Font::width(const TextRun& run) const
508 {
509     return lroundf(floatWidth(run));
510 }
511
512 int Font::ascent() const
513 {
514     return primaryFont()->ascent();
515 }
516
517 int Font::descent() const
518 {
519     return primaryFont()->descent();
520 }
521
522 int Font::lineSpacing() const
523 {
524     return primaryFont()->lineSpacing();
525 }
526
527 float Font::xHeight() const
528 {
529     return primaryFont()->xHeight();
530 }
531
532 unsigned Font::unitsPerEm() const
533 {
534     return primaryFont()->unitsPerEm();
535 }
536
537 int Font::spaceWidth() const
538 {
539     return (int)ceilf(primaryFont()->m_adjustedSpaceWidth + m_letterSpacing);
540 }
541
542 bool Font::isFixedPitch() const
543 {
544     ASSERT(m_fontList);
545     return m_fontList->isFixedPitch(this);
546 }
547
548 void Font::setCodePath(CodePath p)
549 {
550     codePath = p;
551 }
552
553 bool Font::canUseGlyphCache(const TextRun& run) const
554 {
555     switch (codePath) {
556         case Auto:
557             break;
558         case Simple:
559             return true;
560         case Complex:
561             return false;
562     }
563     
564     // Start from 0 since drawing and highlighting also measure the characters before run->from
565     for (int i = 0; i < run.length(); i++) {
566         const UChar c = run[i];
567         if (c < 0x300)      // U+0300 through U+036F Combining diacritical marks
568             continue;
569         if (c <= 0x36F)
570             return false;
571
572         if (c < 0x0591 || c == 0x05BE)     // U+0591 through U+05CF excluding U+05BE Hebrew combining marks, Hebrew punctuation Paseq, Sof Pasuq and Nun Hafukha
573             continue;
574         if (c <= 0x05CF)
575             return false;
576
577         if (c < 0x0600)     // U+0600 through U+1059 Arabic, Syriac, Thaana, Devanagari, Bengali, Gurmukhi, Gujarati, Oriya, Tamil, Telugu, Kannada, Malayalam, Sinhala, Thai, Lao, Tibetan, Myanmar
578             continue;
579         if (c <= 0x1059)
580             return false;
581
582         if (c < 0x1100)     // U+1100 through U+11FF Hangul Jamo (only Ancient Korean should be left here if you precompose; Modern Korean will be precomposed as a result of step A)
583             continue;
584         if (c <= 0x11FF)
585             return false;
586
587         if (c < 0x1780)     // U+1780 through U+18AF Khmer, Mongolian
588             continue;
589         if (c <= 0x18AF)
590             return false;
591
592         if (c < 0x1900)     // U+1900 through U+194F Limbu (Unicode 4.0)
593             continue;
594         if (c <= 0x194F)
595             return false;
596
597         if (c < 0x20D0)     // U+20D0 through U+20FF Combining marks for symbols
598             continue;
599         if (c <= 0x20FF)
600             return false;
601
602         if (c < 0xFE20)     // U+FE20 through U+FE2F Combining half marks
603             continue;
604         if (c <= 0xFE2F)
605             return false;
606     }
607
608     return true;
609
610 }
611
612 void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
613 {
614     // This glyph buffer holds our glyphs+advances+font data for each glyph.
615     GlyphBuffer glyphBuffer;
616
617     float startX = point.x();
618     WidthIterator it(this, run);
619     it.advance(from);
620     float beforeWidth = it.m_runWidthSoFar;
621     it.advance(to, &glyphBuffer);
622     
623     // We couldn't generate any glyphs for the run.  Give up.
624     if (glyphBuffer.isEmpty())
625         return;
626     
627     float afterWidth = it.m_runWidthSoFar;
628
629     if (run.rtl()) {
630         float finalRoundingWidth = it.m_finalRoundingWidth;
631         it.advance(run.length());
632         startX += finalRoundingWidth + it.m_runWidthSoFar - afterWidth;
633     } else
634         startX += beforeWidth;
635
636     // Swap the order of the glyphs if right-to-left.
637     if (run.rtl())
638         for (int i = 0, end = glyphBuffer.size() - 1; i < glyphBuffer.size() / 2; ++i, --end)
639             glyphBuffer.swap(i, end);
640
641     // Calculate the starting point of the glyphs to be displayed by adding
642     // all the advances up to the first glyph.
643     FloatPoint startPoint(startX, point.y());
644     drawGlyphBuffer(context, glyphBuffer, run, startPoint);
645 }
646
647 void Font::drawGlyphBuffer(GraphicsContext* context, const GlyphBuffer& glyphBuffer, 
648                            const TextRun& run, const FloatPoint& point) const
649 {   
650     // Draw each contiguous run of glyphs that use the same font data.
651     const FontData* fontData = glyphBuffer.fontDataAt(0);
652     FloatSize offset = glyphBuffer.offsetAt(0);
653     FloatPoint startPoint(point);
654     float nextX = startPoint.x();
655     int lastFrom = 0;
656     int nextGlyph = 0;
657     while (nextGlyph < glyphBuffer.size()) {
658         const FontData* nextFontData = glyphBuffer.fontDataAt(nextGlyph);
659         FloatSize nextOffset = glyphBuffer.offsetAt(nextGlyph);
660         if (nextFontData != fontData || nextOffset != offset) {
661             drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint);
662             lastFrom = nextGlyph;
663             fontData = nextFontData;
664             offset = nextOffset;
665             startPoint.setX(nextX);
666         }
667         nextX += glyphBuffer.advanceAt(nextGlyph);
668         nextGlyph++;
669     }
670     drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint);
671 }
672
673 void Font::drawText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
674 {
675     // Don't draw anything while we are using custom fonts that are in the process of loading.
676     if (m_fontList && m_fontList->loadingCustomFonts())
677         return;
678     
679     to = (to == -1 ? run.length() : to);
680     if (canUseGlyphCache(run))
681         drawSimpleText(context, run, point, from, to);
682     else
683         drawComplexText(context, run, point, from, to);
684 }
685
686 float Font::floatWidth(const TextRun& run) const
687 {
688     if (canUseGlyphCache(run))
689         return floatWidthForSimpleText(run, 0);
690     return floatWidthForComplexText(run);
691 }
692
693 float Font::floatWidthForSimpleText(const TextRun& run, GlyphBuffer* glyphBuffer) const
694 {
695     WidthIterator it(this, run);
696     it.advance(run.length(), glyphBuffer);
697     return it.m_runWidthSoFar;
698 }
699
700 FloatRect Font::selectionRectForText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
701 {
702     to = (to == -1 ? run.length() : to);
703     if (canUseGlyphCache(run))
704         return selectionRectForSimpleText(run, point, h, from, to);
705     return selectionRectForComplexText(run, point, h, from, to);
706 }
707
708 FloatRect Font::selectionRectForSimpleText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
709 {
710     WidthIterator it(this, run);
711     it.advance(from);
712     float beforeWidth = it.m_runWidthSoFar;
713     it.advance(to);
714     float afterWidth = it.m_runWidthSoFar;
715
716     // Using roundf() rather than ceilf() for the right edge as a compromise to ensure correct caret positioning
717     if (run.rtl()) {
718         it.advance(run.length());
719         float totalWidth = it.m_runWidthSoFar;
720         return FloatRect(point.x() + floorf(totalWidth - afterWidth), point.y(), roundf(totalWidth - beforeWidth) - floorf(totalWidth - afterWidth), h);
721     } else {
722         return FloatRect(point.x() + floorf(beforeWidth), point.y(), roundf(afterWidth) - floorf(beforeWidth), h);
723     }
724 }
725
726 int Font::offsetForPosition(const TextRun& run, int x, bool includePartialGlyphs) const
727 {
728     if (canUseGlyphCache(run))
729         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
730     return offsetForPositionForComplexText(run, x, includePartialGlyphs);
731 }
732
733 int Font::offsetForPositionForSimpleText(const TextRun& run, int x, bool includePartialGlyphs) const
734 {
735     float delta = (float)x;
736
737     WidthIterator it(this, run);
738     GlyphBuffer localGlyphBuffer;
739     unsigned offset;
740     if (run.rtl()) {
741         delta -= floatWidthForSimpleText(run, 0);
742         while (1) {
743             offset = it.m_currentCharacter;
744             float w;
745             if (!it.advanceOneCharacter(w, &localGlyphBuffer))
746                 break;
747             delta += w;
748             if (includePartialGlyphs) {
749                 if (delta - w / 2 >= 0)
750                     break;
751             } else {
752                 if (delta >= 0)
753                     break;
754             }
755         }
756     } else {
757         while (1) {
758             offset = it.m_currentCharacter;
759             float w;
760             if (!it.advanceOneCharacter(w, &localGlyphBuffer))
761                 break;
762             delta -= w;
763             if (includePartialGlyphs) {
764                 if (delta + w / 2 <= 0)
765                     break;
766             } else {
767                 if (delta <= 0)
768                     break;
769             }
770         }
771     }
772
773     return offset;
774 }
775
776 }