WebCore:
[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 const GlyphData& Font::glyphDataForCharacter(UChar32 c, bool mirror, bool forceSmallCaps) const
349 {
350     bool useSmallCapsFont = forceSmallCaps;
351     if (m_fontDescription.smallCaps()) {
352         UChar32 upperC = Unicode::toUpper(c);
353         if (upperC != c) {
354             c = upperC;
355             useSmallCapsFont = true;
356         }
357     }
358
359     if (mirror)
360         c = mirroredChar(c);
361
362     unsigned pageNumber = (c / GlyphPage::size);
363
364     GlyphPageTreeNode* node = pageNumber ? m_pages.get(pageNumber) : m_pageZero;
365     if (!node) {
366         node = GlyphPageTreeNode::getRootChild(primaryFont(), pageNumber);
367         if (pageNumber)
368             m_pages.set(pageNumber, node);
369         else
370             m_pageZero = node;
371     }
372
373     GlyphPage* page;
374     if (!useSmallCapsFont) {
375         // Fastest loop, for the common case (not small caps).
376         while (true) {
377             page = node->page();
378             if (page) {
379                 const GlyphData& data = page->glyphDataForCharacter(c);
380                 if (data.fontData)
381                     return data;
382                 if (node->isSystemFallback())
383                     break;
384             }
385
386             // Proceed with the fallback list.
387             node = node->getChild(fontDataAt(node->level()), pageNumber);
388             if (pageNumber)
389                 m_pages.set(pageNumber, node);
390             else
391                 m_pageZero = node;
392         }
393     } else {
394         while (true) {
395             page = node->page();
396             if (page) {
397                 const GlyphData& data = page->glyphDataForCharacter(c);
398                 if (data.fontData) {
399                     // The smallCapsFontData function should not normally return 0.
400                     // But if it does, we will just render the capital letter big.
401                     const FontData* smallCapsFontData = data.fontData->smallCapsFontData(m_fontDescription);
402                     if (!smallCapsFontData)
403                         return data;
404
405                     GlyphPageTreeNode* smallCapsNode = GlyphPageTreeNode::getRootChild(smallCapsFontData, pageNumber);
406                     const GlyphData& data = smallCapsNode->page()->glyphDataForCharacter(c);
407                     if (data.fontData)
408                         return data;
409
410                     // Do not attempt system fallback off the smallCapsFontData. This is the very unlikely case that
411                     // a font has the lowercase character but the small caps font does not have its uppercase version.
412                     return smallCapsFontData->missingGlyphData();
413                 }
414
415                 if (node->isSystemFallback())
416                     break;
417             }
418
419             // Proceed with the fallback list.
420             node = node->getChild(fontDataAt(node->level()), pageNumber);
421             if (pageNumber)
422                 m_pages.set(pageNumber, node);
423             else
424                 m_pageZero = node;
425         }
426     }
427
428     ASSERT(page);
429     ASSERT(node->isSystemFallback());
430
431     // System fallback is character-dependent. When we get here, we
432     // know that the character in question isn't in the system fallback
433     // font's glyph page. Try to lazily create it here.
434     UChar codeUnits[2];
435     int codeUnitsLength;
436     if (c <= 0xFFFF) {
437         UChar c16 = c;
438         if (Font::treatAsSpace(c16))
439             codeUnits[0] = ' ';
440         else if (Font::treatAsZeroWidthSpace(c16))
441             codeUnits[0] = zeroWidthSpace;
442         else
443             codeUnits[0] = c16;
444         codeUnitsLength = 1;
445     } else {
446         codeUnits[0] = U16_LEAD(c);
447         codeUnits[1] = U16_TRAIL(c);
448         codeUnitsLength = 2;
449     }
450     const FontData* characterFontData = FontCache::getFontDataForCharacters(*this, codeUnits, codeUnitsLength);
451     if (useSmallCapsFont)
452         characterFontData = characterFontData->smallCapsFontData(m_fontDescription);
453     if (characterFontData) {
454         // Got the fallback glyph and font.
455         GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData, pageNumber)->page();
456         const GlyphData& data = fallbackPage && fallbackPage->glyphDataForCharacter(c).fontData ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
457         // Cache it so we don't have to do system fallback again next time.
458         if (!useSmallCapsFont)
459             page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
460         return data;
461     }
462
463     // Even system fallback can fail; use the missing glyph in that case.
464     // FIXME: It would be nicer to use the missing glyph from the last resort font instead.
465     const GlyphData& data = primaryFont()->missingGlyphData();
466     if (!useSmallCapsFont)
467         page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
468     return data;
469 }
470
471 const FontData* Font::primaryFont() const
472 {
473     ASSERT(m_fontList);
474     return m_fontList->primaryFont(this);
475 }
476
477 const FontData* Font::fontDataAt(unsigned index) const
478 {
479     ASSERT(m_fontList);
480     return m_fontList->fontDataAt(this, index);
481 }
482
483 const FontData* Font::fontDataForCharacters(const UChar* characters, int length) const
484 {
485     ASSERT(m_fontList);
486     return m_fontList->fontDataForCharacters(this, characters, length);
487 }
488
489 void Font::update(PassRefPtr<FontSelector> fontSelector) const
490 {
491     // FIXME: It is pretty crazy that we are willing to just poke into a RefPtr, but it ends up 
492     // being reasonably safe (because inherited fonts in the render tree pick up the new
493     // style anyway. Other copies are transient, e.g., the state in the GraphicsContext, and
494     // won't stick around long enough to get you in trouble). Still, this is pretty disgusting,
495     // and could eventually be rectified by using RefPtrs for Fonts themselves.
496     if (!m_fontList)
497         m_fontList = new FontFallbackList();
498     m_fontList->invalidate(fontSelector);
499     m_pageZero = 0;
500     m_pages.clear();
501 }
502
503 int Font::width(const TextRun& run) const
504 {
505     return lroundf(floatWidth(run));
506 }
507
508 int Font::ascent() const
509 {
510     return primaryFont()->ascent();
511 }
512
513 int Font::descent() const
514 {
515     return primaryFont()->descent();
516 }
517
518 int Font::lineSpacing() const
519 {
520     return primaryFont()->lineSpacing();
521 }
522
523 float Font::xHeight() const
524 {
525     return primaryFont()->xHeight();
526 }
527
528 unsigned Font::unitsPerEm() const
529 {
530     return primaryFont()->unitsPerEm();
531 }
532
533 int Font::spaceWidth() const
534 {
535     return (int)ceilf(primaryFont()->m_adjustedSpaceWidth + m_letterSpacing);
536 }
537
538 bool Font::isFixedPitch() const
539 {
540     ASSERT(m_fontList);
541     return m_fontList->isFixedPitch(this);
542 }
543
544 void Font::setCodePath(CodePath p)
545 {
546     codePath = p;
547 }
548
549 bool Font::canUseGlyphCache(const TextRun& run) const
550 {
551     switch (codePath) {
552         case Auto:
553             break;
554         case Simple:
555             return true;
556         case Complex:
557             return false;
558     }
559     
560     // Start from 0 since drawing and highlighting also measure the characters before run->from
561     for (int i = 0; i < run.length(); i++) {
562         const UChar c = run[i];
563         if (c < 0x300)      // U+0300 through U+036F Combining diacritical marks
564             continue;
565         if (c <= 0x36F)
566             return false;
567
568         if (c < 0x0591 || c == 0x05BE)     // U+0591 through U+05CF excluding U+05BE Hebrew combining marks, Hebrew punctuation Paseq, Sof Pasuq and Nun Hafukha
569             continue;
570         if (c <= 0x05CF)
571             return false;
572
573         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
574             continue;
575         if (c <= 0x1059)
576             return false;
577
578         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)
579             continue;
580         if (c <= 0x11FF)
581             return false;
582
583         if (c < 0x1780)     // U+1780 through U+18AF Khmer, Mongolian
584             continue;
585         if (c <= 0x18AF)
586             return false;
587
588         if (c < 0x1900)     // U+1900 through U+194F Limbu (Unicode 4.0)
589             continue;
590         if (c <= 0x194F)
591             return false;
592
593         if (c < 0x20D0)     // U+20D0 through U+20FF Combining marks for symbols
594             continue;
595         if (c <= 0x20FF)
596             return false;
597
598         if (c < 0xFE20)     // U+FE20 through U+FE2F Combining half marks
599             continue;
600         if (c <= 0xFE2F)
601             return false;
602     }
603
604     return true;
605
606 }
607
608 void Font::drawSimpleText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
609 {
610     // This glyph buffer holds our glyphs+advances+font data for each glyph.
611     GlyphBuffer glyphBuffer;
612
613     float startX = point.x();
614     WidthIterator it(this, run);
615     it.advance(from);
616     float beforeWidth = it.m_runWidthSoFar;
617     it.advance(to, &glyphBuffer);
618     
619     // We couldn't generate any glyphs for the run.  Give up.
620     if (glyphBuffer.isEmpty())
621         return;
622     
623     float afterWidth = it.m_runWidthSoFar;
624
625     if (run.rtl()) {
626         float finalRoundingWidth = it.m_finalRoundingWidth;
627         it.advance(run.length());
628         startX += finalRoundingWidth + it.m_runWidthSoFar - afterWidth;
629     } else
630         startX += beforeWidth;
631
632     // Swap the order of the glyphs if right-to-left.
633     if (run.rtl())
634         for (int i = 0, end = glyphBuffer.size() - 1; i < glyphBuffer.size() / 2; ++i, --end)
635             glyphBuffer.swap(i, end);
636
637     // Calculate the starting point of the glyphs to be displayed by adding
638     // all the advances up to the first glyph.
639     FloatPoint startPoint(startX, point.y());
640     drawGlyphBuffer(context, glyphBuffer, run, startPoint);
641 }
642
643 void Font::drawGlyphBuffer(GraphicsContext* context, const GlyphBuffer& glyphBuffer, 
644                            const TextRun& run, const FloatPoint& point) const
645 {   
646     // Draw each contiguous run of glyphs that use the same font data.
647     const FontData* fontData = glyphBuffer.fontDataAt(0);
648     FloatSize offset = glyphBuffer.offsetAt(0);
649     FloatPoint startPoint(point);
650     float nextX = startPoint.x();
651     int lastFrom = 0;
652     int nextGlyph = 0;
653     while (nextGlyph < glyphBuffer.size()) {
654         const FontData* nextFontData = glyphBuffer.fontDataAt(nextGlyph);
655         FloatSize nextOffset = glyphBuffer.offsetAt(nextGlyph);
656         if (nextFontData != fontData || nextOffset != offset) {
657             drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint);
658             lastFrom = nextGlyph;
659             fontData = nextFontData;
660             offset = nextOffset;
661             startPoint.setX(nextX);
662         }
663         nextX += glyphBuffer.advanceAt(nextGlyph);
664         nextGlyph++;
665     }
666     drawGlyphs(context, fontData, glyphBuffer, lastFrom, nextGlyph - lastFrom, startPoint);
667 }
668
669 void Font::drawText(GraphicsContext* context, const TextRun& run, const FloatPoint& point, int from, int to) const
670 {
671     // Don't draw anything while we are using custom fonts that are in the process of loading.
672     if (m_fontList && m_fontList->loadingCustomFonts())
673         return;
674     
675     to = (to == -1 ? run.length() : to);
676     if (canUseGlyphCache(run))
677         drawSimpleText(context, run, point, from, to);
678     else
679         drawComplexText(context, run, point, from, to);
680 }
681
682 float Font::floatWidth(const TextRun& run) const
683 {
684     if (canUseGlyphCache(run))
685         return floatWidthForSimpleText(run, 0);
686     return floatWidthForComplexText(run);
687 }
688
689 float Font::floatWidthForSimpleText(const TextRun& run, GlyphBuffer* glyphBuffer) const
690 {
691     WidthIterator it(this, run);
692     it.advance(run.length(), glyphBuffer);
693     return it.m_runWidthSoFar;
694 }
695
696 FloatRect Font::selectionRectForText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
697 {
698     to = (to == -1 ? run.length() : to);
699     if (canUseGlyphCache(run))
700         return selectionRectForSimpleText(run, point, h, from, to);
701     return selectionRectForComplexText(run, point, h, from, to);
702 }
703
704 FloatRect Font::selectionRectForSimpleText(const TextRun& run, const IntPoint& point, int h, int from, int to) const
705 {
706     WidthIterator it(this, run);
707     it.advance(from);
708     float beforeWidth = it.m_runWidthSoFar;
709     it.advance(to);
710     float afterWidth = it.m_runWidthSoFar;
711
712     // Using roundf() rather than ceilf() for the right edge as a compromise to ensure correct caret positioning
713     if (run.rtl()) {
714         it.advance(run.length());
715         float totalWidth = it.m_runWidthSoFar;
716         return FloatRect(point.x() + floorf(totalWidth - afterWidth), point.y(), roundf(totalWidth - beforeWidth) - floorf(totalWidth - afterWidth), h);
717     } else {
718         return FloatRect(point.x() + floorf(beforeWidth), point.y(), roundf(afterWidth) - floorf(beforeWidth), h);
719     }
720 }
721
722 int Font::offsetForPosition(const TextRun& run, int x, bool includePartialGlyphs) const
723 {
724     if (canUseGlyphCache(run))
725         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
726     return offsetForPositionForComplexText(run, x, includePartialGlyphs);
727 }
728
729 int Font::offsetForPositionForSimpleText(const TextRun& run, int x, bool includePartialGlyphs) const
730 {
731     float delta = (float)x;
732
733     WidthIterator it(this, run);
734     GlyphBuffer localGlyphBuffer;
735     unsigned offset;
736     if (run.rtl()) {
737         delta -= floatWidthForSimpleText(run, 0);
738         while (1) {
739             offset = it.m_currentCharacter;
740             float w;
741             if (!it.advanceOneCharacter(w, &localGlyphBuffer))
742                 break;
743             delta += w;
744             if (includePartialGlyphs) {
745                 if (delta - w / 2 >= 0)
746                     break;
747             } else {
748                 if (delta >= 0)
749                     break;
750             }
751         }
752     } else {
753         while (1) {
754             offset = it.m_currentCharacter;
755             float w;
756             if (!it.advanceOneCharacter(w, &localGlyphBuffer))
757                 break;
758             delta -= w;
759             if (includePartialGlyphs) {
760                 if (delta + w / 2 <= 0)
761                     break;
762             } else {
763                 if (delta <= 0)
764                     break;
765             }
766         }
767     }
768
769     return offset;
770 }
771
772 }