Home | History | Annotate | Download | only in layoutex 
      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 
   1277