icuSources/layoutex/ParagraphLayout.cpp

   1 /*
   2  **********************************************************************
   3  *   Copyright (C) 2002-2010, International Business Machines
   4  *   Corporation and others.  All Rights Reserved.
   5  **********************************************************************
   6  */
   7
   8 /*
   9  * paragraphLayout doesn't make much sense without
  10  * BreakIterator...
  11  */
  12 #include "layout/LETypes.h"
  13 #include "layout/LEScripts.h"
  14 #include "layout/LELanguages.h"
  15 #include "layout/LayoutEngine.h"
  16 #include "layout/LEFontInstance.h"
  17
  18 #include "unicode/ubidi.h"
  19 #include "unicode/uchriter.h"
  20 #include "unicode/brkiter.h"
  21
  22 #if ! UCONFIG_NO_BREAK_ITERATION
  23 #include "LXUtilities.h"
  24 #include "usc_impl.h" /* this is currently private! */
  25 #include "cstring.h"  /* this too! */
  26
  27 #include "layout/ParagraphLayout.h"
  28
  29 U_NAMESPACE_BEGIN
  30
  31 #define ARRAY_SIZE(array) (sizeof array  / sizeof array[0])
  32
  33 /* Leave this copyright notice here! It needs to go somewhere in this library. */
  34 static const char copyright[] = U_COPYRIGHT_STRING;
  35
  36 class StyleRuns
  37 {
  38 public:
  39     StyleRuns(const RunArray *styleRunArrays[], le_int32 styleCount);
  40
  41     ~StyleRuns();
  42
  43     le_int32 getRuns(le_int32 runLimits[], le_int32 styleIndices[]);
  44
  45 private:
  46     le_int32 fStyleCount;
  47     le_int32 fRunCount;
  48
  49     le_int32 *fRunLimits;
  50     le_int32 *fStyleIndices;
  51 };
  52
  53 StyleRuns::StyleRuns(const RunArray *styleRunArrays[], le_int32 styleCount)
  54     : fStyleCount(styleCount), fRunCount(0), fRunLimits(NULL), fStyleIndices(NULL)
  55 {
  56     le_int32 maxRunCount = 0;
  57     le_int32 style, run, runStyle;
  58     le_int32 *currentRun = LE_NEW_ARRAY(le_int32, styleCount);
  59
  60     for (int i = 0; i < styleCount; i += 1) {
  61         maxRunCount += styleRunArrays[i]->getCount();
  62     }
  63
  64     maxRunCount -= styleCount - 1;
  65
  66     fRunLimits    = LE_NEW_ARRAY(le_int32, maxRunCount);
  67     fStyleIndices = LE_NEW_ARRAY(le_int32, maxRunCount * styleCount);
  68
  69     for (style = 0; style < styleCount; style += 1) {
  70         currentRun[style] = 0;
  71     }
  72
  73     run = 0;
  74     runStyle = 0;
  75
  76     /*
  77      * Since the last run limit for each style run must be
  78      * the same, all the styles will hit the last limit at
  79      * the same time, so we know when we're done when the first
  80      * style hits the last limit.
  81      */
  82     while (currentRun[0] < styleRunArrays[0]->getCount()) {
  83         fRunLimits[run] = 0x7FFFFFFF;
  84
  85         // find the minimum run limit for all the styles
  86         for (style = 0; style < styleCount; style += 1) {
  87             if (styleRunArrays[style]->getLimit(currentRun[style]) < fRunLimits[run]) {
  88                 fRunLimits[run] = styleRunArrays[style]->getLimit(currentRun[style]);
  89             }
  90         }
  91
  92         // advance all styles whose current run is at this limit to the next run
  93         for (style = 0; style < styleCount; style += 1) {
  94             fStyleIndices[runStyle++] = currentRun[style];
  95
  96             if (styleRunArrays[style]->getLimit(currentRun[style]) == fRunLimits[run]) {
  97                 currentRun[style] += 1;
  98             }
  99         }
 100
 101         run += 1;
 102     }
 103
 104     fRunCount = run;
 105     LE_DELETE_ARRAY(currentRun);
 106 }
 107
 108 StyleRuns::~StyleRuns()
 109 {
 110     fRunCount = 0;
 111
 112     LE_DELETE_ARRAY(fStyleIndices);
 113     fStyleIndices = NULL;
 114
 115     LE_DELETE_ARRAY(fRunLimits);
 116     fRunLimits = NULL;
 117 }
 118
 119 le_int32 StyleRuns::getRuns(le_int32 runLimits[], le_int32 styleIndices[])
 120 {
 121     if (runLimits != NULL) {
 122         LE_ARRAY_COPY(runLimits, fRunLimits, fRunCount);
 123     }
 124
 125     if (styleIndices != NULL) {
 126         LE_ARRAY_COPY(styleIndices, fStyleIndices, fRunCount * fStyleCount);
 127     }
 128
 129     return fRunCount;
 130 }
 131
 132 /*
 133  * NOTE: This table only has "TRUE" values for
 134  * those scripts which the LayoutEngine can currently
 135  * process, rather for all scripts which require
 136  * complex processing for correct rendering.
 137  */
 138 static const le_bool complexTable[scriptCodeCount] = {
 139     FALSE , /* Zyyy */
 140     FALSE,  /* Qaai */
 141     TRUE,   /* Arab */
 142     FALSE,  /* Armn */
 143     TRUE,   /* Beng */
 144     FALSE,  /* Bopo */
 145     FALSE,  /* Cher */
 146     FALSE,  /* Copt=Qaac */
 147     FALSE,  /* Cyrl */
 148     FALSE,  /* Dsrt */
 149     TRUE,   /* Deva */
 150     FALSE,  /* Ethi */
 151     FALSE,  /* Geor */
 152     FALSE,  /* Goth */
 153     FALSE,  /* Grek */
 154     TRUE,   /* Gujr */
 155     TRUE,   /* Guru */
 156     FALSE,  /* Hani */
 157     FALSE,  /* Hang */
 158     TRUE,   /* Hebr */
 159     FALSE,  /* Hira */
 160     TRUE,   /* Knda */
 161     FALSE,  /* Kana */
 162     FALSE,  /* Khmr */
 163     FALSE,  /* Laoo */
 164     FALSE,  /* Latn */
 165     TRUE,   /* Mlym */
 166     FALSE,  /* Mong */
 167     FALSE,  /* Mymr */
 168     FALSE,  /* Ogam */
 169     FALSE,  /* Ital */
 170     TRUE,   /* Orya */
 171     FALSE,  /* Runr */
 172     FALSE,  /* Sinh */
 173     FALSE,  /* Syrc */
 174     TRUE,   /* Taml */
 175     TRUE,   /* Telu */
 176     FALSE,  /* Thaa */
 177     TRUE,   /* Thai */
 178     FALSE,  /* Tibt */
 179     FALSE,  /* Cans */
 180     FALSE,  /* Yiii */
 181     FALSE,  /* Tglg */
 182     FALSE,  /* Hano */
 183     FALSE,  /* Buhd */
 184     FALSE,  /* Tagb */
 185     FALSE,  /* Brai */
 186     FALSE,  /* Cprt */
 187     FALSE,  /* Limb */
 188     FALSE,  /* Linb */
 189     FALSE,  /* Osma */
 190     FALSE,  /* Shaw */
 191     FALSE,  /* Tale */
 192     FALSE,  /* Ugar */
 193     FALSE,  /* Hrkt */
 194     FALSE,  /* Bugi */
 195     FALSE,  /* Glag */
 196     FALSE,  /* Khar */
 197     FALSE,  /* Sylo */
 198     FALSE,  /* Talu */
 199     FALSE,  /* Tfng */
 200     FALSE,  /* Xpeo */
 201     FALSE,  /* Bali */
 202     FALSE,  /* Batk */
 203     FALSE,  /* Blis */
 204     FALSE,  /* Brah */
 205     FALSE,  /* Cham */
 206     FALSE,  /* Cirt */
 207     FALSE,  /* Cyrs */
 208     FALSE,  /* Egyd */
 209     FALSE,  /* Egyh */
 210     FALSE,  /* Egyp */
 211     FALSE,  /* Geok */
 212     FALSE,  /* Hans */
 213     FALSE,  /* Hant */
 214     FALSE,  /* Hmng */
 215     FALSE,  /* Hung */
 216     FALSE,  /* Inds */
 217     FALSE,  /* Java */
 218     FALSE,  /* Kali */
 219     FALSE,  /* Latf */
 220     FALSE,  /* Latg */
 221     FALSE,  /* Lepc */
 222     FALSE,  /* Lina */
 223     FALSE,  /* Mand */
 224     FALSE,  /* Maya */
 225     FALSE,  /* Mero */
 226     FALSE,  /* Nkoo */
 227     FALSE,  /* Orkh */
 228     FALSE,  /* Perm */
 229     FALSE,  /* Phag */
 230     FALSE,  /* Phnx */
 231     FALSE,  /* Plrd */
 232     FALSE,  /* Roro */
 233     FALSE,  /* Sara */
 234     FALSE,  /* Syre */
 235     FALSE,  /* Syrj */
 236     FALSE,  /* Syrn */
 237     FALSE,  /* Teng */
 238     FALSE,  /* Taii */
 239     FALSE,  /* Visp */
 240     FALSE,  /* Xsux */
 241     FALSE,  /* Zxxx */
 242     FALSE,  /* Zzzz */
 243     FALSE,  /* Cari */
 244     FALSE,  /* Jpan */
 245     FALSE,  /* Lana */
 246     FALSE,  /* Lyci */
 247     FALSE,  /* Lydi */
 248     FALSE,  /* Olck */
 249     FALSE,  /* Rjng */
 250     FALSE,  /* Saur */
 251     FALSE,  /* Sgnw */
 252     FALSE,  /* Sund */
 253     FALSE,  /* Moon */
 254     FALSE,  /* Mtei */
 255     FALSE,  /* Armi */
 256     FALSE,  /* Avst */
 257     FALSE,  /* Cakm */
 258     FALSE,  /* Kore */
 259     FALSE,  /* Kthi */
 260     FALSE,  /* Mani */
 261     FALSE,  /* Phli */
 262     FALSE,  /* Phlp */
 263     FALSE,  /* Phlv */
 264     FALSE,  /* Prti */
 265     FALSE,  /* Samr */
 266     FALSE,  /* Tavt */
 267     FALSE,  /* Zmth */
 268     FALSE,  /* Zsym */
 269     FALSE,  /* Bamu */
 270     FALSE,  /* Lisu */
 271     FALSE,  /* Nkgb */
 272     FALSE   /* Sarb */
 273 };
 274
 275
 276 const char ParagraphLayout::fgClassID = 0;
 277
 278 static void fillMissingCharToGlyphMapValues(le_int32 *charToGlyphMap,
 279                                             le_int32 charCount) {
 280     le_int32 lastValidGlyph = -1;
 281     le_int32 ch;
 282     for (ch = 0; ch <= charCount; ch += 1) {
 283         if (charToGlyphMap[ch] == -1) {
 284             charToGlyphMap[ch] = lastValidGlyph;
 285         } else {
 286             lastValidGlyph = charToGlyphMap[ch];
 287         }
 288     }
 289 }
 290
 291 /*
 292  * How to deal with composite fonts:
 293  *
 294  * Don't store the client's FontRuns; we'll need to compute sub-font FontRuns using Doug's
 295  * LEFontInstance method. Do that by intersecting the client's FontRuns with fScriptRuns. Use
 296  * that to compute fFontRuns, and then intersect fFontRuns, fScriptRuns and fLevelRuns. Doing
 297  * it in this order means we do a two-way intersection and a three-way intersection.
 298  *
 299  * An optimization would be to only do this if there's at least one composite font...
 300  *
 301  * Other notes:
 302  *
 303  * * Return the sub-fonts as the run fonts... could keep the mapping back to the client's FontRuns
 304  *   but that probably makes it more complicated of everyone...
 305  *
 306  * * Take the LineInfo and LineRun types from Paragraph and use them here, incorporate them into the API.
 307  *
 308  * * Might want to change the name of the StyleRun type, and make a new one that holds fonts, scripts and levels?
 309  *
 310  */
 311 ParagraphLayout::ParagraphLayout(const LEUnicode chars[], le_int32 count,
 312                                  const FontRuns   *fontRuns,
 313                                  const ValueRuns  *levelRuns,
 314                                  const ValueRuns  *scriptRuns,
 315                                  const LocaleRuns *localeRuns,
 316                                  UBiDiLevel paragraphLevel, le_bool vertical,
 317                                  LEErrorCode &status)
 318                                  : fChars(chars), fCharCount(count),
 319                                    fFontRuns(NULL), fLevelRuns(levelRuns), fScriptRuns(scriptRuns), fLocaleRuns(localeRuns),
 320                                    fVertical(vertical), fClientLevels(TRUE), fClientScripts(TRUE), fClientLocales(TRUE), fEmbeddingLevels(NULL),
 321                                    fAscent(0), fDescent(0), fLeading(0),
 322                                    fGlyphToCharMap(NULL), fCharToMinGlyphMap(NULL), fCharToMaxGlyphMap(NULL), fGlyphWidths(NULL), fGlyphCount(0),
 323                                    fParaBidi(NULL), fLineBidi(NULL),
 324                                    fStyleRunLimits(NULL), fStyleIndices(NULL), fStyleRunCount(0),
 325                                    fBreakIterator(NULL), fLineStart(-1), fLineEnd(0),
 326                                  /*fVisualRuns(NULL), fStyleRunInfo(NULL), fVisualRunCount(-1),
 327                                    fFirstVisualRun(-1), fLastVisualRun(-1),*/ fVisualRunLastX(0), fVisualRunLastY(0)
 328 {
 329
 330     if (LE_FAILURE(status)) {
 331         fCharCount = -1;
 332         return;
 333     }
 334
 335     // FIXME: should check the limit arrays for consistency...
 336
 337     computeLevels(paragraphLevel);
 338
 339     if (scriptRuns == NULL) {
 340         computeScripts();
 341     }
 342
 343     if (localeRuns == NULL) {
 344         computeLocales();
 345     }
 346
 347     computeSubFonts(fontRuns, status);
 348
 349     if (LE_FAILURE(status)) {
 350         //other stuff?
 351         fCharCount = -1;
 352         return;
 353     }
 354
 355     // now intersect the font, direction and script runs...
 356     const RunArray *styleRunArrays[] = {fFontRuns, fLevelRuns, fScriptRuns, fLocaleRuns};
 357     le_int32  styleCount = sizeof styleRunArrays / sizeof styleRunArrays[0];
 358     StyleRuns styleRuns(styleRunArrays, styleCount);
 359     LEErrorCode layoutStatus = LE_NO_ERROR;
 360
 361     fStyleRunCount = styleRuns.getRuns(NULL, NULL);
 362
 363     fStyleRunLimits = LE_NEW_ARRAY(le_int32, fStyleRunCount);
 364     fStyleIndices   = LE_NEW_ARRAY(le_int32, fStyleRunCount * styleCount);
 365     if ((fStyleRunLimits == NULL) || (fStyleIndices == NULL)) {
 366         status = LE_MEMORY_ALLOCATION_ERROR;
 367         return;
 368     }
 369
 370     styleRuns.getRuns(fStyleRunLimits, fStyleIndices);
 371
 372     // now build a LayoutEngine for each style run...
 373     le_int32 *styleIndices = fStyleIndices;
 374     le_int32 run, runStart;
 375
 376     fStyleRunInfo = LE_NEW_ARRAY(StyleRunInfo, fStyleRunCount);
 377     if (fStyleRunInfo == NULL) {
 378         status = LE_MEMORY_ALLOCATION_ERROR;
 379         return;
 380     }
 381     else {
 382         // initialize
 383         for (runStart = 0, run = 0; run < fStyleRunCount; run += 1) {
 384             fStyleRunInfo[run].font = NULL;
 385             fStyleRunInfo[run].runBase = 0;
 386             fStyleRunInfo[run].runLimit = 0;
 387             fStyleRunInfo[run].script = (UScriptCode)0;
 388             fStyleRunInfo[run].locale = NULL;
 389             fStyleRunInfo[run].level = 0;
 390             fStyleRunInfo[run].glyphBase = 0;
 391             fStyleRunInfo[run].engine = NULL;
 392             fStyleRunInfo[run].glyphCount = 0;
 393             fStyleRunInfo[run].glyphs = NULL;
 394             fStyleRunInfo[run].positions = NULL;
 395         }
 396     }
 397
 398     fGlyphCount = 0;
 399     for (runStart = 0, run = 0; run < fStyleRunCount; run += 1) {
 400         fStyleRunInfo[run].font      = fFontRuns->getFont(styleIndices[0]);
 401         fStyleRunInfo[run].runBase   = runStart;
 402         fStyleRunInfo[run].runLimit  = fStyleRunLimits[run];
 403         fStyleRunInfo[run].script    = (UScriptCode) fScriptRuns->getValue(styleIndices[2]);
 404         fStyleRunInfo[run].locale    = fLocaleRuns->getLocale(styleIndices[3]);
 405         fStyleRunInfo[run].level     = (UBiDiLevel) fLevelRuns->getValue(styleIndices[1]);
 406         fStyleRunInfo[run].glyphBase = fGlyphCount;
 407
 408         fStyleRunInfo[run].engine = LayoutEngine::layoutEngineFactory(fStyleRunInfo[run].font,
 409             fStyleRunInfo[run].script, getLanguageCode(fStyleRunInfo[run].locale), layoutStatus);
 410         if (LE_FAILURE(layoutStatus)) {
 411             status = layoutStatus;
 412             return;
 413         }
 414
 415         fStyleRunInfo[run].glyphCount = fStyleRunInfo[run].engine->layoutChars(fChars, runStart, fStyleRunLimits[run] - runStart, fCharCount,
 416             fStyleRunInfo[run].level & 1, 0, 0, layoutStatus);
 417         if (LE_FAILURE(layoutStatus)) {
 418             status = layoutStatus;
 419             return;
 420         }
 421
 422         runStart = fStyleRunLimits[run];
 423         styleIndices += styleCount;
 424         fGlyphCount += fStyleRunInfo[run].glyphCount;
 425     }
 426
 427     // Make big arrays for the glyph widths, glyph-to-char and char-to-glyph maps,
 428     // in logical order. (Both maps need an extra entry for the end of the text.)
 429     //
 430     // For each layout get the positions and convert them into glyph widths, in
 431     // logical order. Get the glyph-to-char mapping, offset by starting index in the
 432     // character array. Swap the glyph width and glyph-to-char arrays into logical order.
 433     // Finally, fill in the char-to-glyph mappings.
 434     fGlyphWidths       = LE_NEW_ARRAY(float, fGlyphCount);
 435     fGlyphToCharMap    = LE_NEW_ARRAY(le_int32, fGlyphCount + 1);
 436     fCharToMinGlyphMap = LE_NEW_ARRAY(le_int32, fCharCount + 1);
 437     fCharToMaxGlyphMap = LE_NEW_ARRAY(le_int32, fCharCount + 1);
 438     if ((fGlyphWidths == NULL) || (fGlyphToCharMap == NULL) ||
 439         (fCharToMinGlyphMap == NULL) || (fCharToMaxGlyphMap == NULL)) {
 440         status = LE_MEMORY_ALLOCATION_ERROR;
 441         return;
 442     }
 443
 444     le_int32 glyph;
 445
 446     for (runStart = 0, run = 0; run < fStyleRunCount; run += 1) {
 447         LayoutEngine *engine = fStyleRunInfo[run].engine;
 448         le_int32 glyphCount  = fStyleRunInfo[run].glyphCount;
 449         le_int32 glyphBase   = fStyleRunInfo[run].glyphBase;
 450
 451         fStyleRunInfo[run].glyphs = LE_NEW_ARRAY(LEGlyphID, glyphCount);
 452         fStyleRunInfo[run].positions = LE_NEW_ARRAY(float, glyphCount * 2 + 2);
 453         if ((fStyleRunInfo[run].glyphs == NULL) ||
 454             (fStyleRunInfo[run].positions == NULL)) {
 455             status = LE_MEMORY_ALLOCATION_ERROR;
 456             return;
 457         }
 458
 459         engine->getGlyphs(fStyleRunInfo[run].glyphs, layoutStatus);
 460         if (LE_FAILURE(layoutStatus)) {
 461             status = layoutStatus;
 462             return;
 463         }
 464
 465         engine->getGlyphPositions(fStyleRunInfo[run].positions, layoutStatus);
 466         if (LE_FAILURE(layoutStatus)) {
 467             status = layoutStatus;
 468             return;
 469         }
 470
 471         engine->getCharIndices(&fGlyphToCharMap[glyphBase], runStart, layoutStatus);
 472         if (LE_FAILURE(layoutStatus)) {
 473             status = layoutStatus;
 474             return;
 475         }
 476
 477         for (glyph = 0; glyph < glyphCount; glyph += 1) {
 478             fGlyphWidths[glyphBase + glyph] = fStyleRunInfo[run].positions[glyph * 2 + 2] - fStyleRunInfo[run].positions[glyph * 2];
 479         }
 480
 481         if ((fStyleRunInfo[run].level & 1) != 0) {
 482             LXUtilities::reverse(&fGlyphWidths[glyphBase], glyphCount);
 483             LXUtilities::reverse(&fGlyphToCharMap[glyphBase], glyphCount);
 484         }
 485
 486         runStart = fStyleRunLimits[run];
 487
 488         delete engine;
 489         fStyleRunInfo[run].engine = NULL;
 490     }
 491
 492     fGlyphToCharMap[fGlyphCount] = fCharCount;
 493
 494     // Initialize the char-to-glyph maps to -1 so that we can later figure out
 495     // whether any of the entries in the map aren't filled in below.
 496     le_int32 chIndex;
 497     for (chIndex = 0; chIndex <= fCharCount; chIndex += 1) {
 498         fCharToMinGlyphMap[chIndex] = -1;
 499         fCharToMaxGlyphMap[chIndex] = -1;
 500     }
 501
 502     for (glyph = fGlyphCount - 1; glyph >= 0; glyph -= 1) {
 503         le_int32 ch = fGlyphToCharMap[glyph];
 504
 505         fCharToMinGlyphMap[ch] = glyph;
 506     }
 507
 508     fCharToMinGlyphMap[fCharCount] = fGlyphCount;
 509
 510     for (glyph = 0; glyph < fGlyphCount; glyph += 1) {
 511         le_int32 ch = fGlyphToCharMap[glyph];
 512
 513         fCharToMaxGlyphMap[ch] = glyph;
 514     }
 515
 516     fCharToMaxGlyphMap[fCharCount] = fGlyphCount;
 517
 518     // Now fill in the missing values in the char-to-glyph maps.
 519     fillMissingCharToGlyphMapValues(fCharToMinGlyphMap, fCharCount);
 520     fillMissingCharToGlyphMapValues(fCharToMaxGlyphMap, fCharCount);
 521 }
 522
 523 ParagraphLayout::~ParagraphLayout()
 524 {
 525     delete (FontRuns *) fFontRuns;
 526
 527     if (! fClientLevels) {
 528         delete (ValueRuns *) fLevelRuns;
 529         fLevelRuns = NULL;
 530
 531         fClientLevels = TRUE;
 532     }
 533
 534     if (! fClientScripts) {
 535         delete (ValueRuns *) fScriptRuns;
 536         fScriptRuns = NULL;
 537
 538         fClientScripts = TRUE;
 539     }
 540
 541     if (! fClientLocales) {
 542         delete (LocaleRuns *) fLocaleRuns;
 543         fLocaleRuns = NULL;
 544
 545         fClientLocales = TRUE;
 546     }
 547
 548     if (fEmbeddingLevels != NULL) {
 549         LE_DELETE_ARRAY(fEmbeddingLevels);
 550         fEmbeddingLevels = NULL;
 551     }
 552
 553     if (fGlyphToCharMap != NULL) {
 554         LE_DELETE_ARRAY(fGlyphToCharMap);
 555         fGlyphToCharMap = NULL;
 556     }
 557
 558     if (fCharToMinGlyphMap != NULL) {
 559         LE_DELETE_ARRAY(fCharToMinGlyphMap);
 560         fCharToMinGlyphMap = NULL;
 561     }
 562
 563     if (fCharToMaxGlyphMap != NULL) {
 564         LE_DELETE_ARRAY(fCharToMaxGlyphMap);
 565         fCharToMaxGlyphMap = NULL;
 566     }
 567
 568     if (fGlyphWidths != NULL) {
 569         LE_DELETE_ARRAY(fGlyphWidths);
 570         fGlyphWidths = NULL;
 571     }
 572
 573     if (fParaBidi != NULL) {
 574         ubidi_close(fParaBidi);
 575         fParaBidi = NULL;
 576     }
 577
 578     if (fLineBidi != NULL) {
 579         ubidi_close(fLineBidi);
 580         fLineBidi = NULL;
 581     }
 582
 583     if (fStyleRunCount > 0) {
 584         le_int32 run;
 585
 586         LE_DELETE_ARRAY(fStyleRunLimits);
 587         LE_DELETE_ARRAY(fStyleIndices);
 588
 589         for (run = 0; run < fStyleRunCount; run += 1) {
 590             LE_DELETE_ARRAY(fStyleRunInfo[run].glyphs);
 591             LE_DELETE_ARRAY(fStyleRunInfo[run].positions);
 592
 593             fStyleRunInfo[run].glyphs    = NULL;
 594             fStyleRunInfo[run].positions = NULL;
 595         }
 596
 597         LE_DELETE_ARRAY(fStyleRunInfo);
 598
 599         fStyleRunLimits = NULL;
 600         fStyleIndices   = NULL;
 601         fStyleRunInfo        = NULL;
 602         fStyleRunCount  = 0;
 603     }
 604
 605     if (fBreakIterator != NULL) {
 606         delete fBreakIterator;
 607         fBreakIterator = NULL;
 608     }
 609 }
 610
 611
 612 le_bool ParagraphLayout::isComplex(const LEUnicode chars[], le_int32 count)
 613 {
 614     UErrorCode scriptStatus = U_ZERO_ERROR;
 615     UScriptCode scriptCode  = USCRIPT_INVALID_CODE;
 616     UScriptRun *sr = uscript_openRun(chars, count, &scriptStatus);
 617     le_bool result = FALSE;
 618
 619     while (uscript_nextRun(sr, NULL, NULL, &scriptCode)) {
 620         if (isComplex(scriptCode)) {
 621             result = TRUE;
 622             break;
 623         }
 624     }
 625
 626     uscript_closeRun(sr);
 627     return result;
 628 }
 629
 630 le_int32 ParagraphLayout::getAscent() const
 631 {
 632     if (fAscent <= 0 && fCharCount > 0) {
 633         ((ParagraphLayout *) this)->computeMetrics();
 634     }
 635
 636     return fAscent;
 637 }
 638
 639 le_int32 ParagraphLayout::getDescent() const
 640 {
 641     if (fAscent <= 0 && fCharCount > 0) {
 642         ((ParagraphLayout *) this)->computeMetrics();
 643     }
 644
 645     return fDescent;
 646 }
 647
 648 le_int32 ParagraphLayout::getLeading() const
 649 {
 650     if (fAscent <= 0 && fCharCount > 0) {
 651         ((ParagraphLayout *) this)->computeMetrics();
 652     }
 653
 654     return fLeading;
 655 }
 656
 657 le_bool ParagraphLayout::isDone() const
 658 {
 659     return fLineEnd >= fCharCount;
 660 }
 661
 662 ParagraphLayout::Line *ParagraphLayout::nextLine(float width)
 663 {
 664     if (isDone()) {
 665         return NULL;
 666     }
 667
 668     fLineStart = fLineEnd;
 669
 670     if (width > 0) {
 671         le_int32 glyph    = fCharToMinGlyphMap[fLineStart];
 672         float widthSoFar  = 0;
 673
 674         while (glyph < fGlyphCount && widthSoFar + fGlyphWidths[glyph] <= width) {
 675             widthSoFar += fGlyphWidths[glyph++];
 676         }
 677
 678         // If no glyphs fit on the line, force one to fit.
 679         //
 680         // (There shouldn't be any zero width glyphs at the
 681         // start of a line unless the paragraph consists of
 682         // only zero width glyphs, because otherwise the zero
 683         // width glyphs will have been included on the end of
 684         // the previous line...)
 685         if (widthSoFar == 0 && glyph < fGlyphCount) {
 686             glyph += 1;
 687         }
 688
 689         fLineEnd = previousBreak(fGlyphToCharMap[glyph]);
 690
 691         // If this break is at or before the last one,
 692         // find a glyph, starting at the one which didn't
 693         // fit, that produces a break after the last one.
 694         while (fLineEnd <= fLineStart) {
 695             fLineEnd = fGlyphToCharMap[glyph++];
 696         }
 697     } else {
 698         fLineEnd = fCharCount;
 699     }
 700
 701     return computeVisualRuns();
 702 }
 703
 704 void ParagraphLayout::computeLevels(UBiDiLevel paragraphLevel)
 705 {
 706     UErrorCode bidiStatus = U_ZERO_ERROR;
 707
 708     if (fLevelRuns != NULL) {
 709         le_int32 ch;
 710         le_int32 run;
 711
 712         fEmbeddingLevels = LE_NEW_ARRAY(UBiDiLevel, fCharCount);
 713
 714         for (ch = 0, run = 0; run < fLevelRuns->getCount(); run += 1) {
 715             UBiDiLevel runLevel = (UBiDiLevel) fLevelRuns->getValue(run) | UBIDI_LEVEL_OVERRIDE;
 716             le_int32   runLimit = fLevelRuns->getLimit(run);
 717
 718             while (ch < runLimit) {
 719                 fEmbeddingLevels[ch++] = runLevel;
 720             }
 721         }
 722     }
 723
 724     fParaBidi = ubidi_openSized(fCharCount, 0, &bidiStatus);
 725     ubidi_setPara(fParaBidi, fChars, fCharCount, paragraphLevel, fEmbeddingLevels, &bidiStatus);
 726
 727     if (fLevelRuns == NULL) {
 728         le_int32 levelRunCount = ubidi_countRuns(fParaBidi, &bidiStatus);
 729         ValueRuns *levelRuns = new ValueRuns(levelRunCount);
 730
 731         le_int32 logicalStart = 0;
 732         le_int32 run;
 733         le_int32 limit;
 734         UBiDiLevel level;
 735
 736         for (run = 0; run < levelRunCount; run += 1) {
 737             ubidi_getLogicalRun(fParaBidi, logicalStart, &limit, &level);
 738             levelRuns->add(level, limit);
 739             logicalStart = limit;
 740         }
 741
 742         fLevelRuns    = levelRuns;
 743         fClientLevels = FALSE;
 744     }
 745 }
 746
 747 void ParagraphLayout::computeScripts()
 748 {
 749     UErrorCode scriptStatus = U_ZERO_ERROR;
 750     UScriptRun *sr = uscript_openRun(fChars, fCharCount, &scriptStatus);
 751     ValueRuns  *scriptRuns = new ValueRuns(0);
 752     le_int32 limit;
 753     UScriptCode script;
 754
 755     while (uscript_nextRun(sr, NULL, &limit, &script)) {
 756         scriptRuns->add(script, limit);
 757     }
 758
 759     uscript_closeRun(sr);
 760
 761     fScriptRuns    = scriptRuns;
 762     fClientScripts = FALSE;
 763 }
 764
 765 void ParagraphLayout::computeLocales()
 766 {
 767     LocaleRuns *localeRuns = new LocaleRuns(0);
 768     const Locale *defaultLocale = &Locale::getDefault();
 769
 770     localeRuns->add(defaultLocale, fCharCount);
 771
 772     fLocaleRuns    = localeRuns;
 773     fClientLocales = FALSE;
 774 }
 775
 776 void ParagraphLayout::computeSubFonts(const FontRuns *fontRuns, LEErrorCode &status)
 777 {
 778     if (LE_FAILURE(status)) {
 779         return;
 780     }
 781
 782     const RunArray *styleRunArrays[] = {fontRuns, fScriptRuns};
 783     le_int32 styleCount = sizeof styleRunArrays / sizeof styleRunArrays[0];
 784     StyleRuns styleRuns(styleRunArrays, styleCount);
 785     le_int32 styleRunCount = styleRuns.getRuns(NULL, NULL);
 786     le_int32 *styleRunLimits = LE_NEW_ARRAY(le_int32, styleRunCount);
 787     le_int32 *styleIndices = LE_NEW_ARRAY(le_int32, styleRunCount * styleCount);
 788     FontRuns *subFontRuns  = new FontRuns(0);
 789     le_int32  run, offset, *si;
 790
 791     styleRuns.getRuns(styleRunLimits, styleIndices);
 792
 793     si = styleIndices;
 794     offset = 0;
 795
 796     for (run = 0; run < styleRunCount; run += 1) {
 797         const LEFontInstance *runFont = fontRuns->getFont(si[0]);
 798         le_int32 script = fScriptRuns->getValue(si[1]);
 799
 800         while (offset < styleRunLimits[run]) {
 801             const LEFontInstance *subFont = runFont->getSubFont(fChars, &offset, styleRunLimits[run], script, status);
 802
 803             if (LE_FAILURE(status)) {
 804                 delete subFontRuns;
 805                 goto cleanUp;
 806             }
 807
 808             subFontRuns->add(subFont, offset);
 809         }
 810
 811         si += styleCount;
 812     }
 813
 814     fFontRuns = subFontRuns;
 815
 816 cleanUp:
 817     LE_DELETE_ARRAY(styleIndices);
 818     LE_DELETE_ARRAY(styleRunLimits);
 819 }
 820
 821 void ParagraphLayout::computeMetrics()
 822 {
 823     le_int32 i, count = fFontRuns->getCount();
 824     le_int32 maxDL = 0;
 825
 826     for (i = 0; i < count; i += 1) {
 827         const LEFontInstance *font = fFontRuns->getFont(i);
 828         le_int32 ascent  = font->getAscent();
 829         le_int32 descent = font->getDescent();
 830         le_int32 leading = font->getLeading();
 831         le_int32 dl      = descent + leading;
 832
 833         if (ascent > fAscent) {
 834             fAscent = ascent;
 835         }
 836
 837         if (descent > fDescent) {
 838             fDescent = descent;
 839         }
 840
 841         if (leading > fLeading) {
 842             fLeading = leading;
 843         }
 844
 845         if (dl > maxDL) {
 846             maxDL = dl;
 847         }
 848     }
 849
 850     fLeading = maxDL - fDescent;
 851 }
 852
 853 #if 1
 854 struct LanguageMap
 855 {
 856     const char *localeCode;
 857     le_int32 languageCode;
 858 };
 859
 860 static const LanguageMap languageMap[] =
 861 {
 862     {"afr", afkLanguageCode}, // Afrikaans
 863     {"ara", araLanguageCode}, // Arabic
 864     {"asm", asmLanguageCode}, // Assamese
 865     {"bel", belLanguageCode}, // Belarussian
 866     {"ben", benLanguageCode}, // Bengali
 867     {"bod", tibLanguageCode}, // Tibetan
 868     {"bul", bgrLanguageCode}, // Bulgarian
 869     {"cat", catLanguageCode}, // Catalan
 870     {"ces", csyLanguageCode}, // Czech
 871     {"che", cheLanguageCode}, // Chechen
 872     {"cop", copLanguageCode}, // Coptic
 873     {"cym", welLanguageCode}, // Welsh
 874     {"dan", danLanguageCode}, // Danish
 875     {"deu", deuLanguageCode}, // German
 876     {"dzo", dznLanguageCode}, // Dzongkha
 877     {"ell", ellLanguageCode}, // Greek
 878     {"eng", engLanguageCode}, // English
 879     {"est", etiLanguageCode}, // Estonian
 880     {"eus", euqLanguageCode}, // Basque
 881     {"fas", farLanguageCode}, // Farsi
 882     {"fin", finLanguageCode}, // Finnish
 883     {"fra", fraLanguageCode}, // French
 884     {"gle", gaeLanguageCode}, // Irish Gaelic
 885     {"guj", gujLanguageCode}, // Gujarati
 886     {"hau", hauLanguageCode}, // Hausa
 887     {"heb", iwrLanguageCode}, // Hebrew
 888     {"hin", hinLanguageCode}, // Hindi
 889     {"hrv", hrvLanguageCode}, // Croatian
 890     {"hun", hunLanguageCode}, // Hungarian
 891     {"hye", hyeLanguageCode}, // Armenian
 892     {"ind", indLanguageCode}, // Indonesian
 893     {"ita", itaLanguageCode}, // Italian
 894     {"jpn", janLanguageCode}, // Japanese
 895     {"kan", kanLanguageCode}, // Kannada
 896     {"kas", kshLanguageCode}, // Kashmiri
 897     {"khm", khmLanguageCode}, // Khmer
 898     {"kok", kokLanguageCode}, // Konkani
 899     {"kor", korLanguageCode}, // Korean
 900 //  {"mal_XXX", malLanguageCode}, // Malayalam - Traditional
 901     {"mal", mlrLanguageCode}, // Malayalam - Reformed
 902     {"mar", marLanguageCode}, // Marathi
 903     {"mlt", mtsLanguageCode}, // Maltese
 904     {"mni", mniLanguageCode}, // Manipuri
 905     {"mon", mngLanguageCode}, // Mongolian
 906     {"nep", nepLanguageCode}, // Nepali
 907     {"ori", oriLanguageCode}, // Oriya
 908     {"pol", plkLanguageCode}, // Polish
 909     {"por", ptgLanguageCode}, // Portuguese
 910     {"pus", pasLanguageCode}, // Pashto
 911     {"ron", romLanguageCode}, // Romanian
 912     {"rus", rusLanguageCode}, // Russian
 913     {"san", sanLanguageCode}, // Sanskrit
 914     {"sin", snhLanguageCode}, // Sinhalese
 915     {"slk", skyLanguageCode}, // Slovak
 916     {"snd", sndLanguageCode}, // Sindhi
 917     {"slv", slvLanguageCode}, // Slovenian
 918     {"spa", espLanguageCode}, // Spanish
 919     {"sqi", sqiLanguageCode}, // Albanian
 920     {"srp", srbLanguageCode}, // Serbian
 921     {"swe", sveLanguageCode}, // Swedish
 922     {"syr", syrLanguageCode}, // Syriac
 923     {"tam", tamLanguageCode}, // Tamil
 924     {"tel", telLanguageCode}, // Telugu
 925     {"tha", thaLanguageCode}, // Thai
 926     {"tur", trkLanguageCode}, // Turkish
 927     {"urd", urdLanguageCode}, // Urdu
 928     {"yid", jiiLanguageCode}, // Yiddish
 929 //  {"zhp", zhpLanguageCode}, // Chinese - Phonetic
 930     {"zho", zhsLanguageCode}, // Chinese
 931     {"zho_CHN", zhsLanguageCode}, // Chinese - China
 932     {"zho_HKG", zhsLanguageCode}, // Chinese - Hong Kong
 933     {"zho_MAC", zhtLanguageCode}, // Chinese - Macao
 934     {"zho_SGP", zhsLanguageCode}, // Chinese - Singapore
 935     {"zho_TWN", zhtLanguageCode}  // Chinese - Taiwan
 936 };
 937
 938 static const le_int32 languageMapCount = ARRAY_SIZE(languageMap);
 939
 940 le_int32 ParagraphLayout::getLanguageCode(const Locale *locale)
 941 {
 942     char code[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 943     const char *language = locale->getISO3Language();
 944     const char *country  = locale->getISO3Country();
 945
 946     uprv_strcat(code, language);
 947
 948     if ((uprv_strcmp(language, "zho") == 0) && country != NULL) {
 949         uprv_strcat(code, "_");
 950         uprv_strcat(code, country);
 951     }
 952
 953     for (le_int32 i = 0; i < languageMapCount; i += 1) {
 954         if (uprv_strcmp(code, languageMap[i].localeCode) == 0) {
 955             return languageMap[i].languageCode;
 956         }
 957     }
 958
 959     return nullLanguageCode;
 960 }
 961 #else
 962
 963 // TODO - dummy implementation for right now...
 964 le_int32 ParagraphLayout::getLanguageCode(const Locale *locale)
 965 {
 966     return nullLanguageCode;
 967 }
 968 #endif
 969
 970 le_bool ParagraphLayout::isComplex(UScriptCode script)
 971 {
 972     if (script < 0 || script >= (UScriptCode) scriptCodeCount) {
 973         return FALSE;
 974     }
 975
 976     return complexTable[script];
 977 }
 978
 979 le_int32 ParagraphLayout::previousBreak(le_int32 charIndex)
 980 {
 981     // skip over any whitespace or control characters,
 982     // because they can hang in the margin.
 983     while (charIndex < fCharCount &&
 984            (u_isWhitespace(fChars[charIndex]) ||
 985             u_iscntrl(fChars[charIndex]))) {
 986         charIndex += 1;
 987     }
 988
 989     // Create the BreakIterator if we don't already have one
 990     if (fBreakIterator == NULL) {
 991         Locale thai("th");
 992         UCharCharacterIterator *iter = new UCharCharacterIterator(fChars, fCharCount);
 993         UErrorCode status = U_ZERO_ERROR;
 994
 995         fBreakIterator = BreakIterator::createLineInstance(thai, status);
 996         fBreakIterator->adoptText(iter);
 997     }
 998
 999     // return the break location that's at or before
1000     // the character we stopped on. Note: if we're
1001     // on a break, the "+ 1" will cause preceding to
1002     // back up to it.
1003     return fBreakIterator->preceding(charIndex + 1);
1004 }
1005
1006 ParagraphLayout::Line *ParagraphLayout::computeVisualRuns()
1007 {
1008     UErrorCode bidiStatus = U_ZERO_ERROR;
1009     le_int32 dirRunCount, visualRun;
1010
1011     fVisualRunLastX = 0;
1012     fVisualRunLastY = 0;
1013     fFirstVisualRun = getCharRun(fLineStart);
1014     fLastVisualRun  = getCharRun(fLineEnd - 1);
1015
1016     if (fLineBidi == NULL) {
1017         fLineBidi = ubidi_openSized(fCharCount, 0, &bidiStatus);
1018     }
1019
1020     ubidi_setLine(fParaBidi, fLineStart, fLineEnd, fLineBidi, &bidiStatus);
1021     dirRunCount = ubidi_countRuns(fLineBidi, &bidiStatus);
1022
1023     Line *line = new Line();
1024
1025     for (visualRun = 0; visualRun < dirRunCount; visualRun += 1) {
1026         le_int32 relStart, run, runLength;
1027         UBiDiDirection runDirection = ubidi_getVisualRun(fLineBidi, visualRun, &relStart, &runLength);
1028         le_int32 runStart = fLineStart + relStart;
1029         le_int32 runEnd   = runStart + runLength - 1;
1030         le_int32 firstRun = getCharRun(runStart);
1031         le_int32 lastRun  = getCharRun(runEnd);
1032         le_int32 startRun = (runDirection == UBIDI_LTR)? firstRun : lastRun;
1033         le_int32 stopRun  = (runDirection == UBIDI_LTR)? lastRun + 1 : firstRun - 1;
1034         le_int32 dir      = (runDirection == UBIDI_LTR)?  1 : -1;
1035
1036         for (run = startRun; run != stopRun; run += dir) {
1037             le_int32 firstChar = (run == firstRun)? runStart : fStyleRunInfo[run].runBase;
1038             le_int32 lastChar  = (run == lastRun)?  runEnd   : fStyleRunInfo[run].runLimit - 1;
1039
1040             appendRun(line, run, firstChar, lastChar);
1041         }
1042     }
1043
1044     return line;
1045 }
1046
1047 void ParagraphLayout::appendRun(ParagraphLayout::Line *line, le_int32 run, le_int32 firstChar, le_int32 lastChar)
1048 {
1049     le_int32 glyphBase = fStyleRunInfo[run].glyphBase;
1050     le_int32 inGlyph, outGlyph;
1051
1052     // Get the glyph indices for all the characters between firstChar and lastChar,
1053     // make the minimum one be leftGlyph and the maximum one be rightGlyph.
1054     // (need to do this to handle local reorderings like Indic left matras)
1055     le_int32 leftGlyph  = fGlyphCount;
1056     le_int32 rightGlyph = -1;
1057     le_int32 ch;
1058
1059     for (ch = firstChar; ch <= lastChar; ch += 1) {
1060         le_int32 minGlyph = fCharToMinGlyphMap[ch];
1061         le_int32 maxGlyph = fCharToMaxGlyphMap[ch];
1062
1063         if (minGlyph < leftGlyph) {
1064             leftGlyph = minGlyph;
1065         }
1066
1067         if (maxGlyph > rightGlyph) {
1068             rightGlyph = maxGlyph;
1069         }
1070     }
1071
1072     if ((fStyleRunInfo[run].level & 1) != 0) {
1073         le_int32 swap = rightGlyph;
1074         le_int32 last = glyphBase + fStyleRunInfo[run].glyphCount - 1;
1075
1076         // Here, we want to remove the glyphBase bias...
1077         rightGlyph = last - leftGlyph;
1078         leftGlyph  = last - swap;
1079     } else {
1080         rightGlyph -= glyphBase;
1081         leftGlyph  -= glyphBase;
1082     }
1083
1084     // Set the position bias for the glyphs. If we're at the start of
1085     // a line, we want the first glyph to be at x = 0, even if it comes
1086     // from the middle of a layout. If we've got a right-to-left run, we
1087     // want the left-most glyph to start at the final x position of the
1088     // previous run, even though this glyph may be in the middle of the
1089     // run.
1090     fVisualRunLastX -= fStyleRunInfo[run].positions[leftGlyph * 2];
1091
1092     // Make rightGlyph be the glyph just to the right of
1093     // the run's glyphs
1094     rightGlyph += 1;
1095
1096     UBiDiDirection direction  = ((fStyleRunInfo[run].level & 1) == 0)? UBIDI_LTR : UBIDI_RTL;
1097     le_int32   glyphCount     = rightGlyph - leftGlyph;
1098     LEGlyphID *glyphs         = LE_NEW_ARRAY(LEGlyphID, glyphCount);
1099     float     *positions      = LE_NEW_ARRAY(float, glyphCount * 2 + 2);
1100     le_int32  *glyphToCharMap = LE_NEW_ARRAY(le_int32, glyphCount);
1101
1102     LE_ARRAY_COPY(glyphs, &fStyleRunInfo[run].glyphs[leftGlyph], glyphCount);
1103
1104     for (outGlyph = 0, inGlyph = leftGlyph * 2; inGlyph <= rightGlyph * 2; inGlyph += 2, outGlyph += 2) {
1105         positions[outGlyph]     = fStyleRunInfo[run].positions[inGlyph] + fVisualRunLastX;
1106         positions[outGlyph + 1] = fStyleRunInfo[run].positions[inGlyph + 1] + fVisualRunLastY;
1107     }
1108
1109     // Save the ending position of this run
1110     // to use for the start of the next run
1111     fVisualRunLastX = positions[outGlyph - 2];
1112     fVisualRunLastY = positions[outGlyph - 1];
1113
1114     if ((fStyleRunInfo[run].level & 1) == 0) {
1115         for (outGlyph = 0, inGlyph = leftGlyph; inGlyph < rightGlyph; inGlyph += 1, outGlyph += 1) {
1116             glyphToCharMap[outGlyph] = fGlyphToCharMap[glyphBase + inGlyph];
1117         }
1118     } else {
1119         // Because fGlyphToCharMap is stored in logical order to facilitate line breaking,
1120         // we need to map the physical glyph indices to logical indices while we copy the
1121         // character indices.
1122         le_int32 base = glyphBase + fStyleRunInfo[run].glyphCount - 1;
1123
1124         for (outGlyph = 0, inGlyph = leftGlyph; inGlyph < rightGlyph; inGlyph += 1, outGlyph += 1) {
1125             glyphToCharMap[outGlyph] = fGlyphToCharMap[base - inGlyph];
1126         }
1127     }
1128
1129     line->append(fStyleRunInfo[run].font, direction, glyphCount, glyphs, positions, glyphToCharMap);
1130 }
1131
1132 le_int32 ParagraphLayout::getCharRun(le_int32 charIndex)
1133 {
1134     if (charIndex < 0 || charIndex > fCharCount) {
1135         return -1;
1136     }
1137
1138     le_int32 run;
1139
1140     // NOTE: as long as fStyleRunLimits is well-formed
1141     // the above range check guarantees that we'll never
1142     // fall off the end of the array.
1143     run = 0;
1144     while (charIndex >= fStyleRunLimits[run]) {
1145         run += 1;
1146     }
1147
1148     return run;
1149 }
1150
1151
1152 const char ParagraphLayout::Line::fgClassID = 0;
1153
1154 #define INITIAL_RUN_CAPACITY 4
1155 #define RUN_CAPACITY_GROW_LIMIT 16
1156
1157 ParagraphLayout::Line::~Line()
1158 {
1159     le_int32 i;
1160
1161     for (i = 0; i < fRunCount; i += 1) {
1162         delete fRuns[i];
1163     }
1164
1165     LE_DELETE_ARRAY(fRuns);
1166 }
1167
1168 le_int32 ParagraphLayout::Line::getAscent() const
1169 {
1170     if (fAscent <= 0) {
1171         ((ParagraphLayout::Line *)this)->computeMetrics();
1172     }
1173
1174     return fAscent;
1175 }
1176
1177 le_int32 ParagraphLayout::Line::getDescent() const
1178 {
1179     if (fAscent <= 0) {
1180         ((ParagraphLayout::Line *)this)->computeMetrics();
1181     }
1182
1183     return fDescent;
1184 }
1185
1186 le_int32 ParagraphLayout::Line::getLeading() const
1187 {
1188     if (fAscent <= 0) {
1189         ((ParagraphLayout::Line *)this)->computeMetrics();
1190     }
1191
1192     return fLeading;
1193 }
1194
1195 le_int32 ParagraphLayout::Line::getWidth() const
1196 {
1197     const VisualRun *lastRun = getVisualRun(fRunCount - 1);
1198
1199     if (lastRun == NULL) {
1200         return 0;
1201     }
1202
1203     le_int32 glyphCount = lastRun->getGlyphCount();
1204     const float *positions = lastRun->getPositions();
1205
1206     return (le_int32) positions[glyphCount * 2];
1207 }
1208
1209 const ParagraphLayout::VisualRun *ParagraphLayout::Line::getVisualRun(le_int32 runIndex) const
1210 {
1211     if (runIndex < 0 || runIndex >= fRunCount) {
1212         return NULL;
1213     }
1214
1215     return fRuns[runIndex];
1216 }
1217
1218 void ParagraphLayout::Line::append(const LEFontInstance *font, UBiDiDirection direction, le_int32 glyphCount,
1219                                    const LEGlyphID glyphs[], const float positions[], const le_int32 glyphToCharMap[])
1220 {
1221     if (fRunCount >= fRunCapacity) {
1222         if (fRunCapacity == 0) {
1223             fRunCapacity = INITIAL_RUN_CAPACITY;
1224             fRuns = LE_NEW_ARRAY(ParagraphLayout::VisualRun *, fRunCapacity);
1225         } else {
1226             fRunCapacity += (fRunCapacity < RUN_CAPACITY_GROW_LIMIT? fRunCapacity : RUN_CAPACITY_GROW_LIMIT);
1227             fRuns = (ParagraphLayout::VisualRun **) LE_GROW_ARRAY(fRuns, fRunCapacity);
1228         }
1229     }
1230
1231     fRuns[fRunCount++] = new ParagraphLayout::VisualRun(font, direction, glyphCount, glyphs, positions, glyphToCharMap);
1232 }
1233
1234 void ParagraphLayout::Line::computeMetrics()
1235 {
1236     le_int32 maxDL = 0;
1237
1238     for (le_int32 i = 0; i < fRunCount; i += 1) {
1239         le_int32 ascent  = fRuns[i]->getAscent();
1240         le_int32 descent = fRuns[i]->getDescent();
1241         le_int32 leading = fRuns[i]->getLeading();
1242         le_int32 dl      = descent + leading;
1243
1244         if (ascent > fAscent) {
1245             fAscent = ascent;
1246         }
1247
1248         if (descent > fDescent) {
1249             fDescent = descent;
1250         }
1251
1252         if (leading > fLeading) {
1253             fLeading = leading;
1254         }
1255
1256         if (dl > maxDL) {
1257             maxDL = dl;
1258         }
1259     }
1260
1261     fLeading = maxDL - fDescent;
1262 }
1263
1264 const char ParagraphLayout::VisualRun::fgClassID = 0;
1265
1266 ParagraphLayout::VisualRun::~VisualRun()
1267 {
1268     LE_DELETE_ARRAY(fGlyphToCharMap);
1269     LE_DELETE_ARRAY(fPositions);
1270     LE_DELETE_ARRAY(fGlyphs);
1271 }
1272
1273 U_NAMESPACE_END
1274
1275 #endif
1276