History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/awt/font/TextLine.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/awt/font/TextLine.java+1437−0
@@ -0,0 +1,1437 @@
1/*
2 * Copyright (c) 1998, 2006, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26/*
27 * (C) Copyright IBM Corp. 1998-2003, All Rights Reserved
28 *
29 */
30
31package java.awt.font;
32
33import java.awt.Color;
34import java.awt.Font;
35import java.awt.Graphics2D;
36import java.awt.Rectangle;
37import java.awt.Shape;
38import java.awt.geom.AffineTransform;
39import java.awt.geom.GeneralPath;
40import java.awt.geom.Point2D;
41import java.awt.geom.Rectangle2D;
42import java.awt.im.InputMethodHighlight;
43import java.awt.image.BufferedImage;
44import java.text.Annotation;
45import java.text.AttributedCharacterIterator;
46import java.text.Bidi;
47import java.text.CharacterIterator;
48import java.util.Hashtable;
49import java.util.Map;
50import sun.font.AttributeValues;
51import sun.font.BidiUtils;
52import sun.font.CoreMetrics;
53import sun.font.Decoration;
54import sun.font.FontLineMetrics;
55import sun.font.FontResolver;
56import sun.font.GraphicComponent;
57import sun.font.LayoutPathImpl;
58import sun.font.LayoutPathImpl.EmptyPath;
59import sun.font.LayoutPathImpl.SegmentPathBuilder;
60import sun.font.TextLabelFactory;
61import sun.font.TextLineComponent;
62import sun.text.CodePointIterator;
63
64import java.awt.geom.Line2D;
65
66final class TextLine {
67
68 static final class TextLineMetrics {
69 public final float ascent;
70 public final float descent;
71 public final float leading;
72 public final float advance;
73
74 public TextLineMetrics(float ascent,
75 float descent,
76 float leading,
77 float advance) {
78 this.ascent = ascent;
79 this.descent = descent;
80 this.leading = leading;
81 this.advance = advance;
82 }
83 }
84
85 private TextLineComponent[] fComponents;
86 private float[] fBaselineOffsets;
87 private int[] fComponentVisualOrder; // if null, ltr
88 private float[] locs; // x,y pairs for components in visual order
89 private char[] fChars;
90 private int fCharsStart;
91 private int fCharsLimit;
92 private int[] fCharVisualOrder; // if null, ltr
93 private int[] fCharLogicalOrder; // if null, ltr
94 private byte[] fCharLevels; // if null, 0
95 private boolean fIsDirectionLTR;
96 private LayoutPathImpl lp;
97 private boolean isSimple;
98 private Rectangle pixelBounds;
99 private FontRenderContext frc;
100
101 private TextLineMetrics fMetrics = null; // built on demand in getMetrics
102
103 public TextLine(FontRenderContext frc,
104 TextLineComponent[] components,
105 float[] baselineOffsets,
106 char[] chars,
107 int charsStart,
108 int charsLimit,
109 int[] charLogicalOrder,
110 byte[] charLevels,
111 boolean isDirectionLTR) {
112
113 int[] componentVisualOrder = computeComponentOrder(components,
114 charLogicalOrder);
115
116 this.frc = frc;
117 fComponents = components;
118 fBaselineOffsets = baselineOffsets;
119 fComponentVisualOrder = componentVisualOrder;
120 fChars = chars;
121 fCharsStart = charsStart;
122 fCharsLimit = charsLimit;
123 fCharLogicalOrder = charLogicalOrder;
124 fCharLevels = charLevels;
125 fIsDirectionLTR = isDirectionLTR;
126 checkCtorArgs();
127
128 init();
129 }
130
131 private void checkCtorArgs() {
132
133 int checkCharCount = 0;
134 for (int i=0; i < fComponents.length; i++) {
135 checkCharCount += fComponents[i].getNumCharacters();
136 }
137
138 if (checkCharCount != this.characterCount()) {
139 throw new IllegalArgumentException("Invalid TextLine! " +
140 "char count is different from " +
141 "sum of char counts of components.");
142 }
143 }
144
145 private void init() {
146
147 // first, we need to check for graphic components on the TOP or BOTTOM baselines. So
148 // we perform the work that used to be in getMetrics here.
149
150 float ascent = 0;
151 float descent = 0;
152 float leading = 0;
153 float advance = 0;
154
155 // ascent + descent must not be less than this value
156 float maxGraphicHeight = 0;
157 float maxGraphicHeightWithLeading = 0;
158
159 // walk through EGA's
160 TextLineComponent tlc;
161 boolean fitTopAndBottomGraphics = false;
162
163 isSimple = true;
164
165 for (int i = 0; i < fComponents.length; i++) {
166 tlc = fComponents[i];
167
168 isSimple &= tlc.isSimple();
169
170 CoreMetrics cm = tlc.getCoreMetrics();
171
172 byte baseline = (byte)cm.baselineIndex;
173
174 if (baseline >= 0) {
175 float baselineOffset = fBaselineOffsets[baseline];
176
177 ascent = Math.max(ascent, -baselineOffset + cm.ascent);
178
179 float gd = baselineOffset + cm.descent;
180 descent = Math.max(descent, gd);
181
182 leading = Math.max(leading, gd + cm.leading);
183 }
184 else {
185 fitTopAndBottomGraphics = true;
186 float graphicHeight = cm.ascent + cm.descent;
187 float graphicHeightWithLeading = graphicHeight + cm.leading;
188 maxGraphicHeight = Math.max(maxGraphicHeight, graphicHeight);
189 maxGraphicHeightWithLeading = Math.max(maxGraphicHeightWithLeading,
190 graphicHeightWithLeading);
191 }
192 }
193
194 if (fitTopAndBottomGraphics) {
195 if (maxGraphicHeight > ascent + descent) {
196 descent = maxGraphicHeight - ascent;
197 }
198 if (maxGraphicHeightWithLeading > ascent + leading) {
199 leading = maxGraphicHeightWithLeading - ascent;
200 }
201 }
202
203 leading -= descent;
204
205 // we now know enough to compute the locs, but we need the final loc
206 // for the advance before we can create the metrics object
207
208 if (fitTopAndBottomGraphics) {
209 // we have top or bottom baselines, so expand the baselines array
210 // full offsets are needed by CoreMetrics.effectiveBaselineOffset
211 fBaselineOffsets = new float[] {
212 fBaselineOffsets[0],
213 fBaselineOffsets[1],
214 fBaselineOffsets[2],
215 descent,
216 -ascent
217 };
218 }
219
220 float x = 0;
221 float y = 0;
222 CoreMetrics pcm = null;
223
224 boolean needPath = false;
225 locs = new float[fComponents.length * 2 + 2];
226
227 for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {
228 tlc = fComponents[getComponentLogicalIndex(i)];
229 CoreMetrics cm = tlc.getCoreMetrics();
230
231 if ((pcm != null) &&
232 (pcm.italicAngle != 0 || cm.italicAngle != 0) && // adjust because of italics
233 (pcm.italicAngle != cm.italicAngle ||
234 pcm.baselineIndex != cm.baselineIndex ||
235 pcm.ssOffset != cm.ssOffset)) {
236
237 // 1) compute the area of overlap - min effective ascent and min effective descent
238 // 2) compute the x positions along italic angle of ascent and descent for left and right
239 // 3) compute maximum left - right, adjust right position by this value
240 // this is a crude form of kerning between textcomponents
241
242 // note glyphvectors preposition glyphs based on offset,
243 // so tl doesn't need to adjust glyphvector position
244 // 1)
245 float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);
246 float pa = pb - pcm.ascent;
247 float pd = pb + pcm.descent;
248 // pb += pcm.ssOffset;
249
250 float cb = cm.effectiveBaselineOffset(fBaselineOffsets);
251 float ca = cb - cm.ascent;
252 float cd = cb + cm.descent;
253 // cb += cm.ssOffset;
254
255 float a = Math.max(pa, ca);
256 float d = Math.min(pd, cd);
257
258 // 2)
259 float pax = pcm.italicAngle * (pb - a);
260 float pdx = pcm.italicAngle * (pb - d);
261
262 float cax = cm.italicAngle * (cb - a);
263 float cdx = cm.italicAngle * (cb - d);
264
265 // 3)
266 float dax = pax - cax;
267 float ddx = pdx - cdx;
268 float dx = Math.max(dax, ddx);
269
270 x += dx;
271 y = cb;
272 } else {
273 // no italic adjustment for x, but still need to compute y
274 y = cm.effectiveBaselineOffset(fBaselineOffsets); // + cm.ssOffset;
275 }
276
277 locs[n] = x;
278 locs[n+1] = y;
279
280 x += tlc.getAdvance();
281 pcm = cm;
282
283 needPath |= tlc.getBaselineTransform() != null;
284 }
285
286 // do we want italic padding at the right of the line?
287 if (pcm.italicAngle != 0) {
288 float pb = pcm.effectiveBaselineOffset(fBaselineOffsets);
289 float pa = pb - pcm.ascent;
290 float pd = pb + pcm.descent;
291 pb += pcm.ssOffset;
292
293 float d;
294 if (pcm.italicAngle > 0) {
295 d = pb + pcm.ascent;
296 } else {
297 d = pb - pcm.descent;
298 }
299 d *= pcm.italicAngle;
300
301 x += d;
302 }
303 locs[locs.length - 2] = x;
304 // locs[locs.length - 1] = 0; // final offset is always back on baseline
305
306 // ok, build fMetrics since we have the final advance
307 advance = x;
308 fMetrics = new TextLineMetrics(ascent, descent, leading, advance);
309
310 // build path if we need it
311 if (needPath) {
312 isSimple = false;
313
314 Point2D.Double pt = new Point2D.Double();
315 double tx = 0, ty = 0;
316 SegmentPathBuilder builder = new SegmentPathBuilder();
317 builder.moveTo(locs[0], 0);
318 for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {
319 tlc = fComponents[getComponentLogicalIndex(i)];
320 AffineTransform at = tlc.getBaselineTransform();
321 if (at != null && ((at.getType() & at.TYPE_TRANSLATION) != 0)) {
322 double dx = at.getTranslateX();
323 double dy = at.getTranslateY();
324 builder.moveTo(tx += dx, ty += dy);
325 }
326 pt.x = locs[n+2] - locs[n];
327 pt.y = 0;
328 if (at != null) {
329 at.deltaTransform(pt, pt);
330 }
331 builder.lineTo(tx += pt.x, ty += pt.y);
332 }
333 lp = builder.complete();
334
335 if (lp == null) { // empty path
336 tlc = fComponents[getComponentLogicalIndex(0)];
337 AffineTransform at = tlc.getBaselineTransform();
338 if (at != null) {
339 lp = new EmptyPath(at);
340 }
341 }
342 }
343 }
344
345 public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {
346 Rectangle result = null;
347
348 // if we have a matching frc, set it to null so we don't have to test it
349 // for each component
350 if (frc != null && frc.equals(this.frc)) {
351 frc = null;
352 }
353
354 // only cache integral locations with the default frc, this is a bit strict
355 int ix = (int)Math.floor(x);
356 int iy = (int)Math.floor(y);
357 float rx = x - ix;
358 float ry = y - iy;
359 boolean canCache = frc == null && rx == 0 && ry == 0;
360
361 if (canCache && pixelBounds != null) {
362 result = new Rectangle(pixelBounds);
363 result.x += ix;
364 result.y += iy;
365 return result;
366 }
367
368 // couldn't use cache, or didn't have it, so compute
369
370 if (isSimple) { // all glyphvectors with no decorations, no layout path
371 for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
372 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
373 Rectangle pb = tlc.getPixelBounds(frc, locs[n] + rx, locs[n+1] + ry);
374 if (!pb.isEmpty()) {
375 if (result == null) {
376 result = pb;
377 } else {
378 result.add(pb);
379 }
380 }
381 }
382 if (result == null) {
383 result = new Rectangle(0, 0, 0, 0);
384 }
385 } else { // draw and test
386 final int MARGIN = 3;
387 Rectangle2D r2d = getVisualBounds();
388 if (lp != null) {
389 r2d = lp.mapShape(r2d).getBounds();
390 }
391 Rectangle bounds = r2d.getBounds();
392 BufferedImage im = new BufferedImage(bounds.width + MARGIN * 2,
393 bounds.height + MARGIN * 2,
394 BufferedImage.TYPE_INT_ARGB);
395
396 Graphics2D g2d = im.createGraphics();
397 g2d.setColor(Color.WHITE);
398 g2d.fillRect(0, 0, im.getWidth(), im.getHeight());
399
400 g2d.setColor(Color.BLACK);
401 draw(g2d, rx + MARGIN - bounds.x, ry + MARGIN - bounds.y);
402
403 result = computePixelBounds(im);
404 result.x -= MARGIN - bounds.x;
405 result.y -= MARGIN - bounds.y;
406 }
407
408 if (canCache) {
409 pixelBounds = new Rectangle(result);
410 }
411
412 result.x += ix;
413 result.y += iy;
414 return result;
415 }
416
417 static Rectangle computePixelBounds(BufferedImage im) {
418 int w = im.getWidth();
419 int h = im.getHeight();
420
421 int l = -1, t = -1, r = w, b = h;
422
423 {
424 // get top
425 int[] buf = new int[w];
426 loop: while (++t < h) {
427 im.getRGB(0, t, buf.length, 1, buf, 0, w); // w ignored
428 for (int i = 0; i < buf.length; i++) {
429 if (buf[i] != -1) {
430 break loop;
431 }
432 }
433 }
434 }
435
436 // get bottom
437 {
438 int[] buf = new int[w];
439 loop: while (--b > t) {
440 im.getRGB(0, b, buf.length, 1, buf, 0, w); // w ignored
441 for (int i = 0; i < buf.length; ++i) {
442 if (buf[i] != -1) {
443 break loop;
444 }
445 }
446 }
447 ++b;
448 }
449
450 // get left
451 {
452 loop: while (++l < r) {
453 for (int i = t; i < b; ++i) {
454 int v = im.getRGB(l, i);
455 if (v != -1) {
456 break loop;
457 }
458 }
459 }
460 }
461
462 // get right
463 {
464 loop: while (--r > l) {
465 for (int i = t; i < b; ++i) {
466 int v = im.getRGB(r, i);
467 if (v != -1) {
468 break loop;
469 }
470 }
471 }
472 ++r;
473 }
474
475 return new Rectangle(l, t, r-l, b-t);
476 }
477
478 private abstract static class Function {
479
480 abstract float computeFunction(TextLine line,
481 int componentIndex,
482 int indexInArray);
483 }
484
485 private static Function fgPosAdvF = new Function() {
486 float computeFunction(TextLine line,
487 int componentIndex,
488 int indexInArray) {
489
490 TextLineComponent tlc = line.fComponents[componentIndex];
491 int vi = line.getComponentVisualIndex(componentIndex);
492 return line.locs[vi * 2] + tlc.getCharX(indexInArray) + tlc.getCharAdvance(indexInArray);
493 }
494 };
495
496 private static Function fgAdvanceF = new Function() {
497
498 float computeFunction(TextLine line,
499 int componentIndex,
500 int indexInArray) {
501
502 TextLineComponent tlc = line.fComponents[componentIndex];
503 return tlc.getCharAdvance(indexInArray);
504 }
505 };
506
507 private static Function fgXPositionF = new Function() {
508
509 float computeFunction(TextLine line,
510 int componentIndex,
511 int indexInArray) {
512
513 int vi = line.getComponentVisualIndex(componentIndex);
514 TextLineComponent tlc = line.fComponents[componentIndex];
515 return line.locs[vi * 2] + tlc.getCharX(indexInArray);
516 }
517 };
518
519 private static Function fgYPositionF = new Function() {
520
521 float computeFunction(TextLine line,
522 int componentIndex,
523 int indexInArray) {
524
525 TextLineComponent tlc = line.fComponents[componentIndex];
526 float charPos = tlc.getCharY(indexInArray);
527
528 // charPos is relative to the component - adjust for
529 // baseline
530
531 return charPos + line.getComponentShift(componentIndex);
532 }
533 };
534
535 public int characterCount() {
536
537 return fCharsLimit - fCharsStart;
538 }
539
540 public boolean isDirectionLTR() {
541
542 return fIsDirectionLTR;
543 }
544
545 public TextLineMetrics getMetrics() {
546 return fMetrics;
547 }
548
549 public int visualToLogical(int visualIndex) {
550
551 if (fCharLogicalOrder == null) {
552 return visualIndex;
553 }
554
555 if (fCharVisualOrder == null) {
556 fCharVisualOrder = BidiUtils.createInverseMap(fCharLogicalOrder);
557 }
558
559 return fCharVisualOrder[visualIndex];
560 }
561
562 public int logicalToVisual(int logicalIndex) {
563
564 return (fCharLogicalOrder == null)?
565 logicalIndex : fCharLogicalOrder[logicalIndex];
566 }
567
568 public byte getCharLevel(int logicalIndex) {
569
570 return fCharLevels==null? 0 : fCharLevels[logicalIndex];
571 }
572
573 public boolean isCharLTR(int logicalIndex) {
574
575 return (getCharLevel(logicalIndex) & 0x1) == 0;
576 }
577
578 public int getCharType(int logicalIndex) {
579
580 return Character.getType(fChars[logicalIndex + fCharsStart]);
581 }
582
583 public boolean isCharSpace(int logicalIndex) {
584
585 return Character.isSpaceChar(fChars[logicalIndex + fCharsStart]);
586 }
587
588 public boolean isCharWhitespace(int logicalIndex) {
589
590 return Character.isWhitespace(fChars[logicalIndex + fCharsStart]);
591 }
592
593 public float getCharAngle(int logicalIndex) {
594
595 return getCoreMetricsAt(logicalIndex).italicAngle;
596 }
597
598 public CoreMetrics getCoreMetricsAt(int logicalIndex) {
599
600 if (logicalIndex < 0) {
601 throw new IllegalArgumentException("Negative logicalIndex.");
602 }
603
604 if (logicalIndex > fCharsLimit - fCharsStart) {
605 throw new IllegalArgumentException("logicalIndex too large.");
606 }
607
608 int currentTlc = 0;
609 int tlcStart = 0;
610 int tlcLimit = 0;
611
612 do {
613 tlcLimit += fComponents[currentTlc].getNumCharacters();
614 if (tlcLimit > logicalIndex) {
615 break;
616 }
617 ++currentTlc;
618 tlcStart = tlcLimit;
619 } while(currentTlc < fComponents.length);
620
621 return fComponents[currentTlc].getCoreMetrics();
622 }
623
624 public float getCharAscent(int logicalIndex) {
625
626 return getCoreMetricsAt(logicalIndex).ascent;
627 }
628
629 public float getCharDescent(int logicalIndex) {
630
631 return getCoreMetricsAt(logicalIndex).descent;
632 }
633
634 public float getCharShift(int logicalIndex) {
635
636 return getCoreMetricsAt(logicalIndex).ssOffset;
637 }
638
639 private float applyFunctionAtIndex(int logicalIndex, Function f) {
640
641 if (logicalIndex < 0) {
642 throw new IllegalArgumentException("Negative logicalIndex.");
643 }
644
645 int tlcStart = 0;
646
647 for(int i=0; i < fComponents.length; i++) {
648
649 int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
650 if (tlcLimit > logicalIndex) {
651 return f.computeFunction(this, i, logicalIndex - tlcStart);
652 }
653 else {
654 tlcStart = tlcLimit;
655 }
656 }
657
658 throw new IllegalArgumentException("logicalIndex too large.");
659 }
660
661 public float getCharAdvance(int logicalIndex) {
662
663 return applyFunctionAtIndex(logicalIndex, fgAdvanceF);
664 }
665
666 public float getCharXPosition(int logicalIndex) {
667
668 return applyFunctionAtIndex(logicalIndex, fgXPositionF);
669 }
670
671 public float getCharYPosition(int logicalIndex) {
672
673 return applyFunctionAtIndex(logicalIndex, fgYPositionF);
674 }
675
676 public float getCharLinePosition(int logicalIndex) {
677
678 return getCharXPosition(logicalIndex);
679 }
680
681 public float getCharLinePosition(int logicalIndex, boolean leading) {
682 Function f = isCharLTR(logicalIndex) == leading ? fgXPositionF : fgPosAdvF;
683 return applyFunctionAtIndex(logicalIndex, f);
684 }
685
686 public boolean caretAtOffsetIsValid(int offset) {
687
688 if (offset < 0) {
689 throw new IllegalArgumentException("Negative offset.");
690 }
691
692 int tlcStart = 0;
693
694 for(int i=0; i < fComponents.length; i++) {
695
696 int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
697 if (tlcLimit > offset) {
698 return fComponents[i].caretAtOffsetIsValid(offset-tlcStart);
699 }
700 else {
701 tlcStart = tlcLimit;
702 }
703 }
704
705 throw new IllegalArgumentException("logicalIndex too large.");
706 }
707
708 /**
709 * map a component visual index to the logical index.
710 */
711 private int getComponentLogicalIndex(int vi) {
712 if (fComponentVisualOrder == null) {
713 return vi;
714 }
715 return fComponentVisualOrder[vi];
716 }
717
718 /**
719 * map a component logical index to the visual index.
720 */
721 private int getComponentVisualIndex(int li) {
722 if (fComponentVisualOrder == null) {
723 return li;
724 }
725 for (int i = 0; i < fComponentVisualOrder.length; ++i) {
726 if (fComponentVisualOrder[i] == li) {
727 return i;
728 }
729 }
730 throw new IndexOutOfBoundsException("bad component index: " + li);
731 }
732
733 public Rectangle2D getCharBounds(int logicalIndex) {
734
735 if (logicalIndex < 0) {
736 throw new IllegalArgumentException("Negative logicalIndex.");
737 }
738
739 int tlcStart = 0;
740
741 for (int i=0; i < fComponents.length; i++) {
742
743 int tlcLimit = tlcStart + fComponents[i].getNumCharacters();
744 if (tlcLimit > logicalIndex) {
745
746 TextLineComponent tlc = fComponents[i];
747 int indexInTlc = logicalIndex - tlcStart;
748 Rectangle2D chBounds = tlc.getCharVisualBounds(indexInTlc);
749
750 int vi = getComponentVisualIndex(i);
751 chBounds.setRect(chBounds.getX() + locs[vi * 2],
752 chBounds.getY() + locs[vi * 2 + 1],
753 chBounds.getWidth(),
754 chBounds.getHeight());
755 return chBounds;
756 }
757 else {
758 tlcStart = tlcLimit;
759 }
760 }
761
762 throw new IllegalArgumentException("logicalIndex too large.");
763 }
764
765 private float getComponentShift(int index) {
766 CoreMetrics cm = fComponents[index].getCoreMetrics();
767 return cm.effectiveBaselineOffset(fBaselineOffsets);
768 }
769
770 public void draw(Graphics2D g2, float x, float y) {
771 if (lp == null) {
772 for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
773 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
774 tlc.draw(g2, locs[n] + x, locs[n+1] + y);
775 }
776 } else {
777 AffineTransform oldTx = g2.getTransform();
778 Point2D.Float pt = new Point2D.Float();
779 for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
780 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
781 lp.pathToPoint(locs[n], locs[n+1], false, pt);
782 pt.x += x;
783 pt.y += y;
784 AffineTransform at = tlc.getBaselineTransform();
785
786 if (at != null) {
787 g2.translate(pt.x - at.getTranslateX(), pt.y - at.getTranslateY());
788 g2.transform(at);
789 tlc.draw(g2, 0, 0);
790 g2.setTransform(oldTx);
791 } else {
792 tlc.draw(g2, pt.x, pt.y);
793 }
794 }
795 }
796 }
797
798 /**
799 * Return the union of the visual bounds of all the components.
800 * This incorporates the path. It does not include logical
801 * bounds (used by carets).
802 */
803 public Rectangle2D getVisualBounds() {
804 Rectangle2D result = null;
805
806 for (int i = 0, n = 0; i < fComponents.length; i++, n += 2) {
807 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
808 Rectangle2D r = tlc.getVisualBounds();
809
810 Point2D.Float pt = new Point2D.Float(locs[n], locs[n+1]);
811 if (lp == null) {
812 r.setRect(r.getMinX() + pt.x, r.getMinY() + pt.y,
813 r.getWidth(), r.getHeight());
814 } else {
815 lp.pathToPoint(pt, false, pt);
816
817 AffineTransform at = tlc.getBaselineTransform();
818 if (at != null) {
819 AffineTransform tx = AffineTransform.getTranslateInstance
820 (pt.x - at.getTranslateX(), pt.y - at.getTranslateY());
821 tx.concatenate(at);
822 r = tx.createTransformedShape(r).getBounds2D();
823 } else {
824 r.setRect(r.getMinX() + pt.x, r.getMinY() + pt.y,
825 r.getWidth(), r.getHeight());
826 }
827 }
828
829 if (result == null) {
830 result = r;
831 } else {
832 result.add(r);
833 }
834 }
835
836 if (result == null) {
837 result = new Rectangle2D.Float(Float.MAX_VALUE, Float.MAX_VALUE, Float.MIN_VALUE, Float.MIN_VALUE);
838 }
839
840 return result;
841 }
842
843 public Rectangle2D getItalicBounds() {
844
845 float left = Float.MAX_VALUE, right = -Float.MAX_VALUE;
846 float top = Float.MAX_VALUE, bottom = -Float.MAX_VALUE;
847
848 for (int i=0, n = 0; i < fComponents.length; i++, n += 2) {
849 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
850
851 Rectangle2D tlcBounds = tlc.getItalicBounds();
852 float x = locs[n];
853 float y = locs[n+1];
854
855 left = Math.min(left, x + (float)tlcBounds.getX());
856 right = Math.max(right, x + (float)tlcBounds.getMaxX());
857
858 top = Math.min(top, y + (float)tlcBounds.getY());
859 bottom = Math.max(bottom, y + (float)tlcBounds.getMaxY());
860 }
861
862 return new Rectangle2D.Float(left, top, right-left, bottom-top);
863 }
864
865 public Shape getOutline(AffineTransform tx) {
866
867 GeneralPath dstShape = new GeneralPath(GeneralPath.WIND_NON_ZERO);
868
869 for (int i=0, n = 0; i < fComponents.length; i++, n += 2) {
870 TextLineComponent tlc = fComponents[getComponentLogicalIndex(i)];
871
872 dstShape.append(tlc.getOutline(locs[n], locs[n+1]), false);
873 }
874
875 if (tx != null) {
876 dstShape.transform(tx);
877 }
878 return dstShape;
879 }
880
881 public int hashCode() {
882 return (fComponents.length << 16) ^
883 (fComponents[0].hashCode() << 3) ^ (fCharsLimit-fCharsStart);
884 }
885
886 public String toString() {
887 StringBuilder buf = new StringBuilder();
888
889 for (int i = 0; i < fComponents.length; i++) {
890 buf.append(fComponents[i]);
891 }
892
893 return buf.toString();
894 }
895
896 /**
897 * Create a TextLine from the text. The Font must be able to
898 * display all of the text.
899 * attributes==null is equivalent to using an empty Map for
900 * attributes
901 */
902 public static TextLine fastCreateTextLine(FontRenderContext frc,
903 char[] chars,
904 Font font,
905 CoreMetrics lm,
906 Map attributes) {
907
908 boolean isDirectionLTR = true;
909 byte[] levels = null;
910 int[] charsLtoV = null;
911 Bidi bidi = null;
912 int characterCount = chars.length;
913
914 boolean requiresBidi = false;
915 byte[] embs = null;
916
917 AttributeValues values = null;
918 if (attributes != null) {
919 values = AttributeValues.fromMap(attributes);
920 if (values.getRunDirection() >= 0) {
921 isDirectionLTR = values.getRunDirection() == 0;
922 requiresBidi = !isDirectionLTR;
923 }
924 if (values.getBidiEmbedding() != 0) {
925 requiresBidi = true;
926 byte level = (byte)values.getBidiEmbedding();
927 embs = new byte[characterCount];
928 for (int i = 0; i < embs.length; ++i) {
929 embs[i] = level;
930 }
931 }
932 }
933
934 // dlf: get baseRot from font for now???
935
936 if (!requiresBidi) {
937 requiresBidi = Bidi.requiresBidi(chars, 0, chars.length);
938 }
939
940 if (requiresBidi) {
941 int bidiflags = values == null
942 ? Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT
943 : values.getRunDirection();
944
945 bidi = new Bidi(chars, 0, embs, 0, chars.length, bidiflags);
946 if (!bidi.isLeftToRight()) {
947 levels = BidiUtils.getLevels(bidi);
948 int[] charsVtoL = BidiUtils.createVisualToLogicalMap(levels);
949 charsLtoV = BidiUtils.createInverseMap(charsVtoL);
950 isDirectionLTR = bidi.baseIsLeftToRight();
951 }
952 }
953
954 Decoration decorator = Decoration.getDecoration(values);
955
956 int layoutFlags = 0; // no extra info yet, bidi determines run and line direction
957 TextLabelFactory factory = new TextLabelFactory(frc, chars, bidi, layoutFlags);
958
959 TextLineComponent[] components = new TextLineComponent[1];
960
961 components = createComponentsOnRun(0, chars.length,
962 chars,
963 charsLtoV, levels,
964 factory, font, lm,
965 frc,
966 decorator,
967 components,
968 0);
969
970 int numComponents = components.length;
971 while (components[numComponents-1] == null) {
972 numComponents -= 1;
973 }
974
975 if (numComponents != components.length) {
976 TextLineComponent[] temp = new TextLineComponent[numComponents];
977 System.arraycopy(components, 0, temp, 0, numComponents);
978 components = temp;
979 }
980
981 return new TextLine(frc, components, lm.baselineOffsets,
982 chars, 0, chars.length, charsLtoV, levels, isDirectionLTR);
983 }
984
985 private static TextLineComponent[] expandArray(TextLineComponent[] orig) {
986
987 TextLineComponent[] newComponents = new TextLineComponent[orig.length + 8];
988 System.arraycopy(orig, 0, newComponents, 0, orig.length);
989
990 return newComponents;
991 }
992
993 /**
994 * Returns an array in logical order of the TextLineComponents on
995 * the text in the given range, with the given attributes.
996 */
997 public static TextLineComponent[] createComponentsOnRun(int runStart,
998 int runLimit,
999 char[] chars,
1000 int[] charsLtoV,
1001 byte[] levels,
1002 TextLabelFactory factory,
1003 Font font,
1004 CoreMetrics cm,
1005 FontRenderContext frc,
1006 Decoration decorator,
1007 TextLineComponent[] components,
1008 int numComponents) {
1009
1010 int pos = runStart;
1011 do {
1012 int chunkLimit = firstVisualChunk(charsLtoV, levels, pos, runLimit); // <= displayLimit
1013
1014 do {
1015 int startPos = pos;
1016 int lmCount;
1017
1018 if (cm == null) {
1019 LineMetrics lineMetrics = font.getLineMetrics(chars, startPos, chunkLimit, frc);
1020 cm = CoreMetrics.get(lineMetrics);
1021 lmCount = lineMetrics.getNumChars();
1022 }
1023 else {
1024 lmCount = (chunkLimit-startPos);
1025 }
1026
1027 TextLineComponent nextComponent =
1028 factory.createExtended(font, cm, decorator, startPos, startPos + lmCount);
1029
1030 ++numComponents;
1031 if (numComponents >= components.length) {
1032 components = expandArray(components);
1033 }
1034
1035 components[numComponents-1] = nextComponent;
1036
1037 pos += lmCount;
1038 } while (pos < chunkLimit);
1039
1040 } while (pos < runLimit);
1041
1042 return components;
1043 }
1044
1045 /**
1046 * Returns an array (in logical order) of the TextLineComponents representing
1047 * the text. The components are both logically and visually contiguous.
1048 */
1049 public static TextLineComponent[] getComponents(StyledParagraph styledParagraph,
1050 char[] chars,
1051 int textStart,
1052 int textLimit,
1053 int[] charsLtoV,
1054 byte[] levels,
1055 TextLabelFactory factory) {
1056
1057 FontRenderContext frc = factory.getFontRenderContext();
1058
1059 int numComponents = 0;
1060 TextLineComponent[] tempComponents = new TextLineComponent[1];
1061
1062 int pos = textStart;
1063 do {
1064 int runLimit = Math.min(styledParagraph.getRunLimit(pos), textLimit);
1065
1066 Decoration decorator = styledParagraph.getDecorationAt(pos);
1067
1068 Object graphicOrFont = styledParagraph.getFontOrGraphicAt(pos);
1069
1070 if (graphicOrFont instanceof GraphicAttribute) {
1071 // AffineTransform baseRot = styledParagraph.getBaselineRotationAt(pos);
1072 // !!! For now, let's assign runs of text with both fonts and graphic attributes
1073 // a null rotation (e.g. the baseline rotation goes away when a graphic
1074 // is applied.
1075 AffineTransform baseRot = null;
1076 GraphicAttribute graphicAttribute = (GraphicAttribute) graphicOrFont;
1077 do {
1078 int chunkLimit = firstVisualChunk(charsLtoV, levels,
1079 pos, runLimit);
1080
1081 GraphicComponent nextGraphic =
1082 new GraphicComponent(graphicAttribute, decorator, charsLtoV, levels, pos, chunkLimit, baseRot);
1083 pos = chunkLimit;
1084
1085 ++numComponents;
1086 if (numComponents >= tempComponents.length) {
1087 tempComponents = expandArray(tempComponents);
1088 }
1089
1090 tempComponents[numComponents-1] = nextGraphic;
1091
1092 } while(pos < runLimit);
1093 }
1094 else {
1095 Font font = (Font) graphicOrFont;
1096
1097 tempComponents = createComponentsOnRun(pos, runLimit,
1098 chars,
1099 charsLtoV, levels,
1100 factory, font, null,
1101 frc,
1102 decorator,
1103 tempComponents,
1104 numComponents);
1105 pos = runLimit;
1106 numComponents = tempComponents.length;
1107 while (tempComponents[numComponents-1] == null) {
1108 numComponents -= 1;
1109 }
1110 }
1111
1112 } while (pos < textLimit);
1113
1114 TextLineComponent[] components;
1115 if (tempComponents.length == numComponents) {
1116 components = tempComponents;
1117 }
1118 else {
1119 components = new TextLineComponent[numComponents];
1120 System.arraycopy(tempComponents, 0, components, 0, numComponents);
1121 }
1122
1123 return components;
1124 }
1125
1126 /**
1127 * Create a TextLine from the Font and character data over the
1128 * range. The range is relative to both the StyledParagraph and the
1129 * character array.
1130 */
1131 public static TextLine createLineFromText(char[] chars,
1132 StyledParagraph styledParagraph,
1133 TextLabelFactory factory,
1134 boolean isDirectionLTR,
1135 float[] baselineOffsets) {
1136
1137 factory.setLineContext(0, chars.length);
1138
1139 Bidi lineBidi = factory.getLineBidi();
1140 int[] charsLtoV = null;
1141 byte[] levels = null;
1142
1143 if (lineBidi != null) {
1144 levels = BidiUtils.getLevels(lineBidi);
1145 int[] charsVtoL = BidiUtils.createVisualToLogicalMap(levels);
1146 charsLtoV = BidiUtils.createInverseMap(charsVtoL);
1147 }
1148
1149 TextLineComponent[] components =
1150 getComponents(styledParagraph, chars, 0, chars.length, charsLtoV, levels, factory);
1151
1152 return new TextLine(factory.getFontRenderContext(), components, baselineOffsets,
1153 chars, 0, chars.length, charsLtoV, levels, isDirectionLTR);
1154 }
1155
1156 /**
1157 * Compute the components order from the given components array and
1158 * logical-to-visual character mapping. May return null if canonical.
1159 */
1160 private static int[] computeComponentOrder(TextLineComponent[] components,
1161 int[] charsLtoV) {
1162
1163 /*
1164 * Create a visual ordering for the glyph sets. The important thing
1165 * here is that the values have the proper rank with respect to
1166 * each other, not the exact values. For example, the first glyph
1167 * set that appears visually should have the lowest value. The last
1168 * should have the highest value. The values are then normalized
1169 * to map 1-1 with positions in glyphs.
1170 *
1171 */
1172 int[] componentOrder = null;
1173 if (charsLtoV != null && components.length > 1) {
1174 componentOrder = new int[components.length];
1175 int gStart = 0;
1176 for (int i = 0; i < components.length; i++) {
1177 componentOrder[i] = charsLtoV[gStart];
1178 gStart += components[i].getNumCharacters();
1179 }
1180
1181 componentOrder = BidiUtils.createContiguousOrder(componentOrder);
1182 componentOrder = BidiUtils.createInverseMap(componentOrder);
1183 }
1184 return componentOrder;
1185 }
1186
1187
1188 /**
1189 * Create a TextLine from the text. chars is just the text in the iterator.
1190 */
1191 public static TextLine standardCreateTextLine(FontRenderContext frc,
1192 AttributedCharacterIterator text,
1193 char[] chars,
1194 float[] baselineOffsets) {
1195
1196 StyledParagraph styledParagraph = new StyledParagraph(text, chars);
1197 Bidi bidi = new Bidi(text);
1198 if (bidi.isLeftToRight()) {
1199 bidi = null;
1200 }
1201 int layoutFlags = 0; // no extra info yet, bidi determines run and line direction
1202 TextLabelFactory factory = new TextLabelFactory(frc, chars, bidi, layoutFlags);
1203
1204 boolean isDirectionLTR = true;
1205 if (bidi != null) {
1206 isDirectionLTR = bidi.baseIsLeftToRight();
1207 }
1208 return createLineFromText(chars, styledParagraph, factory, isDirectionLTR, baselineOffsets);
1209 }
1210
1211
1212
1213 /*
1214 * A utility to get a range of text that is both logically and visually
1215 * contiguous.
1216 * If the entire range is ok, return limit, otherwise return the first
1217 * directional change after start. We could do better than this, but
1218 * it doesn't seem worth it at the moment.
1219 private static int firstVisualChunk(int order[], byte direction[],
1220 int start, int limit)
1221 {
1222 if (order != null) {
1223 int min = order[start];
1224 int max = order[start];
1225 int count = limit - start;
1226 for (int i = start + 1; i < limit; i++) {
1227 min = Math.min(min, order[i]);
1228 max = Math.max(max, order[i]);
1229 if (max - min >= count) {
1230 if (direction != null) {
1231 byte baseLevel = direction[start];
1232 for (int j = start + 1; j < i; j++) {
1233 if (direction[j] != baseLevel) {
1234 return j;
1235 }
1236 }
1237 }
1238 return i;
1239 }
1240 }
1241 }
1242 return limit;
1243 }
1244 */
1245
1246 /**
1247 * When this returns, the ACI's current position will be at the start of the
1248 * first run which does NOT contain a GraphicAttribute. If no such run exists
1249 * the ACI's position will be at the end, and this method will return false.
1250 */
1251 static boolean advanceToFirstFont(AttributedCharacterIterator aci) {
1252
1253 for (char ch = aci.first(); ch != aci.DONE; ch = aci.setIndex(aci.getRunLimit())) {
1254
1255 if (aci.getAttribute(TextAttribute.CHAR_REPLACEMENT) == null) {
1256 return true;
1257 }
1258 }
1259
1260 return false;
1261 }
1262
1263 static float[] getNormalizedOffsets(float[] baselineOffsets, byte baseline) {
1264
1265 if (baselineOffsets[baseline] != 0) {
1266 float base = baselineOffsets[baseline];
1267 float[] temp = new float[baselineOffsets.length];
1268 for (int i = 0; i < temp.length; i++)
1269 temp[i] = baselineOffsets[i] - base;
1270 baselineOffsets = temp;
1271 }
1272 return baselineOffsets;
1273 }
1274
1275 static Font getFontAtCurrentPos(AttributedCharacterIterator aci) {
1276
1277 Object value = aci.getAttribute(TextAttribute.FONT);
1278 if (value != null) {
1279 return (Font) value;
1280 }
1281 if (aci.getAttribute(TextAttribute.FAMILY) != null) {
1282 return Font.getFont(aci.getAttributes());
1283 }
1284
1285 int ch = CodePointIterator.create(aci).next();
1286 if (ch != CodePointIterator.DONE) {
1287 FontResolver resolver = FontResolver.getInstance();
1288 return resolver.getFont(resolver.getFontIndex(ch), aci.getAttributes());
1289 }
1290 return null;
1291 }
1292
1293 /*
1294 * The new version requires that chunks be at the same level.
1295 */
1296 private static int firstVisualChunk(int order[], byte direction[],
1297 int start, int limit)
1298 {
1299 if (order != null && direction != null) {
1300 byte dir = direction[start];
1301 while (++start < limit && direction[start] == dir) {}
1302 return start;
1303 }
1304 return limit;
1305 }
1306
1307 /*
1308 * create a new line with characters between charStart and charLimit
1309 * justified using the provided width and ratio.
1310 */
1311 public TextLine getJustifiedLine(float justificationWidth, float justifyRatio, int justStart, int justLimit) {
1312
1313 TextLineComponent[] newComponents = new TextLineComponent[fComponents.length];
1314 System.arraycopy(fComponents, 0, newComponents, 0, fComponents.length);
1315
1316 float leftHang = 0;
1317 float adv = 0;
1318 float justifyDelta = 0;
1319 boolean rejustify = false;
1320 do {
1321 adv = getAdvanceBetween(newComponents, 0, characterCount());
1322
1323 // all characters outside the justification range must be in the base direction
1324 // of the layout, otherwise justification makes no sense.
1325
1326 float justifyAdvance = getAdvanceBetween(newComponents, justStart, justLimit);
1327
1328 // get the actual justification delta
1329 justifyDelta = (justificationWidth - justifyAdvance) * justifyRatio;
1330
1331 // generate an array of GlyphJustificationInfo records to pass to
1332 // the justifier. Array is visually ordered.
1333
1334 // get positions that each component will be using
1335 int[] infoPositions = new int[newComponents.length];
1336 int infoCount = 0;
1337 for (int visIndex = 0; visIndex < newComponents.length; visIndex++) {
1338 int logIndex = getComponentLogicalIndex(visIndex);
1339 infoPositions[logIndex] = infoCount;
1340 infoCount += newComponents[logIndex].getNumJustificationInfos();
1341 }
1342 GlyphJustificationInfo[] infos = new GlyphJustificationInfo[infoCount];
1343
1344 // get justification infos
1345 int compStart = 0;
1346 for (int i = 0; i < newComponents.length; i++) {
1347 TextLineComponent comp = newComponents[i];
1348 int compLength = comp.getNumCharacters();
1349 int compLimit = compStart + compLength;
1350 if (compLimit > justStart) {
1351 int rangeMin = Math.max(0, justStart - compStart);
1352 int rangeMax = Math.min(compLength, justLimit - compStart);
1353 comp.getJustificationInfos(infos, infoPositions[i], rangeMin, rangeMax);
1354
1355 if (compLimit >= justLimit) {
1356 break;
1357 }
1358 }
1359 }
1360
1361 // records are visually ordered, and contiguous, so start and end are
1362 // simply the places where we didn't fetch records
1363 int infoStart = 0;
1364 int infoLimit = infoCount;
1365 while (infoStart < infoLimit && infos[infoStart] == null) {
1366 ++infoStart;
1367 }
1368
1369 while (infoLimit > infoStart && infos[infoLimit - 1] == null) {
1370 --infoLimit;
1371 }
1372
1373 // invoke justifier on the records
1374 TextJustifier justifier = new TextJustifier(infos, infoStart, infoLimit);
1375
1376 float[] deltas = justifier.justify(justifyDelta);
1377
1378 boolean canRejustify = rejustify == false;
1379 boolean wantRejustify = false;
1380 boolean[] flags = new boolean[1];
1381
1382 // apply justification deltas
1383 compStart = 0;
1384 for (int i = 0; i < newComponents.length; i++) {
1385 TextLineComponent comp = newComponents[i];
1386 int compLength = comp.getNumCharacters();
1387 int compLimit = compStart + compLength;
1388 if (compLimit > justStart) {
1389 int rangeMin = Math.max(0, justStart - compStart);
1390 int rangeMax = Math.min(compLength, justLimit - compStart);
1391 newComponents[i] = comp.applyJustificationDeltas(deltas, infoPositions[i] * 2, flags);
1392
1393 wantRejustify |= flags[0];
1394
1395 if (compLimit >= justLimit) {
1396 break;
1397 }
1398 }
1399 }
1400
1401 rejustify = wantRejustify && !rejustify; // only make two passes
1402 } while (rejustify);
1403
1404 return new TextLine(frc, newComponents, fBaselineOffsets, fChars, fCharsStart,
1405 fCharsLimit, fCharLogicalOrder, fCharLevels,
1406 fIsDirectionLTR);
1407 }
1408
1409 // return the sum of the advances of text between the logical start and limit
1410 public static float getAdvanceBetween(TextLineComponent[] components, int start, int limit) {
1411 float advance = 0;
1412
1413 int tlcStart = 0;
1414 for(int i = 0; i < components.length; i++) {
1415 TextLineComponent comp = components[i];
1416
1417 int tlcLength = comp.getNumCharacters();
1418 int tlcLimit = tlcStart + tlcLength;
1419 if (tlcLimit > start) {
1420 int measureStart = Math.max(0, start - tlcStart);
1421 int measureLimit = Math.min(tlcLength, limit - tlcStart);
1422 advance += comp.getAdvanceBetween(measureStart, measureLimit);
1423 if (tlcLimit >= limit) {
1424 break;
1425 }
1426 }
1427
1428 tlcStart = tlcLimit;
1429 }
1430
1431 return advance;
1432 }
1433
1434 LayoutPathImpl getLayoutPath() {
1435 return lp;
1436 }
1437}