src/third_party/WebKit/Source/platform/fonts/mac/ComplexTextController.cpp

   1 /*
   2  * Copyright (C) 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include "config.h"
  26 #include "platform/fonts/mac/ComplexTextController.h"
  27
  28 #include "platform/fonts/Character.h"
  29 #include "platform/fonts/Font.h"
  30 #include "platform/fonts/GlyphBuffer.h"
  31 #include "platform/geometry/FloatSize.h"
  32 #include "platform/text/TextBreakIterator.h"
  33 #include "platform/text/TextRun.h"
  34 #include "wtf/StdLibExtras.h"
  35 #include "wtf/unicode/CharacterNames.h"
  36 #include <ApplicationServices/ApplicationServices.h>
  37
  38 using namespace std;
  39
  40 namespace WebCore {
  41
  42 static inline CGFloat roundCGFloat(CGFloat f)
  43 {
  44     if (sizeof(CGFloat) == sizeof(float))
  45         return roundf(static_cast<float>(f));
  46     return static_cast<CGFloat>(round(f));
  47 }
  48
  49 static inline CGFloat ceilCGFloat(CGFloat f)
  50 {
  51     if (sizeof(CGFloat) == sizeof(float))
  52         return ceilf(static_cast<float>(f));
  53     return static_cast<CGFloat>(ceil(f));
  54 }
  55
  56 ComplexTextController::ComplexTextController(const Font* font, const TextRun& run, bool mayUseNaturalWritingDirection, HashSet<const SimpleFontData*>* fallbackFonts, bool forTextEmphasis)
  57     : m_font(*font)
  58     , m_run(run)
  59     , m_isLTROnly(true)
  60     , m_mayUseNaturalWritingDirection(mayUseNaturalWritingDirection)
  61     , m_forTextEmphasis(forTextEmphasis)
  62     , m_currentCharacter(0)
  63     , m_end(run.length())
  64     , m_totalWidth(0)
  65     , m_runWidthSoFar(0)
  66     , m_numGlyphsSoFar(0)
  67     , m_currentRun(0)
  68     , m_glyphInCurrentRun(0)
  69     , m_characterInCurrentGlyph(0)
  70     , m_finalRoundingWidth(0)
  71     , m_expansion(run.expansion())
  72     , m_leadingExpansion(0)
  73     , m_afterExpansion(!run.allowsLeadingExpansion())
  74     , m_fallbackFonts(fallbackFonts)
  75     , m_minGlyphBoundingBoxX(numeric_limits<float>::max())
  76     , m_maxGlyphBoundingBoxX(numeric_limits<float>::min())
  77     , m_minGlyphBoundingBoxY(numeric_limits<float>::max())
  78     , m_maxGlyphBoundingBoxY(numeric_limits<float>::min())
  79     , m_lastRoundingGlyph(0)
  80 {
  81     if (!m_expansion)
  82         m_expansionPerOpportunity = 0;
  83     else {
  84         bool isAfterExpansion = m_afterExpansion;
  85         unsigned expansionOpportunityCount;
  86         if (m_run.is8Bit())
  87             expansionOpportunityCount = Character::expansionOpportunityCount(m_run.characters8(), m_end, m_run.direction(), isAfterExpansion);
  88          else
  89             expansionOpportunityCount = Character::expansionOpportunityCount(m_run.characters16(), m_end, m_run.direction(), isAfterExpansion);
  90         if (isAfterExpansion && !m_run.allowsTrailingExpansion())
  91             expansionOpportunityCount--;
  92
  93         if (!expansionOpportunityCount)
  94             m_expansionPerOpportunity = 0;
  95         else
  96             m_expansionPerOpportunity = m_expansion / expansionOpportunityCount;
  97     }
  98
  99     collectComplexTextRuns();
 100     adjustGlyphsAndAdvances();
 101
 102     if (!m_isLTROnly) {
 103         m_runIndices.reserveInitialCapacity(m_complexTextRuns.size());
 104
 105         m_glyphCountFromStartToIndex.reserveInitialCapacity(m_complexTextRuns.size());
 106         unsigned glyphCountSoFar = 0;
 107         for (unsigned i = 0; i < m_complexTextRuns.size(); ++i) {
 108             m_glyphCountFromStartToIndex.uncheckedAppend(glyphCountSoFar);
 109             glyphCountSoFar += m_complexTextRuns[i]->glyphCount();
 110         }
 111     }
 112
 113     m_runWidthSoFar = m_leadingExpansion;
 114 }
 115
 116 int ComplexTextController::offsetForPosition(float h, bool includePartialGlyphs)
 117 {
 118     if (h >= m_totalWidth)
 119         return m_run.ltr() ? m_end : 0;
 120
 121     h -= m_leadingExpansion;
 122     if (h < 0)
 123         return m_run.ltr() ? 0 : m_end;
 124
 125     CGFloat x = h;
 126
 127     size_t runCount = m_complexTextRuns.size();
 128     size_t offsetIntoAdjustedGlyphs = 0;
 129
 130     for (size_t r = 0; r < runCount; ++r) {
 131         const ComplexTextRun& complexTextRun = *m_complexTextRuns[r];
 132         for (unsigned j = 0; j < complexTextRun.glyphCount(); ++j) {
 133             CGFloat adjustedAdvance = m_adjustedAdvances[offsetIntoAdjustedGlyphs + j].width;
 134             if (x < adjustedAdvance) {
 135                 CFIndex hitGlyphStart = complexTextRun.indexAt(j);
 136                 CFIndex hitGlyphEnd;
 137                 if (m_run.ltr())
 138                     hitGlyphEnd = max<CFIndex>(hitGlyphStart, j + 1 < complexTextRun.glyphCount() ? complexTextRun.indexAt(j + 1) : static_cast<CFIndex>(complexTextRun.indexEnd()));
 139                 else
 140                     hitGlyphEnd = max<CFIndex>(hitGlyphStart, j > 0 ? complexTextRun.indexAt(j - 1) : static_cast<CFIndex>(complexTextRun.indexEnd()));
 141
 142                 // FIXME: Instead of dividing the glyph's advance equally between the characters, this
 143                 // could use the glyph's "ligature carets". However, there is no Core Text API to get the
 144                 // ligature carets.
 145                 CFIndex hitIndex = hitGlyphStart + (hitGlyphEnd - hitGlyphStart) * (m_run.ltr() ? x / adjustedAdvance : 1 - x / adjustedAdvance);
 146                 int stringLength = complexTextRun.stringLength();
 147                 TextBreakIterator* cursorPositionIterator = cursorMovementIterator(complexTextRun.characters(), stringLength);
 148                 int clusterStart;
 149                 if (cursorPositionIterator->isBoundary(hitIndex))
 150                     clusterStart = hitIndex;
 151                 else {
 152                     clusterStart = cursorPositionIterator->preceding(hitIndex);
 153                     if (clusterStart == TextBreakDone)
 154                         clusterStart = 0;
 155                 }
 156
 157                 if (!includePartialGlyphs)
 158                     return complexTextRun.stringLocation() + clusterStart;
 159
 160                 int clusterEnd = cursorPositionIterator->following(hitIndex);
 161                 if (clusterEnd == TextBreakDone)
 162                     clusterEnd = stringLength;
 163
 164                 CGFloat clusterWidth;
 165                 // FIXME: The search stops at the boundaries of complexTextRun. In theory, it should go on into neighboring ComplexTextRuns
 166                 // derived from the same CTLine. In practice, we do not expect there to be more than one CTRun in a CTLine, as no
 167                 // reordering and no font fallback should occur within a CTLine.
 168                 if (clusterEnd - clusterStart > 1) {
 169                     clusterWidth = adjustedAdvance;
 170                     int firstGlyphBeforeCluster = j - 1;
 171                     while (firstGlyphBeforeCluster >= 0 && complexTextRun.indexAt(firstGlyphBeforeCluster) >= clusterStart && complexTextRun.indexAt(firstGlyphBeforeCluster) < clusterEnd) {
 172                         CGFloat width = m_adjustedAdvances[offsetIntoAdjustedGlyphs + firstGlyphBeforeCluster].width;
 173                         clusterWidth += width;
 174                         x += width;
 175                         firstGlyphBeforeCluster--;
 176                     }
 177                     unsigned firstGlyphAfterCluster = j + 1;
 178                     while (firstGlyphAfterCluster < complexTextRun.glyphCount() && complexTextRun.indexAt(firstGlyphAfterCluster) >= clusterStart && complexTextRun.indexAt(firstGlyphAfterCluster) < clusterEnd) {
 179                         clusterWidth += m_adjustedAdvances[offsetIntoAdjustedGlyphs + firstGlyphAfterCluster].width;
 180                         firstGlyphAfterCluster++;
 181                     }
 182                 } else {
 183                     clusterWidth = adjustedAdvance / (hitGlyphEnd - hitGlyphStart);
 184                     x -=  clusterWidth * (m_run.ltr() ? hitIndex - hitGlyphStart : hitGlyphEnd - hitIndex - 1);
 185                 }
 186                 if (x <= clusterWidth / 2)
 187                     return complexTextRun.stringLocation() + (m_run.ltr() ? clusterStart : clusterEnd);
 188                 else
 189                     return complexTextRun.stringLocation() + (m_run.ltr() ? clusterEnd : clusterStart);
 190             }
 191             x -= adjustedAdvance;
 192         }
 193         offsetIntoAdjustedGlyphs += complexTextRun.glyphCount();
 194     }
 195
 196     ASSERT_NOT_REACHED();
 197     return 0;
 198 }
 199
 200 static bool advanceByCombiningCharacterSequence(const UChar*& iterator, const UChar* end, UChar32& baseCharacter, unsigned& markCount)
 201 {
 202     ASSERT(iterator < end);
 203
 204     markCount = 0;
 205
 206     baseCharacter = *iterator++;
 207
 208     if (U16_IS_SURROGATE(baseCharacter)) {
 209         if (!U16_IS_LEAD(baseCharacter))
 210             return false;
 211         if (iterator == end)
 212             return false;
 213         UChar trail = *iterator++;
 214         if (!U16_IS_TRAIL(trail))
 215             return false;
 216         baseCharacter = U16_GET_SUPPLEMENTARY(baseCharacter, trail);
 217     }
 218
 219     // Consume marks.
 220     while (iterator < end) {
 221         UChar32 nextCharacter;
 222         int markLength = 0;
 223         U16_NEXT(iterator, markLength, end - iterator, nextCharacter);
 224         if (!(U_GET_GC_MASK(nextCharacter) & U_GC_M_MASK))
 225             break;
 226         markCount += markLength;
 227         iterator += markLength;
 228     }
 229
 230     return true;
 231 }
 232
 233 void ComplexTextController::collectComplexTextRuns()
 234 {
 235     if (!m_end)
 236         return;
 237
 238     // We break up glyph run generation for the string by FontData.
 239     const UChar* cp;
 240
 241     if (m_run.is8Bit()) {
 242         String stringFor8BitRun = String::make16BitFrom8BitSource(m_run.characters8(), m_run.length());
 243         cp = stringFor8BitRun.characters16();
 244         m_stringsFor8BitRuns.append(stringFor8BitRun);
 245     } else
 246         cp = m_run.characters16();
 247
 248     if (m_font.fontDescription().variant() == FontVariantSmallCaps)
 249         m_smallCapsBuffer.resize(m_end);
 250
 251     unsigned indexOfFontTransition = 0;
 252     const UChar* curr = cp;
 253     const UChar* end = cp + m_end;
 254
 255     const SimpleFontData* fontData;
 256     bool isMissingGlyph;
 257     const SimpleFontData* nextFontData;
 258     bool nextIsMissingGlyph;
 259
 260     unsigned markCount;
 261     const UChar* sequenceStart = curr;
 262     UChar32 baseCharacter;
 263     if (!advanceByCombiningCharacterSequence(curr, end, baseCharacter, markCount))
 264         return;
 265
 266     UChar uppercaseCharacter = 0;
 267
 268     bool isSmallCaps;
 269     bool nextIsSmallCaps = m_font.fontDescription().variant() == FontVariantSmallCaps && !(U_GET_GC_MASK(baseCharacter) & U_GC_M_MASK) && (uppercaseCharacter = u_toupper(baseCharacter)) != baseCharacter;
 270
 271     if (nextIsSmallCaps) {
 272         m_smallCapsBuffer[sequenceStart - cp] = uppercaseCharacter;
 273         for (unsigned i = 0; i < markCount; ++i)
 274             m_smallCapsBuffer[sequenceStart - cp + i + 1] = sequenceStart[i + 1];
 275     }
 276
 277     nextIsMissingGlyph = false;
 278     nextFontData = m_font.fontDataForCombiningCharacterSequence(sequenceStart, curr - sequenceStart, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
 279     if (!nextFontData)
 280         nextIsMissingGlyph = true;
 281
 282     while (curr < end) {
 283         fontData = nextFontData;
 284         isMissingGlyph = nextIsMissingGlyph;
 285         isSmallCaps = nextIsSmallCaps;
 286         int index = curr - cp;
 287
 288         if (!advanceByCombiningCharacterSequence(curr, end, baseCharacter, markCount))
 289             return;
 290
 291         if (m_font.fontDescription().variant()) {
 292             nextIsSmallCaps = (uppercaseCharacter = u_toupper(baseCharacter)) != baseCharacter;
 293             if (nextIsSmallCaps) {
 294                 m_smallCapsBuffer[index] = uppercaseCharacter;
 295                 for (unsigned i = 0; i < markCount; ++i)
 296                     m_smallCapsBuffer[index + i + 1] = cp[index + i + 1];
 297             }
 298         }
 299
 300         nextIsMissingGlyph = false;
 301         if (baseCharacter == zeroWidthJoiner)
 302             nextFontData = fontData;
 303         else {
 304             nextFontData = m_font.fontDataForCombiningCharacterSequence(cp + index, curr - cp - index, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
 305             if (!nextFontData)
 306                 nextIsMissingGlyph = true;
 307         }
 308
 309         if (nextFontData != fontData || nextIsMissingGlyph != isMissingGlyph) {
 310             int itemStart = static_cast<int>(indexOfFontTransition);
 311             int itemLength = index - indexOfFontTransition;
 312             collectComplexTextRunsForCharacters((isSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !isMissingGlyph ? fontData : 0);
 313             indexOfFontTransition = index;
 314         }
 315     }
 316
 317     int itemLength = m_end - indexOfFontTransition;
 318     if (itemLength) {
 319         int itemStart = indexOfFontTransition;
 320         collectComplexTextRunsForCharacters((nextIsSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !nextIsMissingGlyph ? nextFontData : 0);
 321     }
 322
 323     if (!m_run.ltr())
 324         m_complexTextRuns.reverse();
 325 }
 326
 327 CFIndex ComplexTextController::ComplexTextRun::indexAt(size_t i) const
 328 {
 329     return m_coreTextIndices[i];
 330 }
 331
 332 void ComplexTextController::ComplexTextRun::setIsNonMonotonic()
 333 {
 334     ASSERT(m_isMonotonic);
 335     m_isMonotonic = false;
 336
 337     Vector<bool, 64> mappedIndices(m_stringLength);
 338     for (size_t i = 0; i < m_glyphCount; ++i) {
 339         ASSERT(indexAt(i) < static_cast<CFIndex>(m_stringLength));
 340         mappedIndices[indexAt(i)] = true;
 341     }
 342
 343     m_glyphEndOffsets.grow(m_glyphCount);
 344     for (size_t i = 0; i < m_glyphCount; ++i) {
 345         CFIndex nextMappedIndex = m_indexEnd;
 346         for (size_t j = indexAt(i) + 1; j < m_stringLength; ++j) {
 347             if (mappedIndices[j]) {
 348                 nextMappedIndex = j;
 349                 break;
 350             }
 351         }
 352         m_glyphEndOffsets[i] = nextMappedIndex;
 353     }
 354 }
 355
 356 unsigned ComplexTextController::findNextRunIndex(unsigned runIndex) const
 357 {
 358     const unsigned runOffset = stringEnd(*m_complexTextRuns[runIndex]);
 359
 360     // Finds the run with the lowest stringBegin() offset that starts at or
 361     // after |runOffset|.
 362     //
 363     // Note that this can't just find a run whose stringBegin() equals the
 364     // stringEnd() of the previous run because CoreText on Mac OS X 10.6 does
 365     // not return runs covering BiDi control chars, so this has to handle the
 366     // resulting gaps.
 367     unsigned result = 0;
 368     unsigned lowestOffset = UINT_MAX;
 369     for (unsigned i = 0; i < m_complexTextRuns.size(); ++i) {
 370         unsigned offset = stringBegin(*m_complexTextRuns[i]);
 371         if (i != runIndex && offset >= runOffset && offset < lowestOffset) {
 372             lowestOffset = offset;
 373             result = i;
 374         }
 375     }
 376
 377     ASSERT(lowestOffset != UINT_MAX);
 378     return result;
 379 }
 380
 381 unsigned ComplexTextController::indexOfCurrentRun(unsigned& leftmostGlyph)
 382 {
 383     leftmostGlyph = 0;
 384
 385     size_t runCount = m_complexTextRuns.size();
 386     if (m_currentRun >= runCount)
 387         return runCount;
 388
 389     if (m_isLTROnly) {
 390         for (unsigned i = 0; i < m_currentRun; ++i)
 391             leftmostGlyph += m_complexTextRuns[i]->glyphCount();
 392         return m_currentRun;
 393     }
 394
 395     if (m_runIndices.isEmpty()) {
 396         unsigned firstRun = 0;
 397         unsigned firstRunOffset = stringBegin(*m_complexTextRuns[0]);
 398         for (unsigned i = 1; i < runCount; ++i) {
 399             unsigned offset = stringBegin(*m_complexTextRuns[i]);
 400             if (offset < firstRunOffset) {
 401                 firstRun = i;
 402                 firstRunOffset = offset;
 403             }
 404         }
 405         m_runIndices.uncheckedAppend(firstRun);
 406     }
 407
 408     while (m_runIndices.size() <= m_currentRun) {
 409         m_runIndices.uncheckedAppend(findNextRunIndex(m_runIndices.last()));
 410     }
 411
 412     unsigned currentRunIndex = m_runIndices[m_currentRun];
 413     leftmostGlyph = m_glyphCountFromStartToIndex[currentRunIndex];
 414     return currentRunIndex;
 415 }
 416
 417 unsigned ComplexTextController::incrementCurrentRun(unsigned& leftmostGlyph)
 418 {
 419     if (m_isLTROnly) {
 420         leftmostGlyph += m_complexTextRuns[m_currentRun++]->glyphCount();
 421         return m_currentRun;
 422     }
 423
 424     m_currentRun++;
 425     leftmostGlyph = 0;
 426     return indexOfCurrentRun(leftmostGlyph);
 427 }
 428
 429 void ComplexTextController::advance(unsigned offset, GlyphBuffer* glyphBuffer, GlyphIterationStyle iterationStyle, HashSet<const SimpleFontData*>* fallbackFonts)
 430 {
 431     if (static_cast<int>(offset) > m_end)
 432         offset = m_end;
 433
 434     if (offset <= m_currentCharacter) {
 435         m_runWidthSoFar = m_leadingExpansion;
 436         m_numGlyphsSoFar = 0;
 437         m_currentRun = 0;
 438         m_glyphInCurrentRun = 0;
 439         m_characterInCurrentGlyph = 0;
 440     }
 441
 442     m_currentCharacter = offset;
 443
 444     size_t runCount = m_complexTextRuns.size();
 445
 446     unsigned leftmostGlyph = 0;
 447     unsigned currentRunIndex = indexOfCurrentRun(leftmostGlyph);
 448     while (m_currentRun < runCount) {
 449         const ComplexTextRun& complexTextRun = *m_complexTextRuns[currentRunIndex];
 450         bool ltr = complexTextRun.isLTR();
 451         size_t glyphCount = complexTextRun.glyphCount();
 452         unsigned g = ltr ? m_glyphInCurrentRun : glyphCount - 1 - m_glyphInCurrentRun;
 453         unsigned k = leftmostGlyph + g;
 454         if (fallbackFonts && complexTextRun.fontData() != m_font.primaryFont())
 455             fallbackFonts->add(complexTextRun.fontData());
 456
 457         while (m_glyphInCurrentRun < glyphCount) {
 458             unsigned glyphStartOffset = complexTextRun.indexAt(g);
 459             unsigned glyphEndOffset;
 460             if (complexTextRun.isMonotonic()) {
 461                 if (ltr)
 462                     glyphEndOffset = max<unsigned>(glyphStartOffset, static_cast<unsigned>(g + 1 < glyphCount ? complexTextRun.indexAt(g + 1) : complexTextRun.indexEnd()));
 463                 else
 464                     glyphEndOffset = max<unsigned>(glyphStartOffset, static_cast<unsigned>(g > 0 ? complexTextRun.indexAt(g - 1) : complexTextRun.indexEnd()));
 465             } else
 466                 glyphEndOffset = complexTextRun.endOffsetAt(g);
 467
 468             CGSize adjustedAdvance = m_adjustedAdvances[k];
 469
 470             if (glyphStartOffset + complexTextRun.stringLocation() >= m_currentCharacter)
 471                 return;
 472
 473             if (glyphBuffer && !m_characterInCurrentGlyph)
 474                 glyphBuffer->add(m_adjustedGlyphs[k], complexTextRun.fontData(), FloatSize(adjustedAdvance));
 475
 476             unsigned oldCharacterInCurrentGlyph = m_characterInCurrentGlyph;
 477             m_characterInCurrentGlyph = min(m_currentCharacter - complexTextRun.stringLocation(), glyphEndOffset) - glyphStartOffset;
 478             // FIXME: Instead of dividing the glyph's advance equally between the characters, this
 479             // could use the glyph's "ligature carets". However, there is no Core Text API to get the
 480             // ligature carets.
 481             if (glyphStartOffset == glyphEndOffset) {
 482                 // When there are multiple glyphs per character we need to advance by the full width of the glyph.
 483                 ASSERT(m_characterInCurrentGlyph == oldCharacterInCurrentGlyph);
 484                 m_runWidthSoFar += adjustedAdvance.width;
 485             } else if (iterationStyle == ByWholeGlyphs) {
 486                 if (!oldCharacterInCurrentGlyph)
 487                     m_runWidthSoFar += adjustedAdvance.width;
 488             } else
 489                 m_runWidthSoFar += adjustedAdvance.width * (m_characterInCurrentGlyph - oldCharacterInCurrentGlyph) / (glyphEndOffset - glyphStartOffset);
 490
 491             if (glyphEndOffset + complexTextRun.stringLocation() > m_currentCharacter)
 492                 return;
 493
 494             m_numGlyphsSoFar++;
 495             m_glyphInCurrentRun++;
 496             m_characterInCurrentGlyph = 0;
 497             if (ltr) {
 498                 g++;
 499                 k++;
 500             } else {
 501                 g--;
 502                 k--;
 503             }
 504         }
 505         currentRunIndex = incrementCurrentRun(leftmostGlyph);
 506         m_glyphInCurrentRun = 0;
 507     }
 508     if (!m_run.ltr() && m_numGlyphsSoFar == m_adjustedAdvances.size())
 509         m_runWidthSoFar += m_finalRoundingWidth;
 510 }
 511
 512 void ComplexTextController::adjustGlyphsAndAdvances()
 513 {
 514     CGFloat widthSinceLastCommit = 0;
 515     size_t runCount = m_complexTextRuns.size();
 516     bool hasExtraSpacing = (m_font.fontDescription().letterSpacing() || m_font.fontDescription().wordSpacing() || m_expansion) && !m_run.spacingDisabled();
 517     for (size_t r = 0; r < runCount; ++r) {
 518         ComplexTextRun& complexTextRun = *m_complexTextRuns[r];
 519         unsigned glyphCount = complexTextRun.glyphCount();
 520         const SimpleFontData* fontData = complexTextRun.fontData();
 521
 522         if (!complexTextRun.isLTR())
 523             m_isLTROnly = false;
 524
 525         const CGGlyph* glyphs = complexTextRun.glyphs();
 526         const CGSize* advances = complexTextRun.advances();
 527
 528         bool lastRun = r + 1 == runCount;
 529         bool roundsAdvances = fontData->platformData().roundsGlyphAdvances();
 530         float spaceWidth = fontData->spaceWidth() - fontData->syntheticBoldOffset();
 531         CGFloat roundedSpaceWidth = roundCGFloat(spaceWidth);
 532         const UChar* cp = complexTextRun.characters();
 533         CGPoint glyphOrigin = CGPointZero;
 534         CFIndex lastCharacterIndex = m_run.ltr() ? numeric_limits<CFIndex>::min() : numeric_limits<CFIndex>::max();
 535         bool isMonotonic = true;
 536
 537         for (unsigned i = 0; i < glyphCount; i++) {
 538             CFIndex characterIndex = complexTextRun.indexAt(i);
 539             if (m_run.ltr()) {
 540                 if (characterIndex < lastCharacterIndex)
 541                     isMonotonic = false;
 542             } else {
 543                 if (characterIndex > lastCharacterIndex)
 544                     isMonotonic = false;
 545             }
 546             UChar ch = *(cp + characterIndex);
 547             bool lastGlyph = lastRun && i + 1 == glyphCount;
 548             UChar nextCh;
 549             if (lastGlyph)
 550                 nextCh = ' ';
 551             else if (i + 1 < glyphCount)
 552                 nextCh = *(cp + complexTextRun.indexAt(i + 1));
 553             else
 554                 nextCh = *(m_complexTextRuns[r + 1]->characters() + m_complexTextRuns[r + 1]->indexAt(0));
 555
 556             bool treatAsSpace = Character::treatAsSpace(ch);
 557             CGGlyph glyph = treatAsSpace ? fontData->spaceGlyph() : glyphs[i];
 558             CGSize advance = treatAsSpace ? CGSizeMake(spaceWidth, advances[i].height) : advances[i];
 559
 560             if (ch == '\t' && m_run.allowTabs()) {
 561                 advance.width = m_font.tabWidth(*fontData, m_run.tabSize(), m_run.xPos() + m_totalWidth + widthSinceLastCommit);
 562             } else if (Character::treatAsZeroWidthSpace(ch) && !treatAsSpace) {
 563                 advance.width = 0;
 564                 glyph = fontData->spaceGlyph();
 565             }
 566
 567             float roundedAdvanceWidth = roundf(advance.width);
 568             if (roundsAdvances)
 569                 advance.width = roundedAdvanceWidth;
 570
 571             advance.width += fontData->syntheticBoldOffset();
 572
 573
 574             // We special case spaces in two ways when applying word rounding.
 575             // First, we round spaces to an adjusted width in all fonts.
 576             // Second, in fixed-pitch fonts we ensure that all glyphs that
 577             // match the width of the space glyph have the same width as the space glyph.
 578             if (m_run.applyWordRounding() && roundedAdvanceWidth == roundedSpaceWidth && (fontData->pitch() == FixedPitch || glyph == fontData->spaceGlyph()))
 579                 advance.width = fontData->adjustedSpaceWidth();
 580
 581             if (hasExtraSpacing) {
 582                 // If we're a glyph with an advance, go ahead and add in letter-spacing.
 583                 // That way we weed out zero width lurkers.  This behavior matches the fast text code path.
 584                 if (advance.width && m_font.fontDescription().letterSpacing())
 585                     advance.width += m_font.fontDescription().letterSpacing();
 586
 587                 // Handle justification and word-spacing.
 588                 if (treatAsSpace || Character::isCJKIdeographOrSymbol(ch)) {
 589                     // Distribute the run's total expansion evenly over all expansion opportunities in the run.
 590                     if (m_expansion) {
 591                         float previousExpansion = m_expansion;
 592                         if (!treatAsSpace && !m_afterExpansion) {
 593                             // Take the expansion opportunity before this ideograph.
 594                             m_expansion -= m_expansionPerOpportunity;
 595                             float expansionAtThisOpportunity = !m_run.applyWordRounding() ? m_expansionPerOpportunity : roundf(previousExpansion) - roundf(m_expansion);
 596                             m_totalWidth += expansionAtThisOpportunity;
 597                             if (m_adjustedAdvances.isEmpty())
 598                                 m_leadingExpansion = expansionAtThisOpportunity;
 599                             else
 600                                 m_adjustedAdvances.last().width += expansionAtThisOpportunity;
 601                             previousExpansion = m_expansion;
 602                         }
 603                         if (!lastGlyph || m_run.allowsTrailingExpansion()) {
 604                             m_expansion -= m_expansionPerOpportunity;
 605                             advance.width += !m_run.applyWordRounding() ? m_expansionPerOpportunity : roundf(previousExpansion) - roundf(m_expansion);
 606                             m_afterExpansion = true;
 607                         }
 608                     } else
 609                         m_afterExpansion = false;
 610
 611                     // Account for word-spacing.
 612                     if (treatAsSpace && (ch != '\t' || !m_run.allowTabs()) && (characterIndex > 0 || r > 0) && m_font.fontDescription().wordSpacing())
 613                         advance.width += m_font.fontDescription().wordSpacing();
 614                 } else
 615                     m_afterExpansion = false;
 616             }
 617
 618             // Apply rounding hacks if needed.
 619             // We adjust the width of the last character of a "word" to ensure an integer width.
 620             // Force characters that are used to determine word boundaries for the rounding hack
 621             // to be integer width, so the following words will start on an integer boundary.
 622             if (m_run.applyWordRounding() && Character::isRoundingHackCharacter(ch))
 623                 advance.width = ceilCGFloat(advance.width);
 624
 625             // Check to see if the next character is a "rounding hack character", if so, adjust the
 626             // width so that the total run width will be on an integer boundary.
 627             if ((m_run.applyWordRounding() && !lastGlyph && Character::isRoundingHackCharacter(nextCh)) || (m_run.applyRunRounding() && lastGlyph)) {
 628                 CGFloat totalWidth = widthSinceLastCommit + advance.width;
 629                 widthSinceLastCommit = ceilCGFloat(totalWidth);
 630                 CGFloat extraWidth = widthSinceLastCommit - totalWidth;
 631                 if (m_run.ltr())
 632                     advance.width += extraWidth;
 633                 else {
 634                     if (m_lastRoundingGlyph)
 635                         m_adjustedAdvances[m_lastRoundingGlyph - 1].width += extraWidth;
 636                     else
 637                         m_finalRoundingWidth = extraWidth;
 638                     m_lastRoundingGlyph = m_adjustedAdvances.size() + 1;
 639                 }
 640                 m_totalWidth += widthSinceLastCommit;
 641                 widthSinceLastCommit = 0;
 642             } else
 643                 widthSinceLastCommit += advance.width;
 644
 645             // FIXME: Combining marks should receive a text emphasis mark if they are combine with a space.
 646             if (m_forTextEmphasis && (!Character::canReceiveTextEmphasis(ch) || (U_GET_GC_MASK(ch) & U_GC_M_MASK)))
 647                 glyph = 0;
 648
 649             advance.height *= -1;
 650             m_adjustedAdvances.append(advance);
 651             m_adjustedGlyphs.append(glyph);
 652
 653             FloatRect glyphBounds = fontData->boundsForGlyph(glyph);
 654             glyphBounds.move(glyphOrigin.x, glyphOrigin.y);
 655             m_minGlyphBoundingBoxX = min(m_minGlyphBoundingBoxX, glyphBounds.x());
 656             m_maxGlyphBoundingBoxX = max(m_maxGlyphBoundingBoxX, glyphBounds.maxX());
 657             m_minGlyphBoundingBoxY = min(m_minGlyphBoundingBoxY, glyphBounds.y());
 658             m_maxGlyphBoundingBoxY = max(m_maxGlyphBoundingBoxY, glyphBounds.maxY());
 659             glyphOrigin.x += advance.width;
 660             glyphOrigin.y += advance.height;
 661
 662             lastCharacterIndex = characterIndex;
 663         }
 664         if (!isMonotonic)
 665             complexTextRun.setIsNonMonotonic();
 666     }
 667     m_totalWidth += widthSinceLastCommit;
 668 }
 669
 670 } // namespace WebCore