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/javax/swing/text/ParagraphView.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/swing/text/ParagraphView.java+1201−0
@@ -0,0 +1,1201 @@
1/*
2 * Copyright (c) 1997, 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 */
25package javax.swing.text;
26
27import java.util.Arrays;
28import java.awt.*;
29import java.awt.font.TextAttribute;
30import javax.swing.event.*;
31import javax.swing.SizeRequirements;
32
33/**
34 * View of a simple line-wrapping paragraph that supports
35 * multiple fonts, colors, components, icons, etc. It is
36 * basically a vertical box with a margin around it. The
37 * contents of the box are a bunch of rows which are special
38 * horizontal boxes. This view creates a collection of
39 * views that represent the child elements of the paragraph
40 * element. Each of these views are placed into a row
41 * directly if they will fit, otherwise the <code>breakView</code>
42 * method is called to try and carve the view into pieces
43 * that fit.
44 *
45 * @author Timothy Prinzing
46 * @author Scott Violet
47 * @author Igor Kushnirskiy
48 * @see View
49 */
50public class ParagraphView extends FlowView implements TabExpander {
51
52 /**
53 * Constructs a <code>ParagraphView</code> for the given element.
54 *
55 * @param elem the element that this view is responsible for
56 */
57 public ParagraphView(Element elem) {
58 super(elem, View.Y_AXIS);
59 setPropertiesFromAttributes();
60 Document doc = elem.getDocument();
61 Object i18nFlag = doc.getProperty(AbstractDocument.I18NProperty);
62 if ((i18nFlag != null) && i18nFlag.equals(Boolean.TRUE)) {
63 try {
64 if (i18nStrategy == null) {
65 // the classname should probably come from a property file.
66 String classname = "javax.swing.text.TextLayoutStrategy";
67 ClassLoader loader = getClass().getClassLoader();
68 if (loader != null) {
69 i18nStrategy = loader.loadClass(classname);
70 } else {
71 i18nStrategy = Class.forName(classname);
72 }
73 }
74 Object o = i18nStrategy.newInstance();
75 if (o instanceof FlowStrategy) {
76 strategy = (FlowStrategy) o;
77 }
78 } catch (Throwable e) {
79 throw new StateInvariantError("ParagraphView: Can't create i18n strategy: "
80 + e.getMessage());
81 }
82 }
83 }
84
85 /**
86 * Sets the type of justification.
87 *
88 * @param j one of the following values:
89 * <ul>
90 * <li><code>StyleConstants.ALIGN_LEFT</code>
91 * <li><code>StyleConstants.ALIGN_CENTER</code>
92 * <li><code>StyleConstants.ALIGN_RIGHT</code>
93 * </ul>
94 */
95 protected void setJustification(int j) {
96 justification = j;
97 }
98
99 /**
100 * Sets the line spacing.
101 *
102 * @param ls the value is a factor of the line hight
103 */
104 protected void setLineSpacing(float ls) {
105 lineSpacing = ls;
106 }
107
108 /**
109 * Sets the indent on the first line.
110 *
111 * @param fi the value in points
112 */
113 protected void setFirstLineIndent(float fi) {
114 firstLineIndent = (int) fi;
115 }
116
117 /**
118 * Set the cached properties from the attributes.
119 */
120 protected void setPropertiesFromAttributes() {
121 AttributeSet attr = getAttributes();
122 if (attr != null) {
123 setParagraphInsets(attr);
124 Integer a = (Integer)attr.getAttribute(StyleConstants.Alignment);
125 int alignment;
126 if (a == null) {
127 Document doc = getElement().getDocument();
128 Object o = doc.getProperty(TextAttribute.RUN_DIRECTION);
129 if ((o != null) && o.equals(TextAttribute.RUN_DIRECTION_RTL)) {
130 alignment = StyleConstants.ALIGN_RIGHT;
131 } else {
132 alignment = StyleConstants.ALIGN_LEFT;
133 }
134 } else {
135 alignment = a.intValue();
136 }
137 setJustification(alignment);
138 setLineSpacing(StyleConstants.getLineSpacing(attr));
139 setFirstLineIndent(StyleConstants.getFirstLineIndent(attr));
140 }
141 }
142
143 /**
144 * Returns the number of views that this view is
145 * responsible for.
146 * The child views of the paragraph are rows which
147 * have been used to arrange pieces of the <code>View</code>s
148 * that represent the child elements. This is the number
149 * of views that have been tiled in two dimensions,
150 * and should be equivalent to the number of child elements
151 * to the element this view is responsible for.
152 *
153 * @return the number of views that this <code>ParagraphView</code>
154 * is responsible for
155 */
156 protected int getLayoutViewCount() {
157 return layoutPool.getViewCount();
158 }
159
160 /**
161 * Returns the view at a given <code>index</code>.
162 * The child views of the paragraph are rows which
163 * have been used to arrange pieces of the <code>Views</code>
164 * that represent the child elements. This methods returns
165 * the view responsible for the child element index
166 * (prior to breaking). These are the Views that were
167 * produced from a factory (to represent the child
168 * elements) and used for layout.
169 *
170 * @param index the <code>index</code> of the desired view
171 * @return the view at <code>index</code>
172 */
173 protected View getLayoutView(int index) {
174 return layoutPool.getView(index);
175 }
176
177 /**
178 * Returns the next visual position for the cursor, in
179 * either the east or west direction.
180 * Overridden from <code>CompositeView</code>.
181 * @param pos position into the model
182 * @param b either <code>Position.Bias.Forward</code> or
183 * <code>Position.Bias.Backward</code>
184 * @param a the allocated region to render into
185 * @param direction either <code>SwingConstants.NORTH</code>
186 * or <code>SwingConstants.SOUTH</code>
187 * @param biasRet an array containing the bias that were checked
188 * in this method
189 * @return the location in the model that represents the
190 * next location visual position
191 */
192 protected int getNextNorthSouthVisualPositionFrom(int pos, Position.Bias b,
193 Shape a, int direction,
194 Position.Bias[] biasRet)
195 throws BadLocationException {
196 int vIndex;
197 if(pos == -1) {
198 vIndex = (direction == NORTH) ?
199 getViewCount() - 1 : 0;
200 }
201 else {
202 if(b == Position.Bias.Backward && pos > 0) {
203 vIndex = getViewIndexAtPosition(pos - 1);
204 }
205 else {
206 vIndex = getViewIndexAtPosition(pos);
207 }
208 if(direction == NORTH) {
209 if(vIndex == 0) {
210 return -1;
211 }
212 vIndex--;
213 }
214 else if(++vIndex >= getViewCount()) {
215 return -1;
216 }
217 }
218 // vIndex gives index of row to look in.
219 JTextComponent text = (JTextComponent)getContainer();
220 Caret c = text.getCaret();
221 Point magicPoint;
222 magicPoint = (c != null) ? c.getMagicCaretPosition() : null;
223 int x;
224 if(magicPoint == null) {
225 Shape posBounds;
226 try {
227 posBounds = text.getUI().modelToView(text, pos, b);
228 } catch (BadLocationException exc) {
229 posBounds = null;
230 }
231 if(posBounds == null) {
232 x = 0;
233 }
234 else {
235 x = posBounds.getBounds().x;
236 }
237 }
238 else {
239 x = magicPoint.x;
240 }
241 return getClosestPositionTo(pos, b, a, direction, biasRet, vIndex, x);
242 }
243
244 /**
245 * Returns the closest model position to <code>x</code>.
246 * <code>rowIndex</code> gives the index of the view that corresponds
247 * that should be looked in.
248 * @param pos position into the model
249 * @param a the allocated region to render into
250 * @param direction one of the following values:
251 * <ul>
252 * <li><code>SwingConstants.NORTH</code>
253 * <li><code>SwingConstants.SOUTH</code>
254 * </ul>
255 * @param biasRet an array containing the bias that were checked
256 * in this method
257 * @param rowIndex the index of the view
258 * @param x the x coordinate of interest
259 * @return the closest model position to <code>x</code>
260 */
261 // NOTE: This will not properly work if ParagraphView contains
262 // other ParagraphViews. It won't raise, but this does not message
263 // the children views with getNextVisualPositionFrom.
264 protected int getClosestPositionTo(int pos, Position.Bias b, Shape a,
265 int direction, Position.Bias[] biasRet,
266 int rowIndex, int x)
267 throws BadLocationException {
268 JTextComponent text = (JTextComponent)getContainer();
269 Document doc = getDocument();
270 AbstractDocument aDoc = (doc instanceof AbstractDocument) ?
271 (AbstractDocument)doc : null;
272 View row = getView(rowIndex);
273 int lastPos = -1;
274 // This could be made better to check backward positions too.
275 biasRet[0] = Position.Bias.Forward;
276 for(int vc = 0, numViews = row.getViewCount(); vc < numViews; vc++) {
277 View v = row.getView(vc);
278 int start = v.getStartOffset();
279 boolean ltr = (aDoc != null) ? aDoc.isLeftToRight
280 (start, start + 1) : true;
281 if(ltr) {
282 lastPos = start;
283 for(int end = v.getEndOffset(); lastPos < end; lastPos++) {
284 float xx = text.modelToView(lastPos).getBounds().x;
285 if(xx >= x) {
286 while (++lastPos < end &&
287 text.modelToView(lastPos).getBounds().x == xx) {
288 }
289 return --lastPos;
290 }
291 }
292 lastPos--;
293 }
294 else {
295 for(lastPos = v.getEndOffset() - 1; lastPos >= start;
296 lastPos--) {
297 float xx = text.modelToView(lastPos).getBounds().x;
298 if(xx >= x) {
299 while (--lastPos >= start &&
300 text.modelToView(lastPos).getBounds().x == xx) {
301 }
302 return ++lastPos;
303 }
304 }
305 lastPos++;
306 }
307 }
308 if(lastPos == -1) {
309 return getStartOffset();
310 }
311 return lastPos;
312 }
313
314 /**
315 * Determines in which direction the next view lays.
316 * Consider the <code>View</code> at index n.
317 * Typically the <code>View</code>s are layed out
318 * from left to right, so that the <code>View</code>
319 * to the EAST will be at index n + 1, and the
320 * <code>View</code> to the WEST will be at index n - 1.
321 * In certain situations, such as with bidirectional text,
322 * it is possible that the <code>View</code> to EAST is not
323 * at index n + 1, but rather at index n - 1,
324 * or that the <code>View</code> to the WEST is not at
325 * index n - 1, but index n + 1. In this case this method
326 * would return true, indicating the <code>View</code>s are
327 * layed out in descending order.
328 * <p>
329 * This will return true if the text is layed out right
330 * to left at position, otherwise false.
331 *
332 * @param position position into the model
333 * @param bias either <code>Position.Bias.Forward</code> or
334 * <code>Position.Bias.Backward</code>
335 * @return true if the text is layed out right to left at
336 * position, otherwise false.
337 */
338 protected boolean flipEastAndWestAtEnds(int position,
339 Position.Bias bias) {
340 Document doc = getDocument();
341 if(doc instanceof AbstractDocument &&
342 !((AbstractDocument)doc).isLeftToRight(getStartOffset(),
343 getStartOffset() + 1)) {
344 return true;
345 }
346 return false;
347 }
348
349 // --- FlowView methods ---------------------------------------------
350
351 /**
352 * Fetches the constraining span to flow against for
353 * the given child index.
354 * @param index the index of the view being queried
355 * @return the constraining span for the given view at
356 * <code>index</code>
357 * @since 1.3
358 */
359 public int getFlowSpan(int index) {
360 View child = getView(index);
361 int adjust = 0;
362 if (child instanceof Row) {
363 Row row = (Row) child;
364 adjust = row.getLeftInset() + row.getRightInset();
365 }
366 return (layoutSpan == Integer.MAX_VALUE) ? layoutSpan
367 : (layoutSpan - adjust);
368 }
369
370 /**
371 * Fetches the location along the flow axis that the
372 * flow span will start at.
373 * @param index the index of the view being queried
374 * @return the location for the given view at
375 * <code>index</code>
376 * @since 1.3
377 */
378 public int getFlowStart(int index) {
379 View child = getView(index);
380 int adjust = 0;
381 if (child instanceof Row) {
382 Row row = (Row) child;
383 adjust = row.getLeftInset();
384 }
385 return tabBase + adjust;
386 }
387
388 /**
389 * Create a <code>View</code> that should be used to hold a
390 * a row's worth of children in a flow.
391 * @return the new <code>View</code>
392 * @since 1.3
393 */
394 protected View createRow() {
395 return new Row(getElement());
396 }
397
398 // --- TabExpander methods ------------------------------------------
399
400 /**
401 * Returns the next tab stop position given a reference position.
402 * This view implements the tab coordinate system, and calls
403 * <code>getTabbedSpan</code> on the logical children in the process
404 * of layout to determine the desired span of the children. The
405 * logical children can delegate their tab expansion upward to
406 * the paragraph which knows how to expand tabs.
407 * <code>LabelView</code> is an example of a view that delegates
408 * its tab expansion needs upward to the paragraph.
409 * <p>
410 * This is implemented to try and locate a <code>TabSet</code>
411 * in the paragraph element's attribute set. If one can be
412 * found, its settings will be used, otherwise a default expansion
413 * will be provided. The base location for for tab expansion
414 * is the left inset from the paragraphs most recent allocation
415 * (which is what the layout of the children is based upon).
416 *
417 * @param x the X reference position
418 * @param tabOffset the position within the text stream
419 * that the tab occurred at >= 0
420 * @return the trailing end of the tab expansion >= 0
421 * @see TabSet
422 * @see TabStop
423 * @see LabelView
424 */
425 public float nextTabStop(float x, int tabOffset) {
426 // If the text isn't left justified, offset by 10 pixels!
427 if(justification != StyleConstants.ALIGN_LEFT)
428 return x + 10.0f;
429 x -= tabBase;
430 TabSet tabs = getTabSet();
431 if(tabs == null) {
432 // a tab every 72 pixels.
433 return (float)(tabBase + (((int)x / 72 + 1) * 72));
434 }
435 TabStop tab = tabs.getTabAfter(x + .01f);
436 if(tab == null) {
437 // no tab, do a default of 5 pixels.
438 // Should this cause a wrapping of the line?
439 return tabBase + x + 5.0f;
440 }
441 int alignment = tab.getAlignment();
442 int offset;
443 switch(alignment) {
444 default:
445 case TabStop.ALIGN_LEFT:
446 // Simple case, left tab.
447 return tabBase + tab.getPosition();
448 case TabStop.ALIGN_BAR:
449 // PENDING: what does this mean?
450 return tabBase + tab.getPosition();
451 case TabStop.ALIGN_RIGHT:
452 case TabStop.ALIGN_CENTER:
453 offset = findOffsetToCharactersInString(tabChars,
454 tabOffset + 1);
455 break;
456 case TabStop.ALIGN_DECIMAL:
457 offset = findOffsetToCharactersInString(tabDecimalChars,
458 tabOffset + 1);
459 break;
460 }
461 if (offset == -1) {
462 offset = getEndOffset();
463 }
464 float charsSize = getPartialSize(tabOffset + 1, offset);
465 switch(alignment) {
466 case TabStop.ALIGN_RIGHT:
467 case TabStop.ALIGN_DECIMAL:
468 // right and decimal are treated the same way, the new
469 // position will be the location of the tab less the
470 // partialSize.
471 return tabBase + Math.max(x, tab.getPosition() - charsSize);
472 case TabStop.ALIGN_CENTER:
473 // Similar to right, but half the partialSize.
474 return tabBase + Math.max(x, tab.getPosition() - charsSize / 2.0f);
475 }
476 // will never get here!
477 return x;
478 }
479
480 /**
481 * Gets the <code>Tabset</code> to be used in calculating tabs.
482 *
483 * @return the <code>TabSet</code>
484 */
485 protected TabSet getTabSet() {
486 return StyleConstants.getTabSet(getElement().getAttributes());
487 }
488
489 /**
490 * Returns the size used by the views between
491 * <code>startOffset</code> and <code>endOffset</code>.
492 * This uses <code>getPartialView</code> to calculate the
493 * size if the child view implements the
494 * <code>TabableView</code> interface. If a
495 * size is needed and a <code>View</code> does not implement
496 * the <code>TabableView</code> interface,
497 * the <code>preferredSpan</code> will be used.
498 *
499 * @param startOffset the starting document offset >= 0
500 * @param endOffset the ending document offset >= startOffset
501 * @return the size >= 0
502 */
503 protected float getPartialSize(int startOffset, int endOffset) {
504 float size = 0.0f;
505 int viewIndex;
506 int numViews = getViewCount();
507 View view;
508 int viewEnd;
509 int tempEnd;
510
511 // Have to search layoutPool!
512 // PENDING: when ParagraphView supports breaking location
513 // into layoutPool will have to change!
514 viewIndex = getElement().getElementIndex(startOffset);
515 numViews = layoutPool.getViewCount();
516 while(startOffset < endOffset && viewIndex < numViews) {
517 view = layoutPool.getView(viewIndex++);
518 viewEnd = view.getEndOffset();
519 tempEnd = Math.min(endOffset, viewEnd);
520 if(view instanceof TabableView)
521 size += ((TabableView)view).getPartialSpan(startOffset, tempEnd);
522 else if(startOffset == view.getStartOffset() &&
523 tempEnd == view.getEndOffset())
524 size += view.getPreferredSpan(View.X_AXIS);
525 else
526 // PENDING: should we handle this better?
527 return 0.0f;
528 startOffset = viewEnd;
529 }
530 return size;
531 }
532
533 /**
534 * Finds the next character in the document with a character in
535 * <code>string</code>, starting at offset <code>start</code>. If
536 * there are no characters found, -1 will be returned.
537 *
538 * @param string the string of characters
539 * @param start where to start in the model >= 0
540 * @return the document offset, or -1 if no characters found
541 */
542 protected int findOffsetToCharactersInString(char[] string,
543 int start) {
544 int stringLength = string.length;
545 int end = getEndOffset();
546 Segment seg = new Segment();
547 try {
548 getDocument().getText(start, end - start, seg);
549 } catch (BadLocationException ble) {
550 return -1;
551 }
552 for(int counter = seg.offset, maxCounter = seg.offset + seg.count;
553 counter < maxCounter; counter++) {
554 char currentChar = seg.array[counter];
555 for(int subCounter = 0; subCounter < stringLength;
556 subCounter++) {
557 if(currentChar == string[subCounter])
558 return counter - seg.offset + start;
559 }
560 }
561 // No match.
562 return -1;
563 }
564
565 /**
566 * Returns where the tabs are calculated from.
567 * @return where tabs are calculated from
568 */
569 protected float getTabBase() {
570 return (float)tabBase;
571 }
572
573 // ---- View methods ----------------------------------------------------
574
575 /**
576 * Renders using the given rendering surface and area on that
577 * surface. This is implemented to delgate to the superclass
578 * after stashing the base coordinate for tab calculations.
579 *
580 * @param g the rendering surface to use
581 * @param a the allocated region to render into
582 * @see View#paint
583 */
584 public void paint(Graphics g, Shape a) {
585 Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a : a.getBounds();
586 tabBase = alloc.x + getLeftInset();
587 super.paint(g, a);
588
589 // line with the negative firstLineIndent value needs
590 // special handling
591 if (firstLineIndent < 0) {
592 Shape sh = getChildAllocation(0, a);
593 if ((sh != null) && sh.intersects(alloc)) {
594 int x = alloc.x + getLeftInset() + firstLineIndent;
595 int y = alloc.y + getTopInset();
596
597 Rectangle clip = g.getClipBounds();
598 tempRect.x = x + getOffset(X_AXIS, 0);
599 tempRect.y = y + getOffset(Y_AXIS, 0);
600 tempRect.width = getSpan(X_AXIS, 0) - firstLineIndent;
601 tempRect.height = getSpan(Y_AXIS, 0);
602 if (tempRect.intersects(clip)) {
603 tempRect.x = tempRect.x - firstLineIndent;
604 paintChild(g, tempRect, 0);
605 }
606 }
607 }
608 }
609
610 /**
611 * Determines the desired alignment for this view along an
612 * axis. This is implemented to give the alignment to the
613 * center of the first row along the y axis, and the default
614 * along the x axis.
615 *
616 * @param axis may be either <code>View.X_AXIS</code> or
617 * <code>View.Y_AXIS</code>
618 * @return the desired alignment. This should be a value
619 * between 0.0 and 1.0 inclusive, where 0 indicates alignment at the
620 * origin and 1.0 indicates alignment to the full span
621 * away from the origin. An alignment of 0.5 would be the
622 * center of the view.
623 */
624 public float getAlignment(int axis) {
625 switch (axis) {
626 case Y_AXIS:
627 float a = 0.5f;
628 if (getViewCount() != 0) {
629 int paragraphSpan = (int) getPreferredSpan(View.Y_AXIS);
630 View v = getView(0);
631 int rowSpan = (int) v.getPreferredSpan(View.Y_AXIS);
632 a = (paragraphSpan != 0) ? ((float)(rowSpan / 2)) / paragraphSpan : 0;
633 }
634 return a;
635 case X_AXIS:
636 return 0.5f;
637 default:
638 throw new IllegalArgumentException("Invalid axis: " + axis);
639 }
640 }
641
642 /**
643 * Breaks this view on the given axis at the given length.
644 * <p>
645 * <code>ParagraphView</code> instances are breakable
646 * along the <code>Y_AXIS</code> only, and only if
647 * <code>len</code> is after the first line.
648 *
649 * @param axis may be either <code>View.X_AXIS</code>
650 * or <code>View.Y_AXIS</code>
651 * @param len specifies where a potential break is desired
652 * along the given axis >= 0
653 * @param a the current allocation of the view
654 * @return the fragment of the view that represents the
655 * given span, if the view can be broken; if the view
656 * doesn't support breaking behavior, the view itself is
657 * returned
658 * @see View#breakView
659 */
660 public View breakView(int axis, float len, Shape a) {
661 if(axis == View.Y_AXIS) {
662 if(a != null) {
663 Rectangle alloc = a.getBounds();
664 setSize(alloc.width, alloc.height);
665 }
666 // Determine what row to break on.
667
668 // PENDING(prinz) add break support
669 return this;
670 }
671 return this;
672 }
673
674 /**
675 * Gets the break weight for a given location.
676 * <p>
677 * <code>ParagraphView</code> instances are breakable
678 * along the <code>Y_AXIS</code> only, and only if
679 * <code>len</code> is after the first row. If the length
680 * is less than one row, a value of <code>BadBreakWeight</code>
681 * is returned.
682 *
683 * @param axis may be either <code>View.X_AXIS</code>
684 * or <code>View.Y_AXIS</code>
685 * @param len specifies where a potential break is desired >= 0
686 * @return a value indicating the attractiveness of breaking here;
687 * either <code>GoodBreakWeight</code> or <code>BadBreakWeight</code>
688 * @see View#getBreakWeight
689 */
690 public int getBreakWeight(int axis, float len) {
691 if(axis == View.Y_AXIS) {
692 // PENDING(prinz) make this return a reasonable value
693 // when paragraph breaking support is re-implemented.
694 // If less than one row, bad weight value should be
695 // returned.
696 //return GoodBreakWeight;
697 return BadBreakWeight;
698 }
699 return BadBreakWeight;
700 }
701
702 /**
703 * Calculate the needs for the paragraph along the minor axis.
704 *
705 * <p>This uses size requirements of the superclass, modified to take into
706 * account the non-breakable areas at the adjacent views edges. The minimal
707 * size requirements for such views should be no less than the sum of all
708 * adjacent fragments.</p>
709 *
710 * <p>If the {@code axis} parameter is neither {@code View.X_AXIS} nor
711 * {@code View.Y_AXIS}, {@link IllegalArgumentException} is thrown. If the
712 * {@code r} parameter is {@code null,} a new {@code SizeRequirements}
713 * object is created, otherwise the supplied {@code SizeRequirements}
714 * object is returned.</p>
715 *
716 * @param axis the minor axis
717 * @param r the input {@code SizeRequirements} object
718 * @return the new or adjusted {@code SizeRequirements} object
719 * @throws IllegalArgumentException if the {@code axis} parameter is invalid
720 */
721 @Override
722 protected SizeRequirements calculateMinorAxisRequirements(int axis,
723 SizeRequirements r) {
724 r = super.calculateMinorAxisRequirements(axis, r);
725
726 float min = 0;
727 float glue = 0;
728 int n = getLayoutViewCount();
729 for (int i = 0; i < n; i++) {
730 View v = getLayoutView(i);
731 float span = v.getMinimumSpan(axis);
732 if (v.getBreakWeight(axis, 0, v.getMaximumSpan(axis)) > View.BadBreakWeight) {
733 // find the longest non-breakable fragments at the view edges
734 int p0 = v.getStartOffset();
735 int p1 = v.getEndOffset();
736 float start = findEdgeSpan(v, axis, p0, p0, p1);
737 float end = findEdgeSpan(v, axis, p1, p0, p1);
738 glue += start;
739 min = Math.max(min, Math.max(span, glue));
740 glue = end;
741 } else {
742 // non-breakable view
743 glue += span;
744 min = Math.max(min, glue);
745 }
746 }
747 r.minimum = Math.max(r.minimum, (int) min);
748 r.preferred = Math.max(r.minimum, r.preferred);
749 r.maximum = Math.max(r.preferred, r.maximum);
750
751 return r;
752 }
753
754 /**
755 * Binary search for the longest non-breakable fragment at the view edge.
756 */
757 private float findEdgeSpan(View v, int axis, int fp, int p0, int p1) {
758 int len = p1 - p0;
759 if (len <= 1) {
760 // further fragmentation is not possible
761 return v.getMinimumSpan(axis);
762 } else {
763 int mid = p0 + len / 2;
764 boolean startEdge = mid > fp;
765 // initial view is breakable hence must support fragmentation
766 View f = startEdge ?
767 v.createFragment(fp, mid) : v.createFragment(mid, fp);
768 boolean breakable = f.getBreakWeight(
769 axis, 0, f.getMaximumSpan(axis)) > View.BadBreakWeight;
770 if (breakable == startEdge) {
771 p1 = mid;
772 } else {
773 p0 = mid;
774 }
775 return findEdgeSpan(f, axis, fp, p0, p1);
776 }
777 }
778
779 /**
780 * Gives notification from the document that attributes were changed
781 * in a location that this view is responsible for.
782 *
783 * @param changes the change information from the
784 * associated document
785 * @param a the current allocation of the view
786 * @param f the factory to use to rebuild if the view has children
787 * @see View#changedUpdate
788 */
789 public void changedUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
790 // update any property settings stored, and layout should be
791 // recomputed
792 setPropertiesFromAttributes();
793 layoutChanged(X_AXIS);
794 layoutChanged(Y_AXIS);
795 super.changedUpdate(changes, a, f);
796 }
797
798
799 // --- variables -----------------------------------------------
800
801 private int justification;
802 private float lineSpacing;
803 /** Indentation for the first line, from the left inset. */
804 protected int firstLineIndent = 0;
805
806 /**
807 * Used by the TabExpander functionality to determine
808 * where to base the tab calculations. This is basically
809 * the location of the left side of the paragraph.
810 */
811 private int tabBase;
812
813 /**
814 * Used to create an i18n-based layout strategy
815 */
816 static Class i18nStrategy;
817
818 /** Used for searching for a tab. */
819 static char[] tabChars;
820 /** Used for searching for a tab or decimal character. */
821 static char[] tabDecimalChars;
822
823 static {
824 tabChars = new char[1];
825 tabChars[0] = '\t';
826 tabDecimalChars = new char[2];
827 tabDecimalChars[0] = '\t';
828 tabDecimalChars[1] = '.';
829 }
830
831 /**
832 * Internally created view that has the purpose of holding
833 * the views that represent the children of the paragraph
834 * that have been arranged in rows.
835 */
836 class Row extends BoxView {
837
838 Row(Element elem) {
839 super(elem, View.X_AXIS);
840 }
841
842 /**
843 * This is reimplemented to do nothing since the
844 * paragraph fills in the row with its needed
845 * children.
846 */
847 protected void loadChildren(ViewFactory f) {
848 }
849
850 /**
851 * Fetches the attributes to use when rendering. This view
852 * isn't directly responsible for an element so it returns
853 * the outer classes attributes.
854 */
855 public AttributeSet getAttributes() {
856 View p = getParent();
857 return (p != null) ? p.getAttributes() : null;
858 }
859
860 public float getAlignment(int axis) {
861 if (axis == View.X_AXIS) {
862 switch (justification) {
863 case StyleConstants.ALIGN_LEFT:
864 return 0;
865 case StyleConstants.ALIGN_RIGHT:
866 return 1;
867 case StyleConstants.ALIGN_CENTER:
868 return 0.5f;
869 case StyleConstants.ALIGN_JUSTIFIED:
870 float rv = 0.5f;
871 //if we can justifiy the content always align to
872 //the left.
873 if (isJustifiableDocument()) {
874 rv = 0f;
875 }
876 return rv;
877 }
878 }
879 return super.getAlignment(axis);
880 }
881
882 /**
883 * Provides a mapping from the document model coordinate space
884 * to the coordinate space of the view mapped to it. This is
885 * implemented to let the superclass find the position along
886 * the major axis and the allocation of the row is used
887 * along the minor axis, so that even though the children
888 * are different heights they all get the same caret height.
889 *
890 * @param pos the position to convert
891 * @param a the allocated region to render into
892 * @return the bounding box of the given position
893 * @exception BadLocationException if the given position does not represent a
894 * valid location in the associated document
895 * @see View#modelToView
896 */
897 public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
898 Rectangle r = a.getBounds();
899 View v = getViewAtPosition(pos, r);
900 if ((v != null) && (!v.getElement().isLeaf())) {
901 // Don't adjust the height if the view represents a branch.
902 return super.modelToView(pos, a, b);
903 }
904 r = a.getBounds();
905 int height = r.height;
906 int y = r.y;
907 Shape loc = super.modelToView(pos, a, b);
908 r = loc.getBounds();
909 r.height = height;
910 r.y = y;
911 return r;
912 }
913
914 /**
915 * Range represented by a row in the paragraph is only
916 * a subset of the total range of the paragraph element.
917 * @see View#getRange
918 */
919 public int getStartOffset() {
920 int offs = Integer.MAX_VALUE;
921 int n = getViewCount();
922 for (int i = 0; i < n; i++) {
923 View v = getView(i);
924 offs = Math.min(offs, v.getStartOffset());
925 }
926 return offs;
927 }
928
929 public int getEndOffset() {
930 int offs = 0;
931 int n = getViewCount();
932 for (int i = 0; i < n; i++) {
933 View v = getView(i);
934 offs = Math.max(offs, v.getEndOffset());
935 }
936 return offs;
937 }
938
939 /**
940 * Perform layout for the minor axis of the box (i.e. the
941 * axis orthoginal to the axis that it represents). The results
942 * of the layout should be placed in the given arrays which represent
943 * the allocations to the children along the minor axis.
944 * <p>
945 * This is implemented to do a baseline layout of the children
946 * by calling BoxView.baselineLayout.
947 *
948 * @param targetSpan the total span given to the view, which
949 * whould be used to layout the children.
950 * @param axis the axis being layed out.
951 * @param offsets the offsets from the origin of the view for
952 * each of the child views. This is a return value and is
953 * filled in by the implementation of this method.
954 * @param spans the span of each child view. This is a return
955 * value and is filled in by the implementation of this method.
956 * @return the offset and span for each child view in the
957 * offsets and spans parameters
958 */
959 protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, int[] spans) {
960 baselineLayout(targetSpan, axis, offsets, spans);
961 }
962
963 protected SizeRequirements calculateMinorAxisRequirements(int axis,
964 SizeRequirements r) {
965 return baselineRequirements(axis, r);
966 }
967
968
969 private boolean isLastRow() {
970 View parent;
971 return ((parent = getParent()) == null
972 || this == parent.getView(parent.getViewCount() - 1));
973 }
974
975 private boolean isBrokenRow() {
976 boolean rv = false;
977 int viewsCount = getViewCount();
978 if (viewsCount > 0) {
979 View lastView = getView(viewsCount - 1);
980 if (lastView.getBreakWeight(X_AXIS, 0, 0) >=
981 ForcedBreakWeight) {
982 rv = true;
983 }
984 }
985 return rv;
986 }
987
988 private boolean isJustifiableDocument() {
989 return (! Boolean.TRUE.equals(getDocument().getProperty(
990 AbstractDocument.I18NProperty)));
991 }
992
993 /**
994 * Whether we need to justify this {@code Row}.
995 * At this time (jdk1.6) we support justification on for non
996 * 18n text.
997 *
998 * @return {@code true} if this {@code Row} should be justified.
999 */
1000 private boolean isJustifyEnabled() {
1001 boolean ret = (justification == StyleConstants.ALIGN_JUSTIFIED);
1002
1003 //no justification for i18n documents
1004 ret = ret && isJustifiableDocument();
1005
1006 //no justification for the last row
1007 ret = ret && ! isLastRow();
1008
1009 //no justification for the broken rows
1010 ret = ret && ! isBrokenRow();
1011
1012 return ret;
1013 }
1014
1015
1016 //Calls super method after setting spaceAddon to 0.
1017 //Justification should not affect MajorAxisRequirements
1018 @Override
1019 protected SizeRequirements calculateMajorAxisRequirements(int axis,
1020 SizeRequirements r) {
1021 int oldJustficationData[] = justificationData;
1022 justificationData = null;
1023 SizeRequirements ret = super.calculateMajorAxisRequirements(axis, r);
1024 if (isJustifyEnabled()) {
1025 justificationData = oldJustficationData;
1026 }
1027 return ret;
1028 }
1029
1030 @Override
1031 protected void layoutMajorAxis(int targetSpan, int axis,
1032 int[] offsets, int[] spans) {
1033 int oldJustficationData[] = justificationData;
1034 justificationData = null;
1035 super.layoutMajorAxis(targetSpan, axis, offsets, spans);
1036 if (! isJustifyEnabled()) {
1037 return;
1038 }
1039
1040 int currentSpan = 0;
1041 for (int span : spans) {
1042 currentSpan += span;
1043 }
1044 if (currentSpan == targetSpan) {
1045 //no need to justify
1046 return;
1047 }
1048
1049 // we justify text by enlarging spaces by the {@code spaceAddon}.
1050 // justification is started to the right of the rightmost TAB.
1051 // leading and trailing spaces are not extendable.
1052 //
1053 // GlyphPainter1 uses
1054 // justificationData
1055 // for all painting and measurement.
1056
1057 int extendableSpaces = 0;
1058 int startJustifiableContent = -1;
1059 int endJustifiableContent = -1;
1060 int lastLeadingSpaces = 0;
1061
1062 int rowStartOffset = getStartOffset();
1063 int rowEndOffset = getEndOffset();
1064 int spaceMap[] = new int[rowEndOffset - rowStartOffset];
1065 Arrays.fill(spaceMap, 0);
1066 for (int i = getViewCount() - 1; i >= 0 ; i--) {
1067 View view = getView(i);
1068 if (view instanceof GlyphView) {
1069 GlyphView.JustificationInfo justificationInfo =
1070 ((GlyphView) view).getJustificationInfo(rowStartOffset);
1071 final int viewStartOffset = view.getStartOffset();
1072 final int offset = viewStartOffset - rowStartOffset;
1073 for (int j = 0; j < justificationInfo.spaceMap.length(); j++) {
1074 if (justificationInfo.spaceMap.get(j)) {
1075 spaceMap[j + offset] = 1;
1076 }
1077 }
1078 if (startJustifiableContent > 0) {
1079 if (justificationInfo.end >= 0) {
1080 extendableSpaces += justificationInfo.trailingSpaces;
1081 } else {
1082 lastLeadingSpaces += justificationInfo.trailingSpaces;
1083 }
1084 }
1085 if (justificationInfo.start >= 0) {
1086 startJustifiableContent =
1087 justificationInfo.start + viewStartOffset;
1088 extendableSpaces += lastLeadingSpaces;
1089 }
1090 if (justificationInfo.end >= 0
1091 && endJustifiableContent < 0) {
1092 endJustifiableContent =
1093 justificationInfo.end + viewStartOffset;
1094 }
1095 extendableSpaces += justificationInfo.contentSpaces;
1096 lastLeadingSpaces = justificationInfo.leadingSpaces;
1097 if (justificationInfo.hasTab) {
1098 break;
1099 }
1100 }
1101 }
1102 if (extendableSpaces <= 0) {
1103 //there is nothing we can do to justify
1104 return;
1105 }
1106 int adjustment = (targetSpan - currentSpan);
1107 int spaceAddon = (extendableSpaces > 0)
1108 ? adjustment / extendableSpaces
1109 : 0;
1110 int spaceAddonLeftoverEnd = -1;
1111 for (int i = startJustifiableContent - rowStartOffset,
1112 leftover = adjustment - spaceAddon * extendableSpaces;
1113 leftover > 0;
1114 leftover -= spaceMap[i],
1115 i++) {
1116 spaceAddonLeftoverEnd = i;
1117 }
1118 if (spaceAddon > 0 || spaceAddonLeftoverEnd >= 0) {
1119 justificationData = (oldJustficationData != null)
1120 ? oldJustficationData
1121 : new int[END_JUSTIFIABLE + 1];
1122 justificationData[SPACE_ADDON] = spaceAddon;
1123 justificationData[SPACE_ADDON_LEFTOVER_END] =
1124 spaceAddonLeftoverEnd;
1125 justificationData[START_JUSTIFIABLE] =
1126 startJustifiableContent - rowStartOffset;
1127 justificationData[END_JUSTIFIABLE] =
1128 endJustifiableContent - rowStartOffset;
1129 super.layoutMajorAxis(targetSpan, axis, offsets, spans);
1130 }
1131 }
1132
1133 //for justified row we assume the maximum horizontal span
1134 //is MAX_VALUE.
1135 @Override
1136 public float getMaximumSpan(int axis) {
1137 float ret;
1138 if (View.X_AXIS == axis
1139 && isJustifyEnabled()) {
1140 ret = Float.MAX_VALUE;
1141 } else {
1142 ret = super.getMaximumSpan(axis);
1143 }
1144 return ret;
1145 }
1146
1147 /**
1148 * Fetches the child view index representing the given position in
1149 * the model.
1150 *
1151 * @param pos the position >= 0
1152 * @return index of the view representing the given position, or
1153 * -1 if no view represents that position
1154 */
1155 protected int getViewIndexAtPosition(int pos) {
1156 // This is expensive, but are views are not necessarily layed
1157 // out in model order.
1158 if(pos < getStartOffset() || pos >= getEndOffset())
1159 return -1;
1160 for(int counter = getViewCount() - 1; counter >= 0; counter--) {
1161 View v = getView(counter);
1162 if(pos >= v.getStartOffset() &&
1163 pos < v.getEndOffset()) {
1164 return counter;
1165 }
1166 }
1167 return -1;
1168 }
1169
1170 /**
1171 * Gets the left inset.
1172 *
1173 * @return the inset
1174 */
1175 protected short getLeftInset() {
1176 View parentView;
1177 int adjustment = 0;
1178 if ((parentView = getParent()) != null) { //use firstLineIdent for the first row
1179 if (this == parentView.getView(0)) {
1180 adjustment = firstLineIndent;
1181 }
1182 }
1183 return (short)(super.getLeftInset() + adjustment);
1184 }
1185
1186 protected short getBottomInset() {
1187 return (short)(super.getBottomInset() +
1188 ((minorRequest != null) ? minorRequest.preferred : 0) *
1189 lineSpacing);
1190 }
1191
1192 final static int SPACE_ADDON = 0;
1193 final static int SPACE_ADDON_LEFTOVER_END = 1;
1194 final static int START_JUSTIFIABLE = 2;
1195 //this should be the last index in justificationData
1196 final static int END_JUSTIFIABLE = 3;
1197
1198 int justificationData[] = null;
1199 }
1200
1201}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t