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/FlowView.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/swing/text/FlowView.java+871−0
@@ -0,0 +1,871 @@
1+/*
2+ * Copyright (c) 1999, 2008, 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+package javax.swing.text;
26+
27+import java.awt.*;
28+import java.util.Vector;
29+import javax.swing.event.*;
30+import javax.swing.SizeRequirements;
31+
32+/**
33+ * A View that tries to flow it's children into some
34+ * partially constrained space. This can be used to
35+ * build things like paragraphs, pages, etc. The
36+ * flow is made up of the following pieces of functionality.
37+ * <ul>
38+ * <li>A logical set of child views, which as used as a
39+ * layout pool from which a physical view is formed.
40+ * <li>A strategy for translating the logical view to
41+ * a physical (flowed) view.
42+ * <li>Constraints for the strategy to work against.
43+ * <li>A physical structure, that represents the flow.
44+ * The children of this view are where the pieces of
45+ * of the logical views are placed to create the flow.
46+ * </ul>
47+ *
48+ * @author Timothy Prinzing
49+ * @see View
50+ * @since 1.3
51+ */
52+public abstract class FlowView extends BoxView {
53+
54+ /**
55+ * Constructs a FlowView for the given element.
56+ *
57+ * @param elem the element that this view is responsible for
58+ * @param axis may be either View.X_AXIS or View.Y_AXIS
59+ */
60+ public FlowView(Element elem, int axis) {
61+ super(elem, axis);
62+ layoutSpan = Integer.MAX_VALUE;
63+ strategy = new FlowStrategy();
64+ }
65+
66+ /**
67+ * Fetches the axis along which views should be
68+ * flowed. By default, this will be the axis
69+ * orthogonal to the axis along which the flow
70+ * rows are tiled (the axis of the default flow
71+ * rows themselves). This is typically used
72+ * by the <code>FlowStrategy</code>.
73+ */
74+ public int getFlowAxis() {
75+ if (getAxis() == Y_AXIS) {
76+ return X_AXIS;
77+ }
78+ return Y_AXIS;
79+ }
80+
81+ /**
82+ * Fetch the constraining span to flow against for
83+ * the given child index. This is called by the
84+ * FlowStrategy while it is updating the flow.
85+ * A flow can be shaped by providing different values
86+ * for the row constraints. By default, the entire
87+ * span inside of the insets along the flow axis
88+ * is returned.
89+ *
90+ * @param index the index of the row being updated.
91+ * This should be a value >= 0 and < getViewCount().
92+ * @see #getFlowStart
93+ */
94+ public int getFlowSpan(int index) {
95+ return layoutSpan;
96+ }
97+
98+ /**
99+ * Fetch the location along the flow axis that the
100+ * flow span will start at. This is called by the
101+ * FlowStrategy while it is updating the flow.
102+ * A flow can be shaped by providing different values
103+ * for the row constraints.
104+
105+ * @param index the index of the row being updated.
106+ * This should be a value >= 0 and < getViewCount().
107+ * @see #getFlowSpan
108+ */
109+ public int getFlowStart(int index) {
110+ return 0;
111+ }
112+
113+ /**
114+ * Create a View that should be used to hold a
115+ * a rows worth of children in a flow. This is
116+ * called by the FlowStrategy when new children
117+ * are added or removed (i.e. rows are added or
118+ * removed) in the process of updating the flow.
119+ */
120+ protected abstract View createRow();
121+
122+ // ---- BoxView methods -------------------------------------
123+
124+ /**
125+ * Loads all of the children to initialize the view.
126+ * This is called by the <code>setParent</code> method.
127+ * This is reimplemented to not load any children directly
128+ * (as they are created in the process of formatting).
129+ * If the layoutPool variable is null, an instance of
130+ * LogicalView is created to represent the logical view
131+ * that is used in the process of formatting.
132+ *
133+ * @param f the view factory
134+ */
135+ protected void loadChildren(ViewFactory f) {
136+ if (layoutPool == null) {
137+ layoutPool = new LogicalView(getElement());
138+ }
139+ layoutPool.setParent(this);
140+
141+ // This synthetic insertUpdate call gives the strategy a chance
142+ // to initialize.
143+ strategy.insertUpdate(this, null, null);
144+ }
145+
146+ /**
147+ * Fetches the child view index representing the given position in
148+ * the model.
149+ *
150+ * @param pos the position >= 0
151+ * @return index of the view representing the given position, or
152+ * -1 if no view represents that position
153+ */
154+ protected int getViewIndexAtPosition(int pos) {
155+ if (pos >= getStartOffset() && (pos < getEndOffset())) {
156+ for (int counter = 0; counter < getViewCount(); counter++) {
157+ View v = getView(counter);
158+ if(pos >= v.getStartOffset() &&
159+ pos < v.getEndOffset()) {
160+ return counter;
161+ }
162+ }
163+ }
164+ return -1;
165+ }
166+
167+ /**
168+ * Lays out the children. If the span along the flow
169+ * axis has changed, layout is marked as invalid which
170+ * which will cause the superclass behavior to recalculate
171+ * the layout along the box axis. The FlowStrategy.layout
172+ * method will be called to rebuild the flow rows as
173+ * appropriate. If the height of this view changes
174+ * (determined by the perferred size along the box axis),
175+ * a preferenceChanged is called. Following all of that,
176+ * the normal box layout of the superclass is performed.
177+ *
178+ * @param width the width to lay out against >= 0. This is
179+ * the width inside of the inset area.
180+ * @param height the height to lay out against >= 0 This
181+ * is the height inside of the inset area.
182+ */
183+ protected void layout(int width, int height) {
184+ final int faxis = getFlowAxis();
185+ int newSpan;
186+ if (faxis == X_AXIS) {
187+ newSpan = width;
188+ } else {
189+ newSpan = height;
190+ }
191+ if (layoutSpan != newSpan) {
192+ layoutChanged(faxis);
193+ layoutChanged(getAxis());
194+ layoutSpan = newSpan;
195+ }
196+
197+ // repair the flow if necessary
198+ if (! isLayoutValid(faxis)) {
199+ final int heightAxis = getAxis();
200+ int oldFlowHeight = (heightAxis == X_AXIS)? getWidth() : getHeight();
201+ strategy.layout(this);
202+ int newFlowHeight = (int) getPreferredSpan(heightAxis);
203+ if (oldFlowHeight != newFlowHeight) {
204+ View p = getParent();
205+ if (p != null) {
206+ p.preferenceChanged(this, (heightAxis == X_AXIS), (heightAxis == Y_AXIS));
207+ }
208+
209+ // PENDING(shannonh)
210+ // Temporary fix for 4250847
211+ // Can be removed when TraversalContext is added
212+ Component host = getContainer();
213+ if (host != null) {
214+ //nb idk 12/12/2001 host should not be equal to null. We need to add assertion here
215+ host.repaint();
216+ }
217+ }
218+ }
219+
220+ super.layout(width, height);
221+ }
222+
223+ /**
224+ * Calculate equirements along the minor axis. This
225+ * is implemented to forward the request to the logical
226+ * view by calling getMinimumSpan, getPreferredSpan, and
227+ * getMaximumSpan on it.
228+ */
229+ protected SizeRequirements calculateMinorAxisRequirements(int axis, SizeRequirements r) {
230+ if (r == null) {
231+ r = new SizeRequirements();
232+ }
233+ float pref = layoutPool.getPreferredSpan(axis);
234+ float min = layoutPool.getMinimumSpan(axis);
235+ // Don't include insets, Box.getXXXSpan will include them.
236+ r.minimum = (int)min;
237+ r.preferred = Math.max(r.minimum, (int) pref);
238+ r.maximum = Integer.MAX_VALUE;
239+ r.alignment = 0.5f;
240+ return r;
241+ }
242+
243+ // ---- View methods ----------------------------------------------------
244+
245+ /**
246+ * Gives notification that something was inserted into the document
247+ * in a location that this view is responsible for.
248+ *
249+ * @param changes the change information from the associated document
250+ * @param a the current allocation of the view
251+ * @param f the factory to use to rebuild if the view has children
252+ * @see View#insertUpdate
253+ */
254+ public void insertUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
255+ layoutPool.insertUpdate(changes, a, f);
256+ strategy.insertUpdate(this, changes, getInsideAllocation(a));
257+ }
258+
259+ /**
260+ * Gives notification that something was removed from the document
261+ * in a location that this view is responsible for.
262+ *
263+ * @param changes the change information from the associated document
264+ * @param a the current allocation of the view
265+ * @param f the factory to use to rebuild if the view has children
266+ * @see View#removeUpdate
267+ */
268+ public void removeUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
269+ layoutPool.removeUpdate(changes, a, f);
270+ strategy.removeUpdate(this, changes, getInsideAllocation(a));
271+ }
272+
273+ /**
274+ * Gives notification from the document that attributes were changed
275+ * in a location that this view is responsible for.
276+ *
277+ * @param changes the change information from the associated document
278+ * @param a the current allocation of the view
279+ * @param f the factory to use to rebuild if the view has children
280+ * @see View#changedUpdate
281+ */
282+ public void changedUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
283+ layoutPool.changedUpdate(changes, a, f);
284+ strategy.changedUpdate(this, changes, getInsideAllocation(a));
285+ }
286+
287+ /** {@inheritDoc} */
288+ public void setParent(View parent) {
289+ super.setParent(parent);
290+ if (parent == null
291+ && layoutPool != null ) {
292+ layoutPool.setParent(null);
293+ }
294+ }
295+
296+ // --- variables -----------------------------------------------
297+
298+ /**
299+ * Default constraint against which the flow is
300+ * created against.
301+ */
302+ protected int layoutSpan;
303+
304+ /**
305+ * These are the views that represent the child elements
306+ * of the element this view represents (The logical view
307+ * to translate to a physical view). These are not
308+ * directly children of this view. These are either
309+ * placed into the rows directly or used for the purpose
310+ * of breaking into smaller chunks, to form the physical
311+ * view.
312+ */
313+ protected View layoutPool;
314+
315+ /**
316+ * The behavior for keeping the flow updated. By
317+ * default this is a singleton shared by all instances
318+ * of FlowView (FlowStrategy is stateless). Subclasses
319+ * can create an alternative strategy, which might keep
320+ * state.
321+ */
322+ protected FlowStrategy strategy;
323+
324+ /**
325+ * Strategy for maintaining the physical form
326+ * of the flow. The default implementation is
327+ * completely stateless, and recalculates the
328+ * entire flow if the layout is invalid on the
329+ * given FlowView. Alternative strategies can
330+ * be implemented by subclassing, and might
331+ * perform incrementatal repair to the layout
332+ * or alternative breaking behavior.
333+ * @since 1.3
334+ */
335+ public static class FlowStrategy {
336+ Position damageStart = null;
337+ Vector<View> viewBuffer;
338+
339+ void addDamage(FlowView fv, int offset) {
340+ if (offset >= fv.getStartOffset() && offset < fv.getEndOffset()) {
341+ if (damageStart == null || offset < damageStart.getOffset()) {
342+ try {
343+ damageStart = fv.getDocument().createPosition(offset);
344+ } catch (BadLocationException e) {
345+ // shouldn't happen since offset is inside view bounds
346+ assert(false);
347+ }
348+ }
349+ }
350+ }
351+
352+ void unsetDamage() {
353+ damageStart = null;
354+ }
355+
356+ /**
357+ * Gives notification that something was inserted into the document
358+ * in a location that the given flow view is responsible for. The
359+ * strategy should update the appropriate changed region (which
360+ * depends upon the strategy used for repair).
361+ *
362+ * @param e the change information from the associated document
363+ * @param alloc the current allocation of the view inside of the insets.
364+ * This value will be null if the view has not yet been displayed.
365+ * @see View#insertUpdate
366+ */
367+ public void insertUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) {
368+ // FlowView.loadChildren() makes a synthetic call into this,
369+ // passing null as e
370+ if (e != null) {
371+ addDamage(fv, e.getOffset());
372+ }
373+
374+ if (alloc != null) {
375+ Component host = fv.getContainer();
376+ if (host != null) {
377+ host.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
378+ }
379+ } else {
380+ fv.preferenceChanged(null, true, true);
381+ }
382+ }
383+
384+ /**
385+ * Gives notification that something was removed from the document
386+ * in a location that the given flow view is responsible for.
387+ *
388+ * @param e the change information from the associated document
389+ * @param alloc the current allocation of the view inside of the insets.
390+ * @see View#removeUpdate
391+ */
392+ public void removeUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) {
393+ addDamage(fv, e.getOffset());
394+ if (alloc != null) {
395+ Component host = fv.getContainer();
396+ if (host != null) {
397+ host.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
398+ }
399+ } else {
400+ fv.preferenceChanged(null, true, true);
401+ }
402+ }
403+
404+ /**
405+ * Gives notification from the document that attributes were changed
406+ * in a location that this view is responsible for.
407+ *
408+ * @param fv the <code>FlowView</code> containing the changes
409+ * @param e the <code>DocumentEvent</code> describing the changes
410+ * done to the Document
411+ * @param alloc Bounds of the View
412+ * @see View#changedUpdate
413+ */
414+ public void changedUpdate(FlowView fv, DocumentEvent e, Rectangle alloc) {
415+ addDamage(fv, e.getOffset());
416+ if (alloc != null) {
417+ Component host = fv.getContainer();
418+ if (host != null) {
419+ host.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
420+ }
421+ } else {
422+ fv.preferenceChanged(null, true, true);
423+ }
424+ }
425+
426+ /**
427+ * This method gives flow strategies access to the logical
428+ * view of the FlowView.
429+ */
430+ protected View getLogicalView(FlowView fv) {
431+ return fv.layoutPool;
432+ }
433+
434+ /**
435+ * Update the flow on the given FlowView. By default, this causes
436+ * all of the rows (child views) to be rebuilt to match the given
437+ * constraints for each row. This is called by a FlowView.layout
438+ * to update the child views in the flow.
439+ *
440+ * @param fv the view to reflow
441+ */
442+ public void layout(FlowView fv) {
443+ View pool = getLogicalView(fv);
444+ int rowIndex, p0;
445+ int p1 = fv.getEndOffset();
446+
447+ if (fv.majorAllocValid) {
448+ if (damageStart == null) {
449+ return;
450+ }
451+ // In some cases there's no view at position damageStart, so
452+ // step back and search again. See 6452106 for details.
453+ int offset = damageStart.getOffset();
454+ while ((rowIndex = fv.getViewIndexAtPosition(offset)) < 0) {
455+ offset--;
456+ }
457+ if (rowIndex > 0) {
458+ rowIndex--;
459+ }
460+ p0 = fv.getView(rowIndex).getStartOffset();
461+ } else {
462+ rowIndex = 0;
463+ p0 = fv.getStartOffset();
464+ }
465+ reparentViews(pool, p0);
466+
467+ viewBuffer = new Vector<View>(10, 10);
468+ int rowCount = fv.getViewCount();
469+ while (p0 < p1) {
470+ View row;
471+ if (rowIndex >= rowCount) {
472+ row = fv.createRow();
473+ fv.append(row);
474+ } else {
475+ row = fv.getView(rowIndex);
476+ }
477+ p0 = layoutRow(fv, rowIndex, p0);
478+ rowIndex++;
479+ }
480+ viewBuffer = null;
481+
482+ if (rowIndex < rowCount) {
483+ fv.replace(rowIndex, rowCount - rowIndex, null);
484+ }
485+ unsetDamage();
486+ }
487+
488+ /**
489+ * Creates a row of views that will fit within the
490+ * layout span of the row. This is called by the layout method.
491+ * This is implemented to fill the row by repeatedly calling
492+ * the createView method until the available span has been
493+ * exhausted, a forced break was encountered, or the createView
494+ * method returned null. If the remaining span was exhaused,
495+ * the adjustRow method will be called to perform adjustments
496+ * to the row to try and make it fit into the given span.
497+ *
498+ * @param rowIndex the index of the row to fill in with views. The
499+ * row is assumed to be empty on entry.
500+ * @param pos The current position in the children of
501+ * this views element from which to start.
502+ * @return the position to start the next row
503+ */
504+ protected int layoutRow(FlowView fv, int rowIndex, int pos) {
505+ View row = fv.getView(rowIndex);
506+ float x = fv.getFlowStart(rowIndex);
507+ float spanLeft = fv.getFlowSpan(rowIndex);
508+ int end = fv.getEndOffset();
509+ TabExpander te = (fv instanceof TabExpander) ? (TabExpander)fv : null;
510+ final int flowAxis = fv.getFlowAxis();
511+
512+ int breakWeight = BadBreakWeight;
513+ float breakX = 0f;
514+ float breakSpan = 0f;
515+ int breakIndex = -1;
516+ int n = 0;
517+
518+ viewBuffer.clear();
519+ while (pos < end && spanLeft >= 0) {
520+ View v = createView(fv, pos, (int)spanLeft, rowIndex);
521+ if (v == null) {
522+ break;
523+ }
524+
525+ int bw = v.getBreakWeight(flowAxis, x, spanLeft);
526+ if (bw >= ForcedBreakWeight) {
527+ View w = v.breakView(flowAxis, pos, x, spanLeft);
528+ if (w != null) {
529+ viewBuffer.add(w);
530+ } else if (n == 0) {
531+ // if the view does not break, and it is the only view
532+ // in a row, use the whole view
533+ viewBuffer.add(v);
534+ }
535+ break;
536+ } else if (bw >= breakWeight && bw > BadBreakWeight) {
537+ breakWeight = bw;
538+ breakX = x;
539+ breakSpan = spanLeft;
540+ breakIndex = n;
541+ }
542+
543+ float chunkSpan;
544+ if (flowAxis == X_AXIS && v instanceof TabableView) {
545+ chunkSpan = ((TabableView)v).getTabbedSpan(x, te);
546+ } else {
547+ chunkSpan = v.getPreferredSpan(flowAxis);
548+ }
549+
550+ if (chunkSpan > spanLeft && breakIndex >= 0) {
551+ // row is too long, and we may break
552+ if (breakIndex < n) {
553+ v = viewBuffer.get(breakIndex);
554+ }
555+ for (int i = n - 1; i >= breakIndex; i--) {
556+ viewBuffer.remove(i);
557+ }
558+ v = v.breakView(flowAxis, v.getStartOffset(), breakX, breakSpan);
559+ }
560+
561+ spanLeft -= chunkSpan;
562+ x += chunkSpan;
563+ viewBuffer.add(v);
564+ pos = v.getEndOffset();
565+ n++;
566+ }
567+
568+ View[] views = new View[viewBuffer.size()];
569+ viewBuffer.toArray(views);
570+ row.replace(0, row.getViewCount(), views);
571+ return (views.length > 0 ? row.getEndOffset() : pos);
572+ }
573+
574+ /**
575+ * Adjusts the given row if possible to fit within the
576+ * layout span. By default this will try to find the
577+ * highest break weight possible nearest the end of
578+ * the row. If a forced break is encountered, the
579+ * break will be positioned there.
580+ *
581+ * @param rowIndex the row to adjust to the current layout
582+ * span.
583+ * @param desiredSpan the current layout span >= 0
584+ * @param x the location r starts at.
585+ */
586+ protected void adjustRow(FlowView fv, int rowIndex, int desiredSpan, int x) {
587+ final int flowAxis = fv.getFlowAxis();
588+ View r = fv.getView(rowIndex);
589+ int n = r.getViewCount();
590+ int span = 0;
591+ int bestWeight = BadBreakWeight;
592+ int bestSpan = 0;
593+ int bestIndex = -1;
594+ View v;
595+ for (int i = 0; i < n; i++) {
596+ v = r.getView(i);
597+ int spanLeft = desiredSpan - span;
598+
599+ int w = v.getBreakWeight(flowAxis, x + span, spanLeft);
600+ if ((w >= bestWeight) && (w > BadBreakWeight)) {
601+ bestWeight = w;
602+ bestIndex = i;
603+ bestSpan = span;
604+ if (w >= ForcedBreakWeight) {
605+ // it's a forced break, so there is
606+ // no point in searching further.
607+ break;
608+ }
609+ }
610+ span += v.getPreferredSpan(flowAxis);
611+ }
612+ if (bestIndex < 0) {
613+ // there is nothing that can be broken, leave
614+ // it in it's current state.
615+ return;
616+ }
617+
618+ // Break the best candidate view, and patch up the row.
619+ int spanLeft = desiredSpan - bestSpan;
620+ v = r.getView(bestIndex);
621+ v = v.breakView(flowAxis, v.getStartOffset(), x + bestSpan, spanLeft);
622+ View[] va = new View[1];
623+ va[0] = v;
624+ View lv = getLogicalView(fv);
625+ int p0 = r.getView(bestIndex).getStartOffset();
626+ int p1 = r.getEndOffset();
627+ for (int i = 0; i < lv.getViewCount(); i++) {
628+ View tmpView = lv.getView(i);
629+ if (tmpView.getEndOffset() > p1) {
630+ break;
631+ }
632+ if (tmpView.getStartOffset() >= p0) {
633+ tmpView.setParent(lv);
634+ }
635+ }
636+ r.replace(bestIndex, n - bestIndex, va);
637+ }
638+
639+ void reparentViews(View pool, int startPos) {
640+ int n = pool.getViewIndex(startPos, Position.Bias.Forward);
641+ if (n >= 0) {
642+ for (int i = n; i < pool.getViewCount(); i++) {
643+ pool.getView(i).setParent(pool);
644+ }
645+ }
646+ }
647+
648+ /**
649+ * Creates a view that can be used to represent the current piece
650+ * of the flow. This can be either an entire view from the
651+ * logical view, or a fragment of the logical view.
652+ *
653+ * @param fv the view holding the flow
654+ * @param startOffset the start location for the view being created
655+ * @param spanLeft the about of span left to fill in the row
656+ * @param rowIndex the row the view will be placed into
657+ */
658+ protected View createView(FlowView fv, int startOffset, int spanLeft, int rowIndex) {
659+ // Get the child view that contains the given starting position
660+ View lv = getLogicalView(fv);
661+ int childIndex = lv.getViewIndex(startOffset, Position.Bias.Forward);
662+ View v = lv.getView(childIndex);
663+ if (startOffset==v.getStartOffset()) {
664+ // return the entire view
665+ return v;
666+ }
667+
668+ // return a fragment.
669+ v = v.createFragment(startOffset, v.getEndOffset());
670+ return v;
671+ }
672+ }
673+
674+ /**
675+ * This class can be used to represent a logical view for
676+ * a flow. It keeps the children updated to reflect the state
677+ * of the model, gives the logical child views access to the
678+ * view hierarchy, and calculates a preferred span. It doesn't
679+ * do any rendering, layout, or model/view translation.
680+ */
681+ static class LogicalView extends CompositeView {
682+
683+ LogicalView(Element elem) {
684+ super(elem);
685+ }
686+
687+ protected int getViewIndexAtPosition(int pos) {
688+ Element elem = getElement();
689+ if (elem.isLeaf()) {
690+ return 0;
691+ }
692+ return super.getViewIndexAtPosition(pos);
693+ }
694+
695+ protected void loadChildren(ViewFactory f) {
696+ Element elem = getElement();
697+ if (elem.isLeaf()) {
698+ View v = new LabelView(elem);
699+ append(v);
700+ } else {
701+ super.loadChildren(f);
702+ }
703+ }
704+
705+ /**
706+ * Fetches the attributes to use when rendering. This view
707+ * isn't directly responsible for an element so it returns
708+ * the outer classes attributes.
709+ */
710+ public AttributeSet getAttributes() {
711+ View p = getParent();
712+ return (p != null) ? p.getAttributes() : null;
713+ }
714+
715+ /**
716+ * Determines the preferred span for this view along an
717+ * axis.
718+ *
719+ * @param axis may be either View.X_AXIS or View.Y_AXIS
720+ * @return the span the view would like to be rendered into.
721+ * Typically the view is told to render into the span
722+ * that is returned, although there is no guarantee.
723+ * The parent may choose to resize or break the view.
724+ * @see View#getPreferredSpan
725+ */
726+ public float getPreferredSpan(int axis) {
727+ float maxpref = 0;
728+ float pref = 0;
729+ int n = getViewCount();
730+ for (int i = 0; i < n; i++) {
731+ View v = getView(i);
732+ pref += v.getPreferredSpan(axis);
733+ if (v.getBreakWeight(axis, 0, Integer.MAX_VALUE) >= ForcedBreakWeight) {
734+ maxpref = Math.max(maxpref, pref);
735+ pref = 0;
736+ }
737+ }
738+ maxpref = Math.max(maxpref, pref);
739+ return maxpref;
740+ }
741+
742+ /**
743+ * Determines the minimum span for this view along an
744+ * axis. The is implemented to find the minimum unbreakable
745+ * span.
746+ *
747+ * @param axis may be either View.X_AXIS or View.Y_AXIS
748+ * @return the span the view would like to be rendered into.
749+ * Typically the view is told to render into the span
750+ * that is returned, although there is no guarantee.
751+ * The parent may choose to resize or break the view.
752+ * @see View#getPreferredSpan
753+ */
754+ public float getMinimumSpan(int axis) {
755+ float maxmin = 0;
756+ float min = 0;
757+ boolean nowrap = false;
758+ int n = getViewCount();
759+ for (int i = 0; i < n; i++) {
760+ View v = getView(i);
761+ if (v.getBreakWeight(axis, 0, Integer.MAX_VALUE) == BadBreakWeight) {
762+ min += v.getPreferredSpan(axis);
763+ nowrap = true;
764+ } else if (nowrap) {
765+ maxmin = Math.max(min, maxmin);
766+ nowrap = false;
767+ min = 0;
768+ }
769+ if (v instanceof ComponentView) {
770+ maxmin = Math.max(maxmin, v.getMinimumSpan(axis));
771+ }
772+ }
773+ maxmin = Math.max(maxmin, min);
774+ return maxmin;
775+ }
776+
777+ /**
778+ * Forward the DocumentEvent to the given child view. This
779+ * is implemented to reparent the child to the logical view
780+ * (the children may have been parented by a row in the flow
781+ * if they fit without breaking) and then execute the superclass
782+ * behavior.
783+ *
784+ * @param v the child view to forward the event to.
785+ * @param e the change information from the associated document
786+ * @param a the current allocation of the view
787+ * @param f the factory to use to rebuild if the view has children
788+ * @see #forwardUpdate
789+ * @since 1.3
790+ */
791+ protected void forwardUpdateToView(View v, DocumentEvent e,
792+ Shape a, ViewFactory f) {
793+ View parent = v.getParent();
794+ v.setParent(this);
795+ super.forwardUpdateToView(v, e, a, f);
796+ v.setParent(parent);
797+ }
798+
799+ // The following methods don't do anything useful, they
800+ // simply keep the class from being abstract.
801+
802+ /**
803+ * Renders using the given rendering surface and area on that
804+ * surface. This is implemented to do nothing, the logical
805+ * view is never visible.
806+ *
807+ * @param g the rendering surface to use
808+ * @param allocation the allocated region to render into
809+ * @see View#paint
810+ */
811+ public void paint(Graphics g, Shape allocation) {
812+ }
813+
814+ /**
815+ * Tests whether a point lies before the rectangle range.
816+ * Implemented to return false, as hit detection is not
817+ * performed on the logical view.
818+ *
819+ * @param x the X coordinate >= 0
820+ * @param y the Y coordinate >= 0
821+ * @param alloc the rectangle
822+ * @return true if the point is before the specified range
823+ */
824+ protected boolean isBefore(int x, int y, Rectangle alloc) {
825+ return false;
826+ }
827+
828+ /**
829+ * Tests whether a point lies after the rectangle range.
830+ * Implemented to return false, as hit detection is not
831+ * performed on the logical view.
832+ *
833+ * @param x the X coordinate >= 0
834+ * @param y the Y coordinate >= 0
835+ * @param alloc the rectangle
836+ * @return true if the point is after the specified range
837+ */
838+ protected boolean isAfter(int x, int y, Rectangle alloc) {
839+ return false;
840+ }
841+
842+ /**
843+ * Fetches the child view at the given point.
844+ * Implemented to return null, as hit detection is not
845+ * performed on the logical view.
846+ *
847+ * @param x the X coordinate >= 0
848+ * @param y the Y coordinate >= 0
849+ * @param alloc the parent's allocation on entry, which should
850+ * be changed to the child's allocation on exit
851+ * @return the child view
852+ */
853+ protected View getViewAtPoint(int x, int y, Rectangle alloc) {
854+ return null;
855+ }
856+
857+ /**
858+ * Returns the allocation for a given child.
859+ * Implemented to do nothing, as the logical view doesn't
860+ * perform layout on the children.
861+ *
862+ * @param index the index of the child, >= 0 && < getViewCount()
863+ * @param a the allocation to the interior of the box on entry,
864+ * and the allocation of the child view at the index on exit.
865+ */
866+ protected void childAllocation(int index, Rectangle a) {
867+ }
868+ }
869+
870+
871+}

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