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