]> git.saurik.com Git - apple/icu.git/blob - icuSources/layoutex/ParagraphLayout.cpp
projects / apple / icu.git / blob
? search:


9e525cf1c5219817cdb288bf1b03fa8d8f47a313
[apple/icu.git] / icuSources / layoutex / ParagraphLayout.cpp
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
mirror of ICU