icuSources/layoutex/ParagraphLayout.cpp

   1 /*
   2  **********************************************************************
   3  *   Copyright (C) 2002-2014, 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     (void)copyright;  // Suppress unused variable warning.
 336     (void)fVertical;  // Suppress warning for unused field fVertical.
 337
 338     // FIXME: should check the limit arrays for consistency...
 339
 340     computeLevels(paragraphLevel);
 341
 342     if (scriptRuns == NULL) {
 343         computeScripts();
 344     }
 345
 346     if (localeRuns == NULL) {
 347         computeLocales();
 348     }
 349
 350     computeSubFonts(fontRuns, status);
 351
 352     if (LE_FAILURE(status)) {
 353         //other stuff?
 354         fCharCount = -1;
 355         return;
 356     }
 357
 358     // now intersect the font, direction and script runs...
 359     const RunArray *styleRunArrays[] = {fFontRuns, fLevelRuns, fScriptRuns, fLocaleRuns};
 360     le_int32  styleCount = sizeof styleRunArrays / sizeof styleRunArrays[0];
 361     StyleRuns styleRuns(styleRunArrays, styleCount);
 362     LEErrorCode layoutStatus = LE_NO_ERROR;
 363
 364     fStyleRunCount = styleRuns.getRuns(NULL, NULL);
 365
 366     fStyleRunLimits = LE_NEW_ARRAY(le_int32, fStyleRunCount);
 367     fStyleIndices   = LE_NEW_ARRAY(le_int32, fStyleRunCount * styleCount);
 368     if ((fStyleRunLimits == NULL) || (fStyleIndices == NULL)) {
 369         status = LE_MEMORY_ALLOCATION_ERROR;
 370         return;
 371     }
 372
 373     styleRuns.getRuns(fStyleRunLimits, fStyleIndices);
 374
 375     // now build a LayoutEngine for each style run...
 376     le_int32 *styleIndices = fStyleIndices;
 377     le_int32 run, runStart;
 378
 379     fStyleRunInfo = LE_NEW_ARRAY(StyleRunInfo, fStyleRunCount);
 380     if (fStyleRunInfo == NULL) {
 381         status = LE_MEMORY_ALLOCATION_ERROR;
 382         return;
 383     }
 384     else {
 385         // initialize
 386         for (run = 0; run < fStyleRunCount; run += 1) {
 387             fStyleRunInfo[run].font = NULL;
 388             fStyleRunInfo[run].runBase = 0;
 389             fStyleRunInfo[run].runLimit = 0;
 390             fStyleRunInfo[run].script = (UScriptCode)0;
 391             fStyleRunInfo[run].locale = NULL;
 392             fStyleRunInfo[run].level = 0;
 393             fStyleRunInfo[run].glyphBase = 0;
 394             fStyleRunInfo[run].engine = NULL;
 395             fStyleRunInfo[run].glyphCount = 0;
 396             fStyleRunInfo[run].glyphs = NULL;
 397             fStyleRunInfo[run].positions = NULL;
 398         }
 399     }
 400
 401     fGlyphCount = 0;
 402     for (runStart = 0, run = 0; run < fStyleRunCount; run += 1) {
 403         fStyleRunInfo[run].font      = fFontRuns->getFont(styleIndices[0]);
 404         fStyleRunInfo[run].runBase   = runStart;
 405         fStyleRunInfo[run].runLimit  = fStyleRunLimits[run];
 406         fStyleRunInfo[run].script    = (UScriptCode) fScriptRuns->getValue(styleIndices[2]);
 407         fStyleRunInfo[run].locale    = fLocaleRuns->getLocale(styleIndices[3]);
 408         fStyleRunInfo[run].level     = (UBiDiLevel) fLevelRuns->getValue(styleIndices[1]);
 409         fStyleRunInfo[run].glyphBase = fGlyphCount;
 410
 411         fStyleRunInfo[run].engine = LayoutEngine::layoutEngineFactory(fStyleRunInfo[run].font,
 412             fStyleRunInfo[run].script, getLanguageCode(fStyleRunInfo[run].locale), layoutStatus);
 413         if (LE_FAILURE(layoutStatus)) {
 414             status = layoutStatus;
 415             return;
 416         }
 417
 418         fStyleRunInfo[run].glyphCount = fStyleRunInfo[run].engine->layoutChars(fChars, runStart, fStyleRunLimits[run] - runStart, fCharCount,
 419             fStyleRunInfo[run].level & 1, 0, 0, layoutStatus);
 420         if (LE_FAILURE(layoutStatus)) {
 421             status = layoutStatus;
 422             return;
 423         }
 424
 425         runStart = fStyleRunLimits[run];
 426         styleIndices += styleCount;
 427         fGlyphCount += fStyleRunInfo[run].glyphCount;
 428     }
 429
 430     // Make big arrays for the glyph widths, glyph-to-char and char-to-glyph maps,
 431     // in logical order. (Both maps need an extra entry for the end of the text.)
 432     //
 433     // For each layout get the positions and convert them into glyph widths, in
 434     // logical order. Get the glyph-to-char mapping, offset by starting index in the
 435     // character array. Swap the glyph width and glyph-to-char arrays into logical order.
 436     // Finally, fill in the char-to-glyph mappings.
 437     fGlyphWidths       = LE_NEW_ARRAY(float, fGlyphCount);
 438     fGlyphToCharMap    = LE_NEW_ARRAY(le_int32, fGlyphCount + 1);
 439     fCharToMinGlyphMap = LE_NEW_ARRAY(le_int32, fCharCount + 1);
 440     fCharToMaxGlyphMap = LE_NEW_ARRAY(le_int32, fCharCount + 1);
 441     if ((fGlyphWidths == NULL) || (fGlyphToCharMap == NULL) ||
 442         (fCharToMinGlyphMap == NULL) || (fCharToMaxGlyphMap == NULL)) {
 443         status = LE_MEMORY_ALLOCATION_ERROR;
 444         return;
 445     }
 446
 447     le_int32 glyph;
 448
 449     for (runStart = 0, run = 0; run < fStyleRunCount; run += 1) {
 450         LayoutEngine *engine = fStyleRunInfo[run].engine;
 451         le_int32 glyphCount  = fStyleRunInfo[run].glyphCount;
 452         le_int32 glyphBase   = fStyleRunInfo[run].glyphBase;
 453
 454         fStyleRunInfo[run].glyphs = LE_NEW_ARRAY(LEGlyphID, glyphCount);
 455         fStyleRunInfo[run].positions = LE_NEW_ARRAY(float, glyphCount * 2 + 2);
 456         if ((fStyleRunInfo[run].glyphs == NULL) ||
 457             (fStyleRunInfo[run].positions == NULL)) {
 458             status = LE_MEMORY_ALLOCATION_ERROR;
 459             return;
 460         }
 461
 462         engine->getGlyphs(fStyleRunInfo[run].glyphs, layoutStatus);
 463         if (LE_FAILURE(layoutStatus)) {
 464             status = layoutStatus;
 465             return;
 466         }
 467
 468         engine->getGlyphPositions(fStyleRunInfo[run].positions, layoutStatus);
 469         if (LE_FAILURE(layoutStatus)) {
 470             status = layoutStatus;
 471             return;
 472         }
 473
 474         engine->getCharIndices(&fGlyphToCharMap[glyphBase], runStart, layoutStatus);
 475         if (LE_FAILURE(layoutStatus)) {
 476             status = layoutStatus;
 477             return;
 478         }
 479
 480         for (glyph = 0; glyph < glyphCount; glyph += 1) {
 481             fGlyphWidths[glyphBase + glyph] = fStyleRunInfo[run].positions[glyph * 2 + 2] - fStyleRunInfo[run].positions[glyph * 2];
 482         }
 483
 484         if ((fStyleRunInfo[run].level & 1) != 0) {
 485             LXUtilities::reverse(&fGlyphWidths[glyphBase], glyphCount);
 486             LXUtilities::reverse(&fGlyphToCharMap[glyphBase], glyphCount);
 487         }
 488
 489         runStart = fStyleRunLimits[run];
 490
 491         delete engine;
 492         fStyleRunInfo[run].engine = NULL;
 493     }
 494
 495     fGlyphToCharMap[fGlyphCount] = fCharCount;
 496
 497     // Initialize the char-to-glyph maps to -1 so that we can later figure out
 498     // whether any of the entries in the map aren't filled in below.
 499     le_int32 chIndex;
 500     for (chIndex = 0; chIndex <= fCharCount; chIndex += 1) {
 501         fCharToMinGlyphMap[chIndex] = -1;
 502         fCharToMaxGlyphMap[chIndex] = -1;
 503     }
 504
 505     for (glyph = fGlyphCount - 1; glyph >= 0; glyph -= 1) {
 506         le_int32 ch = fGlyphToCharMap[glyph];
 507
 508         fCharToMinGlyphMap[ch] = glyph;
 509     }
 510
 511     fCharToMinGlyphMap[fCharCount] = fGlyphCount;
 512
 513     for (glyph = 0; glyph < fGlyphCount; glyph += 1) {
 514         le_int32 ch = fGlyphToCharMap[glyph];
 515
 516         fCharToMaxGlyphMap[ch] = glyph;
 517     }
 518
 519     fCharToMaxGlyphMap[fCharCount] = fGlyphCount;
 520
 521     // Now fill in the missing values in the char-to-glyph maps.
 522     fillMissingCharToGlyphMapValues(fCharToMinGlyphMap, fCharCount);
 523     fillMissingCharToGlyphMapValues(fCharToMaxGlyphMap, fCharCount);
 524 }
 525
 526 ParagraphLayout::~ParagraphLayout()
 527 {
 528     delete (FontRuns *) fFontRuns;
 529
 530     if (! fClientLevels) {
 531         delete (ValueRuns *) fLevelRuns;
 532         fLevelRuns = NULL;
 533
 534         fClientLevels = TRUE;
 535     }
 536
 537     if (! fClientScripts) {
 538         delete (ValueRuns *) fScriptRuns;
 539         fScriptRuns = NULL;
 540
 541         fClientScripts = TRUE;
 542     }
 543
 544     if (! fClientLocales) {
 545         delete (LocaleRuns *) fLocaleRuns;
 546         fLocaleRuns = NULL;
 547
 548         fClientLocales = TRUE;
 549     }
 550
 551     if (fEmbeddingLevels != NULL) {
 552         LE_DELETE_ARRAY(fEmbeddingLevels);
 553         fEmbeddingLevels = NULL;
 554     }
 555
 556     if (fGlyphToCharMap != NULL) {
 557         LE_DELETE_ARRAY(fGlyphToCharMap);
 558         fGlyphToCharMap = NULL;
 559     }
 560
 561     if (fCharToMinGlyphMap != NULL) {
 562         LE_DELETE_ARRAY(fCharToMinGlyphMap);
 563         fCharToMinGlyphMap = NULL;
 564     }
 565
 566     if (fCharToMaxGlyphMap != NULL) {
 567         LE_DELETE_ARRAY(fCharToMaxGlyphMap);
 568         fCharToMaxGlyphMap = NULL;
 569     }
 570
 571     if (fGlyphWidths != NULL) {
 572         LE_DELETE_ARRAY(fGlyphWidths);
 573         fGlyphWidths = NULL;
 574     }
 575
 576     if (fParaBidi != NULL) {
 577         ubidi_close(fParaBidi);
 578         fParaBidi = NULL;
 579     }
 580
 581     if (fLineBidi != NULL) {
 582         ubidi_close(fLineBidi);
 583         fLineBidi = NULL;
 584     }
 585
 586     if (fStyleRunCount > 0) {
 587         le_int32 run;
 588
 589         LE_DELETE_ARRAY(fStyleRunLimits);
 590         LE_DELETE_ARRAY(fStyleIndices);
 591
 592         for (run = 0; run < fStyleRunCount; run += 1) {
 593             LE_DELETE_ARRAY(fStyleRunInfo[run].glyphs);
 594             LE_DELETE_ARRAY(fStyleRunInfo[run].positions);
 595
 596             fStyleRunInfo[run].glyphs    = NULL;
 597             fStyleRunInfo[run].positions = NULL;
 598         }
 599
 600         LE_DELETE_ARRAY(fStyleRunInfo);
 601
 602         fStyleRunLimits = NULL;
 603         fStyleIndices   = NULL;
 604         fStyleRunInfo        = NULL;
 605         fStyleRunCount  = 0;
 606     }
 607
 608     if (fBreakIterator != NULL) {
 609         delete fBreakIterator;
 610         fBreakIterator = NULL;
 611     }
 612 }
 613
 614
 615 le_bool ParagraphLayout::isComplex(const LEUnicode chars[], le_int32 count)
 616 {
 617     UErrorCode scriptStatus = U_ZERO_ERROR;
 618     UScriptCode scriptCode  = USCRIPT_INVALID_CODE;
 619     UScriptRun *sr = uscript_openRun(chars, count, &scriptStatus);
 620     le_bool result = FALSE;
 621
 622     while (uscript_nextRun(sr, NULL, NULL, &scriptCode)) {
 623         if (isComplex(scriptCode)) {
 624             result = TRUE;
 625             break;
 626         }
 627     }
 628
 629     uscript_closeRun(sr);
 630     return result;
 631 }
 632
 633 le_int32 ParagraphLayout::getAscent() const
 634 {
 635     if (fAscent <= 0 && fCharCount > 0) {
 636         ((ParagraphLayout *) this)->computeMetrics();
 637     }
 638
 639     return fAscent;
 640 }
 641
 642 le_int32 ParagraphLayout::getDescent() const
 643 {
 644     if (fAscent <= 0 && fCharCount > 0) {
 645         ((ParagraphLayout *) this)->computeMetrics();
 646     }
 647
 648     return fDescent;
 649 }
 650
 651 le_int32 ParagraphLayout::getLeading() const
 652 {
 653     if (fAscent <= 0 && fCharCount > 0) {
 654         ((ParagraphLayout *) this)->computeMetrics();
 655     }
 656
 657     return fLeading;
 658 }
 659
 660 le_bool ParagraphLayout::isDone() const
 661 {
 662     return fLineEnd >= fCharCount;
 663 }
 664
 665 ParagraphLayout::Line *ParagraphLayout::nextLine(float width)
 666 {
 667     if (isDone()) {
 668         return NULL;
 669     }
 670
 671     fLineStart = fLineEnd;
 672
 673     if (width > 0) {
 674         le_int32 glyph    = fCharToMinGlyphMap[fLineStart];
 675         float widthSoFar  = 0;
 676
 677         while (glyph < fGlyphCount && widthSoFar + fGlyphWidths[glyph] <= width) {
 678             widthSoFar += fGlyphWidths[glyph++];
 679         }
 680
 681         // If no glyphs fit on the line, force one to fit.
 682         //
 683         // (There shouldn't be any zero width glyphs at the
 684         // start of a line unless the paragraph consists of
 685         // only zero width glyphs, because otherwise the zero
 686         // width glyphs will have been included on the end of
 687         // the previous line...)
 688         if (widthSoFar == 0 && glyph < fGlyphCount) {
 689             glyph += 1;
 690         }
 691
 692         fLineEnd = previousBreak(fGlyphToCharMap[glyph]);
 693
 694         // If this break is at or before the last one,
 695         // find a glyph, starting at the one which didn't
 696         // fit, that produces a break after the last one.
 697         while (fLineEnd <= fLineStart) {
 698             fLineEnd = fGlyphToCharMap[glyph++];
 699         }
 700     } else {
 701         fLineEnd = fCharCount;
 702     }
 703
 704     return computeVisualRuns();
 705 }
 706
 707 void ParagraphLayout::computeLevels(UBiDiLevel paragraphLevel)
 708 {
 709     UErrorCode bidiStatus = U_ZERO_ERROR;
 710
 711     if (fLevelRuns != NULL) {
 712         le_int32 ch;
 713         le_int32 run;
 714
 715         fEmbeddingLevels = LE_NEW_ARRAY(UBiDiLevel, fCharCount);
 716
 717         for (ch = 0, run = 0; run < fLevelRuns->getCount(); run += 1) {
 718             UBiDiLevel runLevel = (UBiDiLevel) fLevelRuns->getValue(run) | UBIDI_LEVEL_OVERRIDE;
 719             le_int32   runLimit = fLevelRuns->getLimit(run);
 720
 721             while (ch < runLimit) {
 722                 fEmbeddingLevels[ch++] = runLevel;
 723             }
 724         }
 725     }
 726
 727     fParaBidi = ubidi_openSized(fCharCount, 0, &bidiStatus);
 728     ubidi_setPara(fParaBidi, fChars, fCharCount, paragraphLevel, fEmbeddingLevels, &bidiStatus);
 729
 730     if (fLevelRuns == NULL) {
 731         le_int32 levelRunCount = ubidi_countRuns(fParaBidi, &bidiStatus);
 732         ValueRuns *levelRuns = new ValueRuns(levelRunCount);
 733
 734         le_int32 logicalStart = 0;
 735         le_int32 run;
 736         le_int32 limit;
 737         UBiDiLevel level;
 738
 739         for (run = 0; run < levelRunCount; run += 1) {
 740             ubidi_getLogicalRun(fParaBidi, logicalStart, &limit, &level);
 741             levelRuns->add(level, limit);
 742             logicalStart = limit;
 743         }
 744
 745         fLevelRuns    = levelRuns;
 746         fClientLevels = FALSE;
 747     }
 748 }
 749
 750 void ParagraphLayout::computeScripts()
 751 {
 752     UErrorCode scriptStatus = U_ZERO_ERROR;
 753     UScriptRun *sr = uscript_openRun(fChars, fCharCount, &scriptStatus);
 754     ValueRuns  *scriptRuns = new ValueRuns(0);
 755     le_int32 limit;
 756     UScriptCode script;
 757
 758     while (uscript_nextRun(sr, NULL, &limit, &script)) {
 759         scriptRuns->add(script, limit);
 760     }
 761
 762     uscript_closeRun(sr);
 763
 764     fScriptRuns    = scriptRuns;
 765     fClientScripts = FALSE;
 766 }
 767
 768 void ParagraphLayout::computeLocales()
 769 {
 770     LocaleRuns *localeRuns = new LocaleRuns(0);
 771     const Locale *defaultLocale = &Locale::getDefault();
 772
 773     localeRuns->add(defaultLocale, fCharCount);
 774
 775     fLocaleRuns    = localeRuns;
 776     fClientLocales = FALSE;
 777 }
 778
 779 void ParagraphLayout::computeSubFonts(const FontRuns *fontRuns, LEErrorCode &status)
 780 {
 781     if (LE_FAILURE(status)) {
 782         return;
 783     }
 784
 785     const RunArray *styleRunArrays[] = {fontRuns, fScriptRuns};
 786     le_int32 styleCount = sizeof styleRunArrays / sizeof styleRunArrays[0];
 787     StyleRuns styleRuns(styleRunArrays, styleCount);
 788     le_int32 styleRunCount = styleRuns.getRuns(NULL, NULL);
 789     le_int32 *styleRunLimits = LE_NEW_ARRAY(le_int32, styleRunCount);
 790     le_int32 *styleIndices = LE_NEW_ARRAY(le_int32, styleRunCount * styleCount);
 791     FontRuns *subFontRuns  = new FontRuns(0);
 792     le_int32  run, offset, *si;
 793
 794     styleRuns.getRuns(styleRunLimits, styleIndices);
 795
 796     si = styleIndices;
 797     offset = 0;
 798
 799     for (run = 0; run < styleRunCount; run += 1) {
 800         const LEFontInstance *runFont = fontRuns->getFont(si[0]);
 801         le_int32 script = fScriptRuns->getValue(si[1]);
 802
 803         while (offset < styleRunLimits[run]) {
 804             const LEFontInstance *subFont = runFont->getSubFont(fChars, &offset, styleRunLimits[run], script, status);
 805
 806             if (LE_FAILURE(status)) {
 807                 delete subFontRuns;
 808                 goto cleanUp;
 809             }
 810
 811             subFontRuns->add(subFont, offset);
 812         }
 813
 814         si += styleCount;
 815     }
 816
 817     fFontRuns = subFontRuns;
 818
 819 cleanUp:
 820     LE_DELETE_ARRAY(styleIndices);
 821     LE_DELETE_ARRAY(styleRunLimits);
 822 }
 823
 824 void ParagraphLayout::computeMetrics()
 825 {
 826     le_int32 i, count = fFontRuns->getCount();
 827     le_int32 maxDL = 0;
 828
 829     for (i = 0; i < count; i += 1) {
 830         const LEFontInstance *font = fFontRuns->getFont(i);
 831         le_int32 ascent  = font->getAscent();
 832         le_int32 descent = font->getDescent();
 833         le_int32 leading = font->getLeading();
 834         le_int32 dl      = descent + leading;
 835
 836         if (ascent > fAscent) {
 837             fAscent = ascent;
 838         }
 839
 840         if (descent > fDescent) {
 841             fDescent = descent;
 842         }
 843
 844         if (leading > fLeading) {
 845             fLeading = leading;
 846         }
 847
 848         if (dl > maxDL) {
 849             maxDL = dl;
 850         }
 851     }
 852
 853     fLeading = maxDL - fDescent;
 854 }
 855
 856 #if 1
 857 struct LanguageMap
 858 {
 859     const char *localeCode;
 860     le_int32 languageCode;
 861 };
 862
 863 static const LanguageMap languageMap[] =
 864 {
 865     {"afr", afkLanguageCode}, // Afrikaans
 866     {"ara", araLanguageCode}, // Arabic
 867     {"asm", asmLanguageCode}, // Assamese
 868     {"bel", belLanguageCode}, // Belarussian
 869     {"ben", benLanguageCode}, // Bengali
 870     {"bod", tibLanguageCode}, // Tibetan
 871     {"bul", bgrLanguageCode}, // Bulgarian
 872     {"cat", catLanguageCode}, // Catalan
 873     {"ces", csyLanguageCode}, // Czech
 874     {"che", cheLanguageCode}, // Chechen
 875     {"cop", copLanguageCode}, // Coptic
 876     {"cym", welLanguageCode}, // Welsh
 877     {"dan", danLanguageCode}, // Danish
 878     {"deu", deuLanguageCode}, // German
 879     {"dzo", dznLanguageCode}, // Dzongkha
 880     {"ell", ellLanguageCode}, // Greek
 881     {"eng", engLanguageCode}, // English
 882     {"est", etiLanguageCode}, // Estonian
 883     {"eus", euqLanguageCode}, // Basque
 884     {"fas", farLanguageCode}, // Farsi
 885     {"fin", finLanguageCode}, // Finnish
 886     {"fra", fraLanguageCode}, // French
 887     {"gle", gaeLanguageCode}, // Irish Gaelic
 888     {"guj", gujLanguageCode}, // Gujarati
 889     {"hau", hauLanguageCode}, // Hausa
 890     {"heb", iwrLanguageCode}, // Hebrew
 891     {"hin", hinLanguageCode}, // Hindi
 892     {"hrv", hrvLanguageCode}, // Croatian
 893     {"hun", hunLanguageCode}, // Hungarian
 894     {"hye", hyeLanguageCode}, // Armenian
 895     {"ind", indLanguageCode}, // Indonesian
 896     {"ita", itaLanguageCode}, // Italian
 897     {"jpn", janLanguageCode}, // Japanese
 898     {"kan", kanLanguageCode}, // Kannada
 899     {"kas", kshLanguageCode}, // Kashmiri
 900     {"khm", khmLanguageCode}, // Khmer
 901     {"kok", kokLanguageCode}, // Konkani
 902     {"kor", korLanguageCode}, // Korean
 903 //  {"mal_XXX", malLanguageCode}, // Malayalam - Traditional
 904     {"mal", mlrLanguageCode}, // Malayalam - Reformed
 905     {"mar", marLanguageCode}, // Marathi
 906     {"mlt", mtsLanguageCode}, // Maltese
 907     {"mni", mniLanguageCode}, // Manipuri
 908     {"mon", mngLanguageCode}, // Mongolian
 909     {"nep", nepLanguageCode}, // Nepali
 910     {"ori", oriLanguageCode}, // Oriya
 911     {"pol", plkLanguageCode}, // Polish
 912     {"por", ptgLanguageCode}, // Portuguese
 913     {"pus", pasLanguageCode}, // Pashto
 914     {"ron", romLanguageCode}, // Romanian
 915     {"rus", rusLanguageCode}, // Russian
 916     {"san", sanLanguageCode}, // Sanskrit
 917     {"sin", snhLanguageCode}, // Sinhalese
 918     {"slk", skyLanguageCode}, // Slovak
 919     {"snd", sndLanguageCode}, // Sindhi
 920     {"slv", slvLanguageCode}, // Slovenian
 921     {"spa", espLanguageCode}, // Spanish
 922     {"sqi", sqiLanguageCode}, // Albanian
 923     {"srp", srbLanguageCode}, // Serbian
 924     {"swe", sveLanguageCode}, // Swedish
 925     {"syr", syrLanguageCode}, // Syriac
 926     {"tam", tamLanguageCode}, // Tamil
 927     {"tel", telLanguageCode}, // Telugu
 928     {"tha", thaLanguageCode}, // Thai
 929     {"tur", trkLanguageCode}, // Turkish
 930     {"urd", urdLanguageCode}, // Urdu
 931     {"yid", jiiLanguageCode}, // Yiddish
 932 //  {"zhp", zhpLanguageCode}, // Chinese - Phonetic
 933     {"zho", zhsLanguageCode}, // Chinese
 934     {"zho_CHN", zhsLanguageCode}, // Chinese - China
 935     {"zho_HKG", zhsLanguageCode}, // Chinese - Hong Kong
 936     {"zho_MAC", zhtLanguageCode}, // Chinese - Macao
 937     {"zho_SGP", zhsLanguageCode}, // Chinese - Singapore
 938     {"zho_TWN", zhtLanguageCode}  // Chinese - Taiwan
 939 };
 940
 941 static const le_int32 languageMapCount = ARRAY_SIZE(languageMap);
 942
 943 le_int32 ParagraphLayout::getLanguageCode(const Locale *locale)
 944 {
 945     char code[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 946     const char *language = locale->getISO3Language();
 947     const char *country  = locale->getISO3Country();
 948
 949     uprv_strcat(code, language);
 950
 951     if ((uprv_strcmp(language, "zho") == 0) && country != NULL) {
 952         uprv_strcat(code, "_");
 953         uprv_strcat(code, country);
 954     }
 955
 956     for (le_int32 i = 0; i < languageMapCount; i += 1) {
 957         if (uprv_strcmp(code, languageMap[i].localeCode) == 0) {
 958             return languageMap[i].languageCode;
 959         }
 960     }
 961
 962     return nullLanguageCode;
 963 }
 964 #else
 965
 966 // TODO - dummy implementation for right now...
 967 le_int32 ParagraphLayout::getLanguageCode(const Locale *locale)
 968 {
 969     return nullLanguageCode;
 970 }
 971 #endif
 972
 973 le_bool ParagraphLayout::isComplex(UScriptCode script)
 974 {
 975     if (script < 0 || script >= (UScriptCode) scriptCodeCount) {
 976         return FALSE;
 977     }
 978
 979     return complexTable[script];
 980 }
 981
 982 le_int32 ParagraphLayout::previousBreak(le_int32 charIndex)
 983 {
 984     // skip over any whitespace or control characters,
 985     // because they can hang in the margin.
 986     while (charIndex < fCharCount &&
 987            (u_isWhitespace(fChars[charIndex]) ||
 988             u_iscntrl(fChars[charIndex]))) {
 989         charIndex += 1;
 990     }
 991
 992     // Create the BreakIterator if we don't already have one
 993     if (fBreakIterator == NULL) {
 994         Locale thai("th");
 995         UCharCharacterIterator *iter = new UCharCharacterIterator(fChars, fCharCount);
 996         UErrorCode status = U_ZERO_ERROR;
 997
 998         fBreakIterator = BreakIterator::createLineInstance(thai, status);
 999         fBreakIterator->adoptText(iter);
1000     }
1001
1002     // return the break location that's at or before
1003     // the character we stopped on. Note: if we're
1004     // on a break, the "+ 1" will cause preceding to
1005     // back up to it.
1006     return fBreakIterator->preceding(charIndex + 1);
1007 }
1008
1009 ParagraphLayout::Line *ParagraphLayout::computeVisualRuns()
1010 {
1011     UErrorCode bidiStatus = U_ZERO_ERROR;
1012     le_int32 dirRunCount, visualRun;
1013
1014     fVisualRunLastX = 0;
1015     fVisualRunLastY = 0;
1016     fFirstVisualRun = getCharRun(fLineStart);
1017     fLastVisualRun  = getCharRun(fLineEnd - 1);
1018
1019     if (fLineBidi == NULL) {
1020         fLineBidi = ubidi_openSized(fCharCount, 0, &bidiStatus);
1021     }
1022
1023     ubidi_setLine(fParaBidi, fLineStart, fLineEnd, fLineBidi, &bidiStatus);
1024     dirRunCount = ubidi_countRuns(fLineBidi, &bidiStatus);
1025
1026     Line *line = new Line();
1027
1028     for (visualRun = 0; visualRun < dirRunCount; visualRun += 1) {
1029         le_int32 relStart, run, runLength;
1030         UBiDiDirection runDirection = ubidi_getVisualRun(fLineBidi, visualRun, &relStart, &runLength);
1031         le_int32 runStart = fLineStart + relStart;
1032         le_int32 runEnd   = runStart + runLength - 1;
1033         le_int32 firstRun = getCharRun(runStart);
1034         le_int32 lastRun  = getCharRun(runEnd);
1035         le_int32 startRun = (runDirection == UBIDI_LTR)? firstRun : lastRun;
1036         le_int32 stopRun  = (runDirection == UBIDI_LTR)? lastRun + 1 : firstRun - 1;
1037         le_int32 dir      = (runDirection == UBIDI_LTR)?  1 : -1;
1038
1039         for (run = startRun; run != stopRun; run += dir) {
1040             le_int32 firstChar = (run == firstRun)? runStart : fStyleRunInfo[run].runBase;
1041             le_int32 lastChar  = (run == lastRun)?  runEnd   : fStyleRunInfo[run].runLimit - 1;
1042
1043             appendRun(line, run, firstChar, lastChar);
1044         }
1045     }
1046
1047     return line;
1048 }
1049
1050 void ParagraphLayout::appendRun(ParagraphLayout::Line *line, le_int32 run, le_int32 firstChar, le_int32 lastChar)
1051 {
1052     le_int32 glyphBase = fStyleRunInfo[run].glyphBase;
1053     le_int32 inGlyph, outGlyph;
1054
1055     // Get the glyph indices for all the characters between firstChar and lastChar,
1056     // make the minimum one be leftGlyph and the maximum one be rightGlyph.
1057     // (need to do this to handle local reorderings like Indic left matras)
1058     le_int32 leftGlyph  = fGlyphCount;
1059     le_int32 rightGlyph = -1;
1060     le_int32 ch;
1061
1062     for (ch = firstChar; ch <= lastChar; ch += 1) {
1063         le_int32 minGlyph = fCharToMinGlyphMap[ch];
1064         le_int32 maxGlyph = fCharToMaxGlyphMap[ch];
1065
1066         if (minGlyph < leftGlyph) {
1067             leftGlyph = minGlyph;
1068         }
1069
1070         if (maxGlyph > rightGlyph) {
1071             rightGlyph = maxGlyph;
1072         }
1073     }
1074
1075     if ((fStyleRunInfo[run].level & 1) != 0) {
1076         le_int32 swap = rightGlyph;
1077         le_int32 last = glyphBase + fStyleRunInfo[run].glyphCount - 1;
1078
1079         // Here, we want to remove the glyphBase bias...
1080         rightGlyph = last - leftGlyph;
1081         leftGlyph  = last - swap;
1082     } else {
1083         rightGlyph -= glyphBase;
1084         leftGlyph  -= glyphBase;
1085     }
1086
1087     // Set the position bias for the glyphs. If we're at the start of
1088     // a line, we want the first glyph to be at x = 0, even if it comes
1089     // from the middle of a layout. If we've got a right-to-left run, we
1090     // want the left-most glyph to start at the final x position of the
1091     // previous run, even though this glyph may be in the middle of the
1092     // run.
1093     fVisualRunLastX -= fStyleRunInfo[run].positions[leftGlyph * 2];
1094
1095     // Make rightGlyph be the glyph just to the right of
1096     // the run's glyphs
1097     rightGlyph += 1;
1098
1099     UBiDiDirection direction  = ((fStyleRunInfo[run].level & 1) == 0)? UBIDI_LTR : UBIDI_RTL;
1100     le_int32   glyphCount     = rightGlyph - leftGlyph;
1101     LEGlyphID *glyphs         = LE_NEW_ARRAY(LEGlyphID, glyphCount);
1102     float     *positions      = LE_NEW_ARRAY(float, glyphCount * 2 + 2);
1103     le_int32  *glyphToCharMap = LE_NEW_ARRAY(le_int32, glyphCount);
1104
1105     LE_ARRAY_COPY(glyphs, &fStyleRunInfo[run].glyphs[leftGlyph], glyphCount);
1106
1107     for (outGlyph = 0, inGlyph = leftGlyph * 2; inGlyph <= rightGlyph * 2; inGlyph += 2, outGlyph += 2) {
1108         positions[outGlyph]     = fStyleRunInfo[run].positions[inGlyph] + fVisualRunLastX;
1109         positions[outGlyph + 1] = fStyleRunInfo[run].positions[inGlyph + 1] + fVisualRunLastY;
1110     }
1111
1112     // Save the ending position of this run
1113     // to use for the start of the next run
1114     fVisualRunLastX = positions[outGlyph - 2];
1115     fVisualRunLastY = positions[outGlyph - 1];
1116
1117     if ((fStyleRunInfo[run].level & 1) == 0) {
1118         for (outGlyph = 0, inGlyph = leftGlyph; inGlyph < rightGlyph; inGlyph += 1, outGlyph += 1) {
1119             glyphToCharMap[outGlyph] = fGlyphToCharMap[glyphBase + inGlyph];
1120         }
1121     } else {
1122         // Because fGlyphToCharMap is stored in logical order to facilitate line breaking,
1123         // we need to map the physical glyph indices to logical indices while we copy the
1124         // character indices.
1125         le_int32 base = glyphBase + fStyleRunInfo[run].glyphCount - 1;
1126
1127         for (outGlyph = 0, inGlyph = leftGlyph; inGlyph < rightGlyph; inGlyph += 1, outGlyph += 1) {
1128             glyphToCharMap[outGlyph] = fGlyphToCharMap[base - inGlyph];
1129         }
1130     }
1131
1132     line->append(fStyleRunInfo[run].font, direction, glyphCount, glyphs, positions, glyphToCharMap);
1133 }
1134
1135 le_int32 ParagraphLayout::getCharRun(le_int32 charIndex)
1136 {
1137     if (charIndex < 0 || charIndex > fCharCount) {
1138         return -1;
1139     }
1140
1141     le_int32 run;
1142
1143     // NOTE: as long as fStyleRunLimits is well-formed
1144     // the above range check guarantees that we'll never
1145     // fall off the end of the array.
1146     run = 0;
1147     while (charIndex >= fStyleRunLimits[run]) {
1148         run += 1;
1149     }
1150
1151     return run;
1152 }
1153
1154
1155 const char ParagraphLayout::Line::fgClassID = 0;
1156
1157 #define INITIAL_RUN_CAPACITY 4
1158 #define RUN_CAPACITY_GROW_LIMIT 16
1159
1160 ParagraphLayout::Line::~Line()
1161 {
1162     le_int32 i;
1163
1164     for (i = 0; i < fRunCount; i += 1) {
1165         delete fRuns[i];
1166     }
1167
1168     LE_DELETE_ARRAY(fRuns);
1169 }
1170
1171 le_int32 ParagraphLayout::Line::getAscent() const
1172 {
1173     if (fAscent <= 0) {
1174         ((ParagraphLayout::Line *)this)->computeMetrics();
1175     }
1176
1177     return fAscent;
1178 }
1179
1180 le_int32 ParagraphLayout::Line::getDescent() const
1181 {
1182     if (fAscent <= 0) {
1183         ((ParagraphLayout::Line *)this)->computeMetrics();
1184     }
1185
1186     return fDescent;
1187 }
1188
1189 le_int32 ParagraphLayout::Line::getLeading() const
1190 {
1191     if (fAscent <= 0) {
1192         ((ParagraphLayout::Line *)this)->computeMetrics();
1193     }
1194
1195     return fLeading;
1196 }
1197
1198 le_int32 ParagraphLayout::Line::getWidth() const
1199 {
1200     const VisualRun *lastRun = getVisualRun(fRunCount - 1);
1201
1202     if (lastRun == NULL) {
1203         return 0;
1204     }
1205
1206     le_int32 glyphCount = lastRun->getGlyphCount();
1207     const float *positions = lastRun->getPositions();
1208
1209     return (le_int32) positions[glyphCount * 2];
1210 }
1211
1212 const ParagraphLayout::VisualRun *ParagraphLayout::Line::getVisualRun(le_int32 runIndex) const
1213 {
1214     if (runIndex < 0 || runIndex >= fRunCount) {
1215         return NULL;
1216     }
1217
1218     return fRuns[runIndex];
1219 }
1220
1221 void ParagraphLayout::Line::append(const LEFontInstance *font, UBiDiDirection direction, le_int32 glyphCount,
1222                                    const LEGlyphID glyphs[], const float positions[], const le_int32 glyphToCharMap[])
1223 {
1224     if (fRunCount >= fRunCapacity) {
1225         if (fRunCapacity == 0) {
1226             fRunCapacity = INITIAL_RUN_CAPACITY;
1227             fRuns = LE_NEW_ARRAY(ParagraphLayout::VisualRun *, fRunCapacity);
1228         } else {
1229             fRunCapacity += (fRunCapacity < RUN_CAPACITY_GROW_LIMIT? fRunCapacity : RUN_CAPACITY_GROW_LIMIT);
1230             fRuns = (ParagraphLayout::VisualRun **) LE_GROW_ARRAY(fRuns, fRunCapacity);
1231         }
1232     }
1233
1234     fRuns[fRunCount++] = new ParagraphLayout::VisualRun(font, direction, glyphCount, glyphs, positions, glyphToCharMap);
1235 }
1236
1237 void ParagraphLayout::Line::computeMetrics()
1238 {
1239     le_int32 maxDL = 0;
1240
1241     for (le_int32 i = 0; i < fRunCount; i += 1) {
1242         le_int32 ascent  = fRuns[i]->getAscent();
1243         le_int32 descent = fRuns[i]->getDescent();
1244         le_int32 leading = fRuns[i]->getLeading();
1245         le_int32 dl      = descent + leading;
1246
1247         if (ascent > fAscent) {
1248             fAscent = ascent;
1249         }
1250
1251         if (descent > fDescent) {
1252             fDescent = descent;
1253         }
1254
1255         if (leading > fLeading) {
1256             fLeading = leading;
1257         }
1258
1259         if (dl > maxDL) {
1260             maxDL = dl;
1261         }
1262     }
1263
1264     fLeading = maxDL - fDescent;
1265 }
1266
1267 const char ParagraphLayout::VisualRun::fgClassID = 0;
1268
1269 ParagraphLayout::VisualRun::~VisualRun()
1270 {
1271     LE_DELETE_ARRAY(fGlyphToCharMap);
1272     LE_DELETE_ARRAY(fPositions);
1273     LE_DELETE_ARRAY(fGlyphs);
1274 }
1275
1276 U_NAMESPACE_END
1277
1278 #endif
1279