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 }