| /* | |
| * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package javax.swing.text; | |
| import java.util.*; | |
| import java.util.List; | |
| import java.awt.*; | |
| import javax.swing.SwingUtilities; | |
| import javax.swing.event.DocumentEvent; | |
| /** | |
| * A box that does layout asynchronously. This | |
| * is useful to keep the GUI event thread moving by | |
| * not doing any layout on it. The layout is done | |
| * on a granularity of operations on the child views. | |
| * After each child view is accessed for some part | |
| * of layout (a potentially time consuming operation) | |
| * the remaining tasks can be abandoned or a new higher | |
| * priority task (i.e. to service a synchronous request | |
| * or a visible area) can be taken on. | |
| * <p> | |
| * While the child view is being accessed | |
| * a read lock is acquired on the associated document | |
| * so that the model is stable while being accessed. | |
| * | |
| * @author Timothy Prinzing | |
| * @since 1.3 | |
| */ | |
| public class AsyncBoxView extends View { | |
| /** | |
| * Construct a box view that does asynchronous layout. | |
| * | |
| * @param elem the element of the model to represent | |
| * @param axis the axis to tile along. This can be | |
| * either X_AXIS or Y_AXIS. | |
| */ | |
| public AsyncBoxView(Element elem, int axis) { | |
| super(elem); | |
| stats = new ArrayList<ChildState>(); | |
| this.axis = axis; | |
| locator = new ChildLocator(); | |
| flushTask = new FlushTask(); | |
| minorSpan = Short.MAX_VALUE; | |
| estimatedMajorSpan = false; | |
| } | |
| /** | |
| * Fetch the major axis (the axis the children | |
| * are tiled along). This will have a value of | |
| * either X_AXIS or Y_AXIS. | |
| * @return the major axis | |
| */ | |
| public int getMajorAxis() { | |
| return axis; | |
| } | |
| /** | |
| * Fetch the minor axis (the axis orthogonal | |
| * to the tiled axis). This will have a value of | |
| * either X_AXIS or Y_AXIS. | |
| * @return the minor axis | |
| */ | |
| public int getMinorAxis() { | |
| return (axis == X_AXIS) ? Y_AXIS : X_AXIS; | |
| } | |
| /** | |
| * Get the top part of the margin around the view. | |
| * @return the top part of the margin around the view | |
| */ | |
| public float getTopInset() { | |
| return topInset; | |
| } | |
| /** | |
| * Set the top part of the margin around the view. | |
| * | |
| * @param i the value of the inset | |
| */ | |
| public void setTopInset(float i) { | |
| topInset = i; | |
| } | |
| /** | |
| * Get the bottom part of the margin around the view. | |
| * @return the bottom part of the margin around the view | |
| */ | |
| public float getBottomInset() { | |
| return bottomInset; | |
| } | |
| /** | |
| * Set the bottom part of the margin around the view. | |
| * | |
| * @param i the value of the inset | |
| */ | |
| public void setBottomInset(float i) { | |
| bottomInset = i; | |
| } | |
| /** | |
| * Get the left part of the margin around the view. | |
| * @return the left part of the margin around the view | |
| */ | |
| public float getLeftInset() { | |
| return leftInset; | |
| } | |
| /** | |
| * Set the left part of the margin around the view. | |
| * | |
| * @param i the value of the inset | |
| */ | |
| public void setLeftInset(float i) { | |
| leftInset = i; | |
| } | |
| /** | |
| * Get the right part of the margin around the view. | |
| * @return the right part of the margin around the view | |
| */ | |
| public float getRightInset() { | |
| return rightInset; | |
| } | |
| /** | |
| * Set the right part of the margin around the view. | |
| * | |
| * @param i the value of the inset | |
| */ | |
| public void setRightInset(float i) { | |
| rightInset = i; | |
| } | |
| /** | |
| * Fetch the span along an axis that is taken up by the insets. | |
| * | |
| * @param axis the axis to determine the total insets along, | |
| * either X_AXIS or Y_AXIS. | |
| * @return the span along an axis that is taken up by the insets | |
| * @since 1.4 | |
| */ | |
| protected float getInsetSpan(int axis) { | |
| float margin = (axis == X_AXIS) ? | |
| getLeftInset() + getRightInset() : getTopInset() + getBottomInset(); | |
| return margin; | |
| } | |
| /** | |
| * Set the estimatedMajorSpan property that determines if the | |
| * major span should be treated as being estimated. If this | |
| * property is true, the value of setSize along the major axis | |
| * will change the requirements along the major axis and incremental | |
| * changes will be ignored until all of the children have been updated | |
| * (which will cause the property to automatically be set to false). | |
| * If the property is false the value of the majorSpan will be | |
| * considered to be accurate and incremental changes will be | |
| * added into the total as they are calculated. | |
| * | |
| * @param isEstimated new value for the estimatedMajorSpan property | |
| * @since 1.4 | |
| */ | |
| protected void setEstimatedMajorSpan(boolean isEstimated) { | |
| estimatedMajorSpan = isEstimated; | |
| } | |
| /** | |
| * Is the major span currently estimated? | |
| * @return whether or not the major span currently estimated | |
| * | |
| * @since 1.4 | |
| */ | |
| protected boolean getEstimatedMajorSpan() { | |
| return estimatedMajorSpan; | |
| } | |
| /** | |
| * Fetch the object representing the layout state of | |
| * of the child at the given index. | |
| * | |
| * @param index the child index. This should be a | |
| * value >= 0 and < getViewCount(). | |
| * @return the object representing the layout state of | |
| * of the child at the given index | |
| */ | |
| protected ChildState getChildState(int index) { | |
| synchronized(stats) { | |
| if ((index >= 0) && (index < stats.size())) { | |
| return stats.get(index); | |
| } | |
| return null; | |
| } | |
| } | |
| /** | |
| * Fetch the queue to use for layout. | |
| * @return the queue to use for layout | |
| */ | |
| protected LayoutQueue getLayoutQueue() { | |
| return LayoutQueue.getDefaultQueue(); | |
| } | |
| /** | |
| * New ChildState records are created through | |
| * this method to allow subclasses the extend | |
| * the ChildState records to do/hold more. | |
| * @param v the view | |
| * @return new child state | |
| */ | |
| protected ChildState createChildState(View v) { | |
| return new ChildState(v); | |
| } | |
| /** | |
| * Requirements changed along the major axis. | |
| * This is called by the thread doing layout for | |
| * the given ChildState object when it has completed | |
| * fetching the child views new preferences. | |
| * Typically this would be the layout thread, but | |
| * might be the event thread if it is trying to update | |
| * something immediately (such as to perform a | |
| * model/view translation). | |
| * <p> | |
| * This is implemented to mark the major axis as having | |
| * changed so that a future check to see if the requirements | |
| * need to be published to the parent view will consider | |
| * the major axis. If the span along the major axis is | |
| * not estimated, it is updated by the given delta to reflect | |
| * the incremental change. The delta is ignored if the | |
| * major span is estimated. | |
| * @param cs the child state | |
| * @param delta the delta | |
| */ | |
| protected synchronized void majorRequirementChange(ChildState cs, float delta) { | |
| if (estimatedMajorSpan == false) { | |
| majorSpan += delta; | |
| } | |
| majorChanged = true; | |
| } | |
| /** | |
| * Requirements changed along the minor axis. | |
| * This is called by the thread doing layout for | |
| * the given ChildState object when it has completed | |
| * fetching the child views new preferences. | |
| * Typically this would be the layout thread, but | |
| * might be the GUI thread if it is trying to update | |
| * something immediately (such as to perform a | |
| * model/view translation). | |
| * @param cs the child state | |
| */ | |
| protected synchronized void minorRequirementChange(ChildState cs) { | |
| minorChanged = true; | |
| } | |
| /** | |
| * Publish the changes in preferences upward to the parent | |
| * view. This is normally called by the layout thread. | |
| */ | |
| protected void flushRequirementChanges() { | |
| AbstractDocument doc = (AbstractDocument) getDocument(); | |
| try { | |
| doc.readLock(); | |
| View parent = null; | |
| boolean horizontal = false; | |
| boolean vertical = false; | |
| synchronized(this) { | |
| // perform tasks that iterate over the children while | |
| // preventing the collection from changing. | |
| synchronized(stats) { | |
| int n = getViewCount(); | |
| if ((n > 0) && (minorChanged || estimatedMajorSpan)) { | |
| LayoutQueue q = getLayoutQueue(); | |
| ChildState min = getChildState(0); | |
| ChildState pref = getChildState(0); | |
| float span = 0f; | |
| for (int i = 1; i < n; i++) { | |
| ChildState cs = getChildState(i); | |
| if (minorChanged) { | |
| if (cs.min > min.min) { | |
| min = cs; | |
| } | |
| if (cs.pref > pref.pref) { | |
| pref = cs; | |
| } | |
| } | |
| if (estimatedMajorSpan) { | |
| span += cs.getMajorSpan(); | |
| } | |
| } | |
| if (minorChanged) { | |
| minRequest = min; | |
| prefRequest = pref; | |
| } | |
| if (estimatedMajorSpan) { | |
| majorSpan = span; | |
| estimatedMajorSpan = false; | |
| majorChanged = true; | |
| } | |
| } | |
| } | |
| // message preferenceChanged | |
| if (majorChanged || minorChanged) { | |
| parent = getParent(); | |
| if (parent != null) { | |
| if (axis == X_AXIS) { | |
| horizontal = majorChanged; | |
| vertical = minorChanged; | |
| } else { | |
| vertical = majorChanged; | |
| horizontal = minorChanged; | |
| } | |
| } | |
| majorChanged = false; | |
| minorChanged = false; | |
| } | |
| } | |
| // propagate a preferenceChanged, using the | |
| // layout thread. | |
| if (parent != null) { | |
| parent.preferenceChanged(this, horizontal, vertical); | |
| // probably want to change this to be more exact. | |
| Component c = getContainer(); | |
| if (c != null) { | |
| c.repaint(); | |
| } | |
| } | |
| } finally { | |
| doc.readUnlock(); | |
| } | |
| } | |
| /** | |
| * Calls the superclass to update the child views, and | |
| * updates the status records for the children. This | |
| * is expected to be called while a write lock is held | |
| * on the model so that interaction with the layout | |
| * thread will not happen (i.e. the layout thread | |
| * acquires a read lock before doing anything). | |
| * | |
| * @param offset the starting offset into the child views >= 0 | |
| * @param length the number of existing views to replace >= 0 | |
| * @param views the child views to insert | |
| */ | |
| public void replace(int offset, int length, View[] views) { | |
| synchronized(stats) { | |
| // remove the replaced state records | |
| for (int i = 0; i < length; i++) { | |
| ChildState cs = stats.remove(offset); | |
| float csSpan = cs.getMajorSpan(); | |
| cs.getChildView().setParent(null); | |
| if (csSpan != 0) { | |
| majorRequirementChange(cs, -csSpan); | |
| } | |
| } | |
| // insert the state records for the new children | |
| LayoutQueue q = getLayoutQueue(); | |
| if (views != null) { | |
| for (int i = 0; i < views.length; i++) { | |
| ChildState s = createChildState(views[i]); | |
| stats.add(offset + i, s); | |
| q.addTask(s); | |
| } | |
| } | |
| // notify that the size changed | |
| q.addTask(flushTask); | |
| } | |
| } | |
| /** | |
| * Loads all of the children to initialize the view. | |
| * This is called by the {@link #setParent setParent} | |
| * method. Subclasses can reimplement this to initialize | |
| * their child views in a different manner. The default | |
| * implementation creates a child view for each | |
| * child element. | |
| * <p> | |
| * Normally a write-lock is held on the Document while | |
| * the children are being changed, which keeps the rendering | |
| * and layout threads safe. The exception to this is when | |
| * the view is initialized to represent an existing element | |
| * (via this method), so it is synchronized to exclude | |
| * preferenceChanged while we are initializing. | |
| * | |
| * @param f the view factory | |
| * @see #setParent | |
| */ | |
| protected void loadChildren(ViewFactory f) { | |
| Element e = getElement(); | |
| int n = e.getElementCount(); | |
| if (n > 0) { | |
| View[] added = new View[n]; | |
| for (int i = 0; i < n; i++) { | |
| added[i] = f.create(e.getElement(i)); | |
| } | |
| replace(0, 0, added); | |
| } | |
| } | |
| /** | |
| * Fetches the child view index representing the given position in | |
| * the model. This is implemented to fetch the view in the case | |
| * where there is a child view for each child element. | |
| * | |
| * @param pos the position >= 0 | |
| * @param b the position bias | |
| * @return index of the view representing the given position, or | |
| * -1 if no view represents that position | |
| */ | |
| protected synchronized int getViewIndexAtPosition(int pos, Position.Bias b) { | |
| boolean isBackward = (b == Position.Bias.Backward); | |
| pos = (isBackward) ? Math.max(0, pos - 1) : pos; | |
| Element elem = getElement(); | |
| return elem.getElementIndex(pos); | |
| } | |
| /** | |
| * Update the layout in response to receiving notification of | |
| * change from the model. This is implemented to note the | |
| * change on the ChildLocator so that offsets of the children | |
| * will be correctly computed. | |
| * | |
| * @param ec changes to the element this view is responsible | |
| * for (may be null if there were no changes). | |
| * @param e the change information from the associated document | |
| * @param a the current allocation of the view | |
| * @see #insertUpdate | |
| * @see #removeUpdate | |
| * @see #changedUpdate | |
| */ | |
| protected void updateLayout(DocumentEvent.ElementChange ec, | |
| DocumentEvent e, Shape a) { | |
| if (ec != null) { | |
| // the newly inserted children don't have a valid | |
| // offset so the child locator needs to be messaged | |
| // that the child prior to the new children has | |
| // changed size. | |
| int index = Math.max(ec.getIndex() - 1, 0); | |
| ChildState cs = getChildState(index); | |
| locator.childChanged(cs); | |
| } | |
| } | |
| // --- View methods ------------------------------------ | |
| /** | |
| * Sets the parent of the view. | |
| * This is reimplemented to provide the superclass | |
| * behavior as well as calling the <code>loadChildren</code> | |
| * method if this view does not already have children. | |
| * The children should not be loaded in the | |
| * constructor because the act of setting the parent | |
| * may cause them to try to search up the hierarchy | |
| * (to get the hosting Container for example). | |
| * If this view has children (the view is being moved | |
| * from one place in the view hierarchy to another), | |
| * the <code>loadChildren</code> method will not be called. | |
| * | |
| * @param parent the parent of the view, null if none | |
| */ | |
| public void setParent(View parent) { | |
| super.setParent(parent); | |
| if ((parent != null) && (getViewCount() == 0)) { | |
| ViewFactory f = getViewFactory(); | |
| loadChildren(f); | |
| } | |
| } | |
| /** | |
| * Child views can call this on the parent to indicate that | |
| * the preference has changed and should be reconsidered | |
| * for layout. This is reimplemented to queue new work | |
| * on the layout thread. This method gets messaged from | |
| * multiple threads via the children. | |
| * | |
| * @param child the child view | |
| * @param width true if the width preference has changed | |
| * @param height true if the height preference has changed | |
| * @see javax.swing.JComponent#revalidate | |
| */ | |
| public synchronized void preferenceChanged(View child, boolean width, boolean height) { | |
| if (child == null) { | |
| getParent().preferenceChanged(this, width, height); | |
| } else { | |
| if (changing != null) { | |
| View cv = changing.getChildView(); | |
| if (cv == child) { | |
| // size was being changed on the child, no need to | |
| // queue work for it. | |
| changing.preferenceChanged(width, height); | |
| return; | |
| } | |
| } | |
| int index = getViewIndex(child.getStartOffset(), | |
| Position.Bias.Forward); | |
| ChildState cs = getChildState(index); | |
| cs.preferenceChanged(width, height); | |
| LayoutQueue q = getLayoutQueue(); | |
| q.addTask(cs); | |
| q.addTask(flushTask); | |
| } | |
| } | |
| /** | |
| * Sets the size of the view. This should cause | |
| * layout of the view if the view caches any layout | |
| * information. | |
| * <p> | |
| * Since the major axis is updated asynchronously and should be | |
| * the sum of the tiled children the call is ignored for the major | |
| * axis. Since the minor axis is flexible, work is queued to resize | |
| * the children if the minor span changes. | |
| * | |
| * @param width the width >= 0 | |
| * @param height the height >= 0 | |
| */ | |
| public void setSize(float width, float height) { | |
| setSpanOnAxis(X_AXIS, width); | |
| setSpanOnAxis(Y_AXIS, height); | |
| } | |
| /** | |
| * Retrieves the size of the view along an axis. | |
| * | |
| * @param axis may be either <code>View.X_AXIS</code> or | |
| * <code>View.Y_AXIS</code> | |
| * @return the current span of the view along the given axis, >= 0 | |
| */ | |
| float getSpanOnAxis(int axis) { | |
| if (axis == getMajorAxis()) { | |
| return majorSpan; | |
| } | |
| return minorSpan; | |
| } | |
| /** | |
| * Sets the size of the view along an axis. Since the major | |
| * axis is updated asynchronously and should be the sum of the | |
| * tiled children the call is ignored for the major axis. Since | |
| * the minor axis is flexible, work is queued to resize the | |
| * children if the minor span changes. | |
| * | |
| * @param axis may be either <code>View.X_AXIS</code> or | |
| * <code>View.Y_AXIS</code> | |
| * @param span the span to layout to >= 0 | |
| */ | |
| void setSpanOnAxis(int axis, float span) { | |
| float margin = getInsetSpan(axis); | |
| if (axis == getMinorAxis()) { | |
| float targetSpan = span - margin; | |
| if (targetSpan != minorSpan) { | |
| minorSpan = targetSpan; | |
| // mark all of the ChildState instances as needing to | |
| // resize the child, and queue up work to fix them. | |
| int n = getViewCount(); | |
| if (n != 0) { | |
| LayoutQueue q = getLayoutQueue(); | |
| for (int i = 0; i < n; i++) { | |
| ChildState cs = getChildState(i); | |
| cs.childSizeValid = false; | |
| q.addTask(cs); | |
| } | |
| q.addTask(flushTask); | |
| } | |
| } | |
| } else { | |
| // along the major axis the value is ignored | |
| // unless the estimatedMajorSpan property is | |
| // true. | |
| if (estimatedMajorSpan) { | |
| majorSpan = span - margin; | |
| } | |
| } | |
| } | |
| /** | |
| * Render the view using the given allocation and | |
| * rendering surface. | |
| * <p> | |
| * This is implemented to determine whether or not the | |
| * desired region to be rendered (i.e. the unclipped | |
| * area) is up to date or not. If up-to-date the children | |
| * are rendered. If not up-to-date, a task to build | |
| * the desired area is placed on the layout queue as | |
| * a high priority task. This keeps by event thread | |
| * moving by rendering if ready, and postponing until | |
| * a later time if not ready (since paint requests | |
| * can be rescheduled). | |
| * | |
| * @param g the rendering surface to use | |
| * @param alloc the allocated region to render into | |
| * @see View#paint | |
| */ | |
| public void paint(Graphics g, Shape alloc) { | |
| synchronized (locator) { | |
| locator.setAllocation(alloc); | |
| locator.paintChildren(g); | |
| } | |
| } | |
| /** | |
| * Determines the preferred span for this view along an | |
| * axis. | |
| * | |
| * @param axis may be either View.X_AXIS or View.Y_AXIS | |
| * @return the span the view would like to be rendered into >= 0. | |
| * Typically the view is told to render into the span | |
| * that is returned, although there is no guarantee. | |
| * The parent may choose to resize or break the view. | |
| * @throws IllegalArgumentException for an invalid axis type | |
| */ | |
| public float getPreferredSpan(int axis) { | |
| float margin = getInsetSpan(axis); | |
| if (axis == this.axis) { | |
| return majorSpan + margin; | |
| } | |
| if (prefRequest != null) { | |
| View child = prefRequest.getChildView(); | |
| return child.getPreferredSpan(axis) + margin; | |
| } | |
| // nothing is known about the children yet | |
| return margin + 30; | |
| } | |
| /** | |
| * Determines the minimum span for this view along an | |
| * axis. | |
| * | |
| * @param axis may be either View.X_AXIS or View.Y_AXIS | |
| * @return the span the view would like to be rendered into >= 0. | |
| * Typically the view is told to render into the span | |
| * that is returned, although there is no guarantee. | |
| * The parent may choose to resize or break the view. | |
| * @throws IllegalArgumentException for an invalid axis type | |
| */ | |
| public float getMinimumSpan(int axis) { | |
| if (axis == this.axis) { | |
| return getPreferredSpan(axis); | |
| } | |
| if (minRequest != null) { | |
| View child = minRequest.getChildView(); | |
| return child.getMinimumSpan(axis); | |
| } | |
| // nothing is known about the children yet | |
| if (axis == X_AXIS) { | |
| return getLeftInset() + getRightInset() + 5; | |
| } else { | |
| return getTopInset() + getBottomInset() + 5; | |
| } | |
| } | |
| /** | |
| * Determines the maximum span for this view along an | |
| * axis. | |
| * | |
| * @param axis may be either View.X_AXIS or View.Y_AXIS | |
| * @return the span the view would like to be rendered into >= 0. | |
| * Typically the view is told to render into the span | |
| * that is returned, although there is no guarantee. | |
| * The parent may choose to resize or break the view. | |
| * @throws IllegalArgumentException for an invalid axis type | |
| */ | |
| public float getMaximumSpan(int axis) { | |
| if (axis == this.axis) { | |
| return getPreferredSpan(axis); | |
| } | |
| return Integer.MAX_VALUE; | |
| } | |
| /** | |
| * Returns the number of views in this view. Since | |
| * the default is to not be a composite view this | |
| * returns 0. | |
| * | |
| * @return the number of views >= 0 | |
| * @see View#getViewCount | |
| */ | |
| public int getViewCount() { | |
| synchronized(stats) { | |
| return stats.size(); | |
| } | |
| } | |
| /** | |
| * Gets the nth child view. Since there are no | |
| * children by default, this returns null. | |
| * | |
| * @param n the number of the view to get, >= 0 && < getViewCount() | |
| * @return the view | |
| */ | |
| public View getView(int n) { | |
| ChildState cs = getChildState(n); | |
| if (cs != null) { | |
| return cs.getChildView(); | |
| } | |
| return null; | |
| } | |
| /** | |
| * Fetches the allocation for the given child view. | |
| * This enables finding out where various views | |
| * are located, without assuming the views store | |
| * their location. This returns null since the | |
| * default is to not have any child views. | |
| * | |
| * @param index the index of the child, >= 0 && < getViewCount() | |
| * @param a the allocation to this view. | |
| * @return the allocation to the child | |
| */ | |
| public Shape getChildAllocation(int index, Shape a) { | |
| Shape ca = locator.getChildAllocation(index, a); | |
| return ca; | |
| } | |
| /** | |
| * Returns the child view index representing the given position in | |
| * the model. By default a view has no children so this is implemented | |
| * to return -1 to indicate there is no valid child index for any | |
| * position. | |
| * | |
| * @param pos the position >= 0 | |
| * @return index of the view representing the given position, or | |
| * -1 if no view represents that position | |
| * @since 1.3 | |
| */ | |
| public int getViewIndex(int pos, Position.Bias b) { | |
| return getViewIndexAtPosition(pos, b); | |
| } | |
| /** | |
| * Provides a mapping from the document model coordinate space | |
| * to the coordinate space of the view mapped to it. | |
| * | |
| * @param pos the position to convert >= 0 | |
| * @param a the allocated region to render into | |
| * @param b the bias toward the previous character or the | |
| * next character represented by the offset, in case the | |
| * position is a boundary of two views. | |
| * @return the bounding box of the given position is returned | |
| * @throws BadLocationException if the given position does | |
| * not represent a valid location in the associated document | |
| * @throws IllegalArgumentException for an invalid bias argument | |
| * @see View#viewToModel | |
| */ | |
| public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException { | |
| int index = getViewIndex(pos, b); | |
| Shape ca = locator.getChildAllocation(index, a); | |
| // forward to the child view, and make sure we don't | |
| // interact with the layout thread by synchronizing | |
| // on the child state. | |
| ChildState cs = getChildState(index); | |
| synchronized (cs) { | |
| View cv = cs.getChildView(); | |
| Shape v = cv.modelToView(pos, ca, b); | |
| return v; | |
| } | |
| } | |
| /** | |
| * Provides a mapping from the view coordinate space to the logical | |
| * coordinate space of the model. The biasReturn argument will be | |
| * filled in to indicate that the point given is closer to the next | |
| * character in the model or the previous character in the model. | |
| * <p> | |
| * This is expected to be called by the GUI thread, holding a | |
| * read-lock on the associated model. It is implemented to | |
| * locate the child view and determine it's allocation with a | |
| * lock on the ChildLocator object, and to call viewToModel | |
| * on the child view with a lock on the ChildState object | |
| * to avoid interaction with the layout thread. | |
| * | |
| * @param x the X coordinate >= 0 | |
| * @param y the Y coordinate >= 0 | |
| * @param a the allocated region to render into | |
| * @return the location within the model that best represents the | |
| * given point in the view >= 0. The biasReturn argument will be | |
| * filled in to indicate that the point given is closer to the next | |
| * character in the model or the previous character in the model. | |
| */ | |
| public int viewToModel(float x, float y, Shape a, Position.Bias[] biasReturn) { | |
| int pos; // return position | |
| int index; // child index to forward to | |
| Shape ca; // child allocation | |
| // locate the child view and it's allocation so that | |
| // we can forward to it. Make sure the layout thread | |
| // doesn't change anything by trying to flush changes | |
| // to the parent while the GUI thread is trying to | |
| // find the child and it's allocation. | |
| synchronized (locator) { | |
| index = locator.getViewIndexAtPoint(x, y, a); | |
| ca = locator.getChildAllocation(index, a); | |
| } | |
| // forward to the child view, and make sure we don't | |
| // interact with the layout thread by synchronizing | |
| // on the child state. | |
| ChildState cs = getChildState(index); | |
| synchronized (cs) { | |
| View v = cs.getChildView(); | |
| pos = v.viewToModel(x, y, ca, biasReturn); | |
| } | |
| return pos; | |
| } | |
| /** | |
| * Provides a way to determine the next visually represented model | |
| * location that one might place a caret. Some views may not be visible, | |
| * they might not be in the same order found in the model, or they just | |
| * might not allow access to some of the locations in the model. | |
| * This method enables specifying a position to convert | |
| * within the range of >=0. If the value is -1, a position | |
| * will be calculated automatically. If the value < -1, | |
| * the {@code BadLocationException} will be thrown. | |
| * | |
| * @param pos the position to convert | |
| * @param a the allocated region to render into | |
| * @param direction the direction from the current position that can | |
| * be thought of as the arrow keys typically found on a keyboard; | |
| * this may be one of the following: | |
| * <ul style="list-style-type:none"> | |
| * <li><code>SwingConstants.WEST</code></li> | |
| * <li><code>SwingConstants.EAST</code></li> | |
| * <li><code>SwingConstants.NORTH</code></li> | |
| * <li><code>SwingConstants.SOUTH</code></li> | |
| * </ul> | |
| * @param biasRet an array contain the bias that was checked | |
| * @return the location within the model that best represents the next | |
| * location visual position | |
| * @throws BadLocationException the given position is not a valid | |
| * position within the document | |
| * @throws IllegalArgumentException if <code>direction</code> is invalid | |
| */ | |
| public int getNextVisualPositionFrom(int pos, Position.Bias b, Shape a, | |
| int direction, | |
| Position.Bias[] biasRet) | |
| throws BadLocationException { | |
| if (pos < -1 || pos > getDocument().getLength()) { | |
| throw new BadLocationException("invalid position", pos); | |
| } | |
| return Utilities.getNextVisualPositionFrom( | |
| this, pos, b, a, direction, biasRet); | |
| } | |
| // --- variables ----------------------------------------- | |
| /** | |
| * The major axis against which the children are | |
| * tiled. | |
| */ | |
| int axis; | |
| /** | |
| * The children and their layout statistics. | |
| */ | |
| List<ChildState> stats; | |
| /** | |
| * Current span along the major axis. This | |
| * is also the value returned by getMinimumSize, | |
| * getPreferredSize, and getMaximumSize along | |
| * the major axis. | |
| */ | |
| float majorSpan; | |
| /** | |
| * Is the span along the major axis estimated? | |
| */ | |
| boolean estimatedMajorSpan; | |
| /** | |
| * Current span along the minor axis. This | |
| * is what layout was done against (i.e. things | |
| * are flexible in this direction). | |
| */ | |
| float minorSpan; | |
| /** | |
| * Object that manages the offsets of the | |
| * children. All locking for management of | |
| * child locations is on this object. | |
| */ | |
| protected ChildLocator locator; | |
| float topInset; | |
| float bottomInset; | |
| float leftInset; | |
| float rightInset; | |
| ChildState minRequest; | |
| ChildState prefRequest; | |
| boolean majorChanged; | |
| boolean minorChanged; | |
| Runnable flushTask; | |
| /** | |
| * Child that is actively changing size. This often | |
| * causes a preferenceChanged, so this is a cache to | |
| * possibly speed up the marking the state. It also | |
| * helps flag an opportunity to avoid adding to flush | |
| * task to the layout queue. | |
| */ | |
| ChildState changing; | |
| /** | |
| * A class to manage the effective position of the | |
| * child views in a localized area while changes are | |
| * being made around the localized area. The AsyncBoxView | |
| * may be continuously changing, but the visible area | |
| * needs to remain fairly stable until the layout thread | |
| * decides to publish an update to the parent. | |
| * @since 1.3 | |
| */ | |
| public class ChildLocator { | |
| /** | |
| * construct a child locator. | |
| */ | |
| public ChildLocator() { | |
| lastAlloc = new Rectangle(); | |
| childAlloc = new Rectangle(); | |
| } | |
| /** | |
| * Notification that a child changed. This can effect | |
| * whether or not new offset calculations are needed. | |
| * This is called by a ChildState object that has | |
| * changed it's major span. This can therefore be | |
| * called by multiple threads. | |
| * @param cs the child state | |
| */ | |
| public synchronized void childChanged(ChildState cs) { | |
| if (lastValidOffset == null) { | |
| lastValidOffset = cs; | |
| } else if (cs.getChildView().getStartOffset() < | |
| lastValidOffset.getChildView().getStartOffset()) { | |
| lastValidOffset = cs; | |
| } | |
| } | |
| /** | |
| * Paint the children that intersect the clip area. | |
| * @param g the rendering surface to use | |
| */ | |
| public synchronized void paintChildren(Graphics g) { | |
| Rectangle clip = g.getClipBounds(); | |
| float targetOffset = (axis == X_AXIS) ? | |
| clip.x - lastAlloc.x : clip.y - lastAlloc.y; | |
| int index = getViewIndexAtVisualOffset(targetOffset); | |
| int n = getViewCount(); | |
| float offs = getChildState(index).getMajorOffset(); | |
| for (int i = index; i < n; i++) { | |
| ChildState cs = getChildState(i); | |
| cs.setMajorOffset(offs); | |
| Shape ca = getChildAllocation(i); | |
| if (intersectsClip(ca, clip)) { | |
| synchronized (cs) { | |
| View v = cs.getChildView(); | |
| v.paint(g, ca); | |
| } | |
| } else { | |
| // done painting intersection | |
| break; | |
| } | |
| offs += cs.getMajorSpan(); | |
| } | |
| } | |
| /** | |
| * Fetch the allocation to use for a child view. | |
| * This will update the offsets for all children | |
| * not yet updated before the given index. | |
| * @param index the child index | |
| * @param a the allocation | |
| * @return the allocation to use for a child view | |
| */ | |
| public synchronized Shape getChildAllocation(int index, Shape a) { | |
| if (a == null) { | |
| return null; | |
| } | |
| setAllocation(a); | |
| ChildState cs = getChildState(index); | |
| if (lastValidOffset == null) { | |
| lastValidOffset = getChildState(0); | |
| } | |
| if (cs.getChildView().getStartOffset() > | |
| lastValidOffset.getChildView().getStartOffset()) { | |
| // offsets need to be updated | |
| updateChildOffsetsToIndex(index); | |
| } | |
| Shape ca = getChildAllocation(index); | |
| return ca; | |
| } | |
| /** | |
| * Fetches the child view index at the given point. | |
| * This is called by the various View methods that | |
| * need to calculate which child to forward a message | |
| * to. This should be called by a block synchronized | |
| * on this object, and would typically be followed | |
| * with one or more calls to getChildAllocation that | |
| * should also be in the synchronized block. | |
| * | |
| * @param x the X coordinate >= 0 | |
| * @param y the Y coordinate >= 0 | |
| * @param a the allocation to the View | |
| * @return the nearest child index | |
| */ | |
| public int getViewIndexAtPoint(float x, float y, Shape a) { | |
| setAllocation(a); | |
| float targetOffset = (axis == X_AXIS) ? x - lastAlloc.x : y - lastAlloc.y; | |
| int index = getViewIndexAtVisualOffset(targetOffset); | |
| return index; | |
| } | |
| /** | |
| * Fetch the allocation to use for a child view. | |
| * <em>This does not update the offsets in the ChildState | |
| * records.</em> | |
| * @param index the index | |
| * @return the allocation to use for a child view | |
| */ | |
| protected Shape getChildAllocation(int index) { | |
| ChildState cs = getChildState(index); | |
| if (! cs.isLayoutValid()) { | |
| cs.run(); | |
| } | |
| if (axis == X_AXIS) { | |
| childAlloc.x = lastAlloc.x + (int) cs.getMajorOffset(); | |
| childAlloc.y = lastAlloc.y + (int) cs.getMinorOffset(); | |
| childAlloc.width = (int) cs.getMajorSpan(); | |
| childAlloc.height = (int) cs.getMinorSpan(); | |
| } else { | |
| childAlloc.y = lastAlloc.y + (int) cs.getMajorOffset(); | |
| childAlloc.x = lastAlloc.x + (int) cs.getMinorOffset(); | |
| childAlloc.height = (int) cs.getMajorSpan(); | |
| childAlloc.width = (int) cs.getMinorSpan(); | |
| } | |
| childAlloc.x += (int)getLeftInset(); | |
| childAlloc.y += (int)getRightInset(); | |
| return childAlloc; | |
| } | |
| /** | |
| * Copy the currently allocated shape into the Rectangle | |
| * used to store the current allocation. This would be | |
| * a floating point rectangle in a Java2D-specific implementation. | |
| * @param a the allocation | |
| */ | |
| protected void setAllocation(Shape a) { | |
| if (a instanceof Rectangle) { | |
| lastAlloc.setBounds((Rectangle) a); | |
| } else { | |
| lastAlloc.setBounds(a.getBounds()); | |
| } | |
| setSize(lastAlloc.width, lastAlloc.height); | |
| } | |
| /** | |
| * Locate the view responsible for an offset into the box | |
| * along the major axis. Make sure that offsets are set | |
| * on the ChildState objects up to the given target span | |
| * past the desired offset. | |
| * @param targetOffset the target offset | |
| * | |
| * @return index of the view representing the given visual | |
| * location (targetOffset), or -1 if no view represents | |
| * that location | |
| */ | |
| protected int getViewIndexAtVisualOffset(float targetOffset) { | |
| int n = getViewCount(); | |
| if (n > 0) { | |
| boolean lastValid = (lastValidOffset != null); | |
| if (lastValidOffset == null) { | |
| lastValidOffset = getChildState(0); | |
| } | |
| if (targetOffset > majorSpan) { | |
| // should only get here on the first time display. | |
| if (!lastValid) { | |
| return 0; | |
| } | |
| int pos = lastValidOffset.getChildView().getStartOffset(); | |
| int index = getViewIndex(pos, Position.Bias.Forward); | |
| return index; | |
| } else if (targetOffset > lastValidOffset.getMajorOffset()) { | |
| // roll offset calculations forward | |
| return updateChildOffsets(targetOffset); | |
| } else { | |
| // no changes prior to the needed offset | |
| // this should be a binary search | |
| float offs = 0f; | |
| for (int i = 0; i < n; i++) { | |
| ChildState cs = getChildState(i); | |
| float nextOffs = offs + cs.getMajorSpan(); | |
| if (targetOffset < nextOffs) { | |
| return i; | |
| } | |
| offs = nextOffs; | |
| } | |
| } | |
| } | |
| return n - 1; | |
| } | |
| /** | |
| * Move the location of the last offset calculation forward | |
| * to the desired offset. | |
| */ | |
| int updateChildOffsets(float targetOffset) { | |
| int n = getViewCount(); | |
| int targetIndex = n - 1; | |
| int pos = lastValidOffset.getChildView().getStartOffset(); | |
| int startIndex = getViewIndex(pos, Position.Bias.Forward); | |
| float start = lastValidOffset.getMajorOffset(); | |
| float lastOffset = start; | |
| for (int i = startIndex; i < n; i++) { | |
| ChildState cs = getChildState(i); | |
| cs.setMajorOffset(lastOffset); | |
| lastOffset += cs.getMajorSpan(); | |
| if (targetOffset < lastOffset) { | |
| targetIndex = i; | |
| lastValidOffset = cs; | |
| break; | |
| } | |
| } | |
| return targetIndex; | |
| } | |
| /** | |
| * Move the location of the last offset calculation forward | |
| * to the desired index. | |
| */ | |
| void updateChildOffsetsToIndex(int index) { | |
| int pos = lastValidOffset.getChildView().getStartOffset(); | |
| int startIndex = getViewIndex(pos, Position.Bias.Forward); | |
| float lastOffset = lastValidOffset.getMajorOffset(); | |
| for (int i = startIndex; i <= index; i++) { | |
| ChildState cs = getChildState(i); | |
| cs.setMajorOffset(lastOffset); | |
| lastOffset += cs.getMajorSpan(); | |
| } | |
| } | |
| boolean intersectsClip(Shape childAlloc, Rectangle clip) { | |
| Rectangle cs = (childAlloc instanceof Rectangle) ? | |
| (Rectangle) childAlloc : childAlloc.getBounds(); | |
| if (cs.intersects(clip)) { | |
| // Make sure that lastAlloc also contains childAlloc, | |
| // this will be false if haven't yet flushed changes. | |
| return lastAlloc.intersects(cs); | |
| } | |
| return false; | |
| } | |
| /** | |
| * The location of the last offset calculation | |
| * that is valid. | |
| */ | |
| protected ChildState lastValidOffset; | |
| /** | |
| * The last seen allocation (for repainting when changes | |
| * are flushed upward). | |
| */ | |
| protected Rectangle lastAlloc; | |
| /** | |
| * A shape to use for the child allocation to avoid | |
| * creating a lot of garbage. | |
| */ | |
| protected Rectangle childAlloc; | |
| } | |
| /** | |
| * A record representing the layout state of a | |
| * child view. It is runnable as a task on another | |
| * thread. All access to the child view that is | |
| * based upon a read-lock on the model should synchronize | |
| * on this object (i.e. The layout thread and the GUI | |
| * thread can both have a read lock on the model at the | |
| * same time and are not protected from each other). | |
| * Access to a child view hierarchy is serialized via | |
| * synchronization on the ChildState instance. | |
| * @since 1.3 | |
| */ | |
| public class ChildState implements Runnable { | |
| /** | |
| * Construct a child status. This needs to start | |
| * out as fairly large so we don't falsely begin with | |
| * the idea that all of the children are visible. | |
| * @param v the view | |
| * @since 1.4 | |
| */ | |
| public ChildState(View v) { | |
| child = v; | |
| minorValid = false; | |
| majorValid = false; | |
| childSizeValid = false; | |
| child.setParent(AsyncBoxView.this); | |
| } | |
| /** | |
| * Fetch the child view this record represents. | |
| * @return the child view this record represents | |
| */ | |
| public View getChildView() { | |
| return child; | |
| } | |
| /** | |
| * Update the child state. This should be | |
| * called by the thread that desires to spend | |
| * time updating the child state (intended to | |
| * be the layout thread). | |
| * <p> | |
| * This acquires a read lock on the associated | |
| * document for the duration of the update to | |
| * ensure the model is not changed while it is | |
| * operating. The first thing to do would be | |
| * to see if any work actually needs to be done. | |
| * The following could have conceivably happened | |
| * while the state was waiting to be updated: | |
| * <ol> | |
| * <li>The child may have been removed from the | |
| * view hierarchy. | |
| * <li>The child may have been updated by a | |
| * higher priority operation (i.e. the child | |
| * may have become visible). | |
| * </ol> | |
| */ | |
| public void run () { | |
| AbstractDocument doc = (AbstractDocument) getDocument(); | |
| try { | |
| doc.readLock(); | |
| if (minorValid && majorValid && childSizeValid) { | |
| // nothing to do | |
| return; | |
| } | |
| if (child.getParent() == AsyncBoxView.this) { | |
| // this may overwrite another threads cached | |
| // value for actively changing... but that just | |
| // means it won't use the cache if there is an | |
| // overwrite. | |
| synchronized(AsyncBoxView.this) { | |
| changing = this; | |
| } | |
| updateChild(); | |
| synchronized(AsyncBoxView.this) { | |
| changing = null; | |
| } | |
| // setting the child size on the minor axis | |
| // may have caused it to change it's preference | |
| // along the major axis. | |
| updateChild(); | |
| } | |
| } finally { | |
| doc.readUnlock(); | |
| } | |
| } | |
| void updateChild() { | |
| boolean minorUpdated = false; | |
| synchronized(this) { | |
| if (! minorValid) { | |
| int minorAxis = getMinorAxis(); | |
| min = child.getMinimumSpan(minorAxis); | |
| pref = child.getPreferredSpan(minorAxis); | |
| max = child.getMaximumSpan(minorAxis); | |
| minorValid = true; | |
| minorUpdated = true; | |
| } | |
| } | |
| if (minorUpdated) { | |
| minorRequirementChange(this); | |
| } | |
| boolean majorUpdated = false; | |
| float delta = 0.0f; | |
| synchronized(this) { | |
| if (! majorValid) { | |
| float old = span; | |
| span = child.getPreferredSpan(axis); | |
| delta = span - old; | |
| majorValid = true; | |
| majorUpdated = true; | |
| } | |
| } | |
| if (majorUpdated) { | |
| majorRequirementChange(this, delta); | |
| locator.childChanged(this); | |
| } | |
| synchronized(this) { | |
| if (! childSizeValid) { | |
| float w; | |
| float h; | |
| if (axis == X_AXIS) { | |
| w = span; | |
| h = getMinorSpan(); | |
| } else { | |
| w = getMinorSpan(); | |
| h = span; | |
| } | |
| childSizeValid = true; | |
| child.setSize(w, h); | |
| } | |
| } | |
| } | |
| /** | |
| * What is the span along the minor axis. | |
| * @return the span along the minor axis | |
| */ | |
| public float getMinorSpan() { | |
| if (max < minorSpan) { | |
| return max; | |
| } | |
| // make it the target width, or as small as it can get. | |
| return Math.max(min, minorSpan); | |
| } | |
| /** | |
| * What is the offset along the minor axis | |
| * @return the offset along the minor axis | |
| */ | |
| public float getMinorOffset() { | |
| if (max < minorSpan) { | |
| // can't make the child this wide, align it | |
| float align = child.getAlignment(getMinorAxis()); | |
| return ((minorSpan - max) * align); | |
| } | |
| return 0f; | |
| } | |
| /** | |
| * What is the span along the major axis. | |
| * @return the span along the major axis | |
| */ | |
| public float getMajorSpan() { | |
| return span; | |
| } | |
| /** | |
| * Get the offset along the major axis. | |
| * @return the offset along the major axis | |
| */ | |
| public float getMajorOffset() { | |
| return offset; | |
| } | |
| /** | |
| * This method should only be called by the ChildLocator, | |
| * it is simply a convenient place to hold the cached | |
| * location. | |
| * @param offs offsets | |
| */ | |
| public void setMajorOffset(float offs) { | |
| offset = offs; | |
| } | |
| /** | |
| * Mark preferences changed for this child. | |
| * | |
| * @param width true if the width preference has changed | |
| * @param height true if the height preference has changed | |
| * @see javax.swing.JComponent#revalidate | |
| */ | |
| public void preferenceChanged(boolean width, boolean height) { | |
| if (axis == X_AXIS) { | |
| if (width) { | |
| majorValid = false; | |
| } | |
| if (height) { | |
| minorValid = false; | |
| } | |
| } else { | |
| if (width) { | |
| minorValid = false; | |
| } | |
| if (height) { | |
| majorValid = false; | |
| } | |
| } | |
| childSizeValid = false; | |
| } | |
| /** | |
| * Has the child view been laid out. | |
| * @return whether or not the child view been laid out. | |
| */ | |
| public boolean isLayoutValid() { | |
| return (minorValid && majorValid && childSizeValid); | |
| } | |
| // minor axis | |
| private float min; | |
| private float pref; | |
| private float max; | |
| private boolean minorValid; | |
| // major axis | |
| private float span; | |
| private float offset; | |
| private boolean majorValid; | |
| private View child; | |
| private boolean childSizeValid; | |
| } | |
| /** | |
| * Task to flush requirement changes upward | |
| */ | |
| class FlushTask implements Runnable { | |
| public void run() { | |
| flushRequirementChanges(); | |
| } | |
| } | |
| } |