| /* BoxView.java -- An composite view |
| Copyright (C) 2005, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package javax.swing.text; |
| |
| import java.awt.Container; |
| import java.awt.Graphics; |
| import java.awt.Rectangle; |
| import java.awt.Shape; |
| |
| import javax.swing.SizeRequirements; |
| import javax.swing.event.DocumentEvent; |
| |
| /** |
| * An implementation of {@link CompositeView} that arranges its children in |
| * a box along one axis. This is comparable to how the <code>BoxLayout</code> |
| * works, but for <code>View</code> children. |
| * |
| * @author Roman Kennke (roman@kennke.org) |
| */ |
| public class BoxView |
| extends CompositeView |
| { |
| |
| /** |
| * The axis along which this <code>BoxView</code> is laid out. |
| */ |
| private int myAxis; |
| |
| /** |
| * Indicates if the layout is valid along X_AXIS or Y_AXIS. |
| */ |
| private boolean[] layoutValid = new boolean[2]; |
| |
| /** |
| * Indicates if the requirements for an axis are valid. |
| */ |
| private boolean[] requirementsValid = new boolean[2]; |
| |
| /** |
| * The spans along the X_AXIS and Y_AXIS. |
| */ |
| private int[][] spans = new int[2][]; |
| |
| /** |
| * The offsets of the children along the X_AXIS and Y_AXIS. |
| */ |
| private int[][] offsets = new int[2][]; |
| |
| /** |
| * The size requirements along the X_AXIS and Y_AXIS. |
| */ |
| private SizeRequirements[] requirements = new SizeRequirements[2]; |
| |
| /** |
| * The current span along X_AXIS or Y_AXIS. |
| */ |
| private int[] span = new int[2]; |
| |
| /** |
| * Creates a new <code>BoxView</code> for the given |
| * <code>Element</code> and axis. Valid values for the axis are |
| * {@link View#X_AXIS} and {@link View#Y_AXIS}. |
| * |
| * @param element the element that is rendered by this BoxView |
| * @param axis the axis along which the box is laid out |
| */ |
| public BoxView(Element element, int axis) |
| { |
| super(element); |
| myAxis = axis; |
| layoutValid[0] = false; |
| layoutValid[1] = false; |
| requirementsValid[X_AXIS] = false; |
| requirementsValid[Y_AXIS] = false; |
| span[0] = 0; |
| span[1] = 0; |
| requirements[0] = new SizeRequirements(); |
| requirements[1] = new SizeRequirements(); |
| |
| // Initialize the cache arrays. |
| spans[0] = new int[0]; |
| spans[1] = new int[0]; |
| offsets[0] = new int[0]; |
| offsets[1] = new int[0]; |
| } |
| |
| /** |
| * Returns the axis along which this <code>BoxView</code> is laid out. |
| * |
| * @return the axis along which this <code>BoxView</code> is laid out |
| * |
| * @since 1.3 |
| */ |
| public int getAxis() |
| { |
| return myAxis; |
| } |
| |
| /** |
| * Sets the axis along which this <code>BoxView</code> is laid out. |
| * |
| * Valid values for the axis are {@link View#X_AXIS} and |
| * {@link View#Y_AXIS}. |
| * |
| * @param axis the axis along which this <code>BoxView</code> is laid out |
| * |
| * @since 1.3 |
| */ |
| public void setAxis(int axis) |
| { |
| boolean changed = axis != myAxis; |
| myAxis = axis; |
| if (changed) |
| preferenceChanged(null, true, true); |
| } |
| |
| /** |
| * Marks the layout along the specified axis as invalid. This is triggered |
| * automatically when any of the child view changes its preferences |
| * via {@link #preferenceChanged(View, boolean, boolean)}. |
| * |
| * The layout will be updated the next time when |
| * {@link #setSize(float, float)} is called, typically from within the |
| * {@link #paint(Graphics, Shape)} method. |
| * |
| * Valid values for the axis are {@link View#X_AXIS} and |
| * {@link View#Y_AXIS}. |
| * |
| * @param axis an <code>int</code> value |
| * |
| * @since 1.3 |
| */ |
| public void layoutChanged(int axis) |
| { |
| if (axis != X_AXIS && axis != Y_AXIS) |
| throw new IllegalArgumentException("Invalid axis parameter."); |
| layoutValid[axis] = false; |
| } |
| |
| /** |
| * Returns <code>true</code> if the layout along the specified |
| * <code>axis</code> is valid, <code>false</code> otherwise. |
| * |
| * Valid values for the axis are {@link View#X_AXIS} and |
| * {@link View#Y_AXIS}. |
| * |
| * @param axis the axis |
| * |
| * @return <code>true</code> if the layout along the specified |
| * <code>axis</code> is valid, <code>false</code> otherwise |
| * |
| * @since 1.4 |
| */ |
| protected boolean isLayoutValid(int axis) |
| { |
| if (axis != X_AXIS && axis != Y_AXIS) |
| throw new IllegalArgumentException("Invalid axis parameter."); |
| return layoutValid[axis]; |
| } |
| |
| /** |
| * Paints the child <code>View</code> at the specified <code>index</code>. |
| * This method modifies the actual values in <code>alloc</code> so make |
| * sure you have a copy of the original values if you need them. |
| * |
| * @param g the <code>Graphics</code> context to paint to |
| * @param alloc the allocated region for the child to paint into |
| * @param index the index of the child to be painted |
| * |
| * @see #childAllocation(int, Rectangle) |
| */ |
| protected void paintChild(Graphics g, Rectangle alloc, int index) |
| { |
| View child = getView(index); |
| child.paint(g, alloc); |
| } |
| |
| /** |
| * Replaces child views by some other child views. If there are no views to |
| * remove (<code>length == 0</code>), the result is a simple insert, if |
| * there are no children to add (<code>view == null</code>) the result |
| * is a simple removal. |
| * |
| * In addition this invalidates the layout and resizes the internal cache |
| * for the child allocations. The old children's cached allocations can |
| * still be accessed (although they are not guaranteed to be valid), and |
| * the new children will have an initial offset and span of 0. |
| * |
| * @param offset the start offset from where to remove children |
| * @param length the number of children to remove |
| * @param views the views that replace the removed children |
| */ |
| public void replace(int offset, int length, View[] views) |
| { |
| // Actually perform the replace. |
| super.replace(offset, length, views); |
| |
| // Resize and copy data for cache arrays. |
| int newItems = views != null ? views.length : 0; |
| int minor = 1 - myAxis; |
| offsets[myAxis] = replaceLayoutArray(offsets[myAxis], offset, newItems); |
| spans[myAxis] = replaceLayoutArray(spans[myAxis], offset, newItems); |
| layoutValid[myAxis] = false; |
| requirementsValid[myAxis] = false; |
| offsets[minor] = replaceLayoutArray(offsets[minor], offset, newItems); |
| spans[minor] = replaceLayoutArray(spans[minor], offset, newItems); |
| layoutValid[minor] = false; |
| requirementsValid[minor] = false; |
| } |
| |
| /** |
| * Helper method. This updates the layout cache arrays in response |
| * to a call to {@link #replace(int, int, View[])}. |
| * |
| * @param oldArray the old array |
| * |
| * @return the replaced array |
| */ |
| private int[] replaceLayoutArray(int[] oldArray, int offset, int newItems) |
| |
| { |
| int num = getViewCount(); |
| int[] newArray = new int[num]; |
| System.arraycopy(oldArray, 0, newArray, 0, offset); |
| System.arraycopy(oldArray, offset, newArray, offset + newItems, |
| num - newItems - offset); |
| return newArray; |
| } |
| |
| /** |
| * A Rectangle instance to be reused in the paint() method below. |
| */ |
| private final Rectangle tmpRect = new Rectangle(); |
| |
| private Rectangle clipRect = new Rectangle(); |
| |
| /** |
| * Renders the <code>Element</code> that is associated with this |
| * <code>View</code>. |
| * |
| * @param g the <code>Graphics</code> context to render to |
| * @param a the allocated region for the <code>Element</code> |
| */ |
| public void paint(Graphics g, Shape a) |
| { |
| // Try to avoid allocation if possible (almost all cases). |
| Rectangle alloc = a instanceof Rectangle ? (Rectangle) a : a.getBounds(); |
| |
| // This returns a cached instance. |
| alloc = getInsideAllocation(alloc); |
| |
| int count = getViewCount(); |
| for (int i = 0; i < count; i++) |
| { |
| View child = getView(i); |
| tmpRect.setBounds(alloc); |
| childAllocation(i, tmpRect); |
| if (g.hitClip(tmpRect.x, tmpRect.y, tmpRect.width, tmpRect.height)) |
| paintChild(g, tmpRect, i); |
| } |
| } |
| |
| /** |
| * Returns the preferred span of the content managed by this |
| * <code>View</code> along the specified <code>axis</code>. |
| * |
| * @param axis the axis |
| * |
| * @return the preferred span of this <code>View</code>. |
| */ |
| public float getPreferredSpan(int axis) |
| { |
| updateRequirements(axis); |
| // Add margin. |
| float margin; |
| if (axis == X_AXIS) |
| margin = getLeftInset() + getRightInset(); |
| else |
| margin = getTopInset() + getBottomInset(); |
| return requirements[axis].preferred + margin; |
| } |
| |
| /** |
| * Returns the maximum span of this view along the specified axis. |
| * This returns <code>Integer.MAX_VALUE</code> for the minor axis |
| * and the preferred span for the major axis. |
| * |
| * @param axis the axis |
| * |
| * @return the maximum span of this view along the specified axis |
| */ |
| public float getMaximumSpan(int axis) |
| { |
| updateRequirements(axis); |
| // Add margin. |
| float margin; |
| if (axis == X_AXIS) |
| margin = getLeftInset() + getRightInset(); |
| else |
| margin = getTopInset() + getBottomInset(); |
| return requirements[axis].maximum + margin; |
| } |
| |
| /** |
| * Returns the minimum span of this view along the specified axis. |
| * This calculates the minimum span using |
| * {@link #calculateMajorAxisRequirements} or |
| * {@link #calculateMinorAxisRequirements} (depending on the axis) and |
| * returns the resulting minimum span. |
| * |
| * @param axis the axis |
| * |
| * @return the minimum span of this view along the specified axis |
| */ |
| public float getMinimumSpan(int axis) |
| { |
| updateRequirements(axis); |
| // Add margin. |
| float margin; |
| if (axis == X_AXIS) |
| margin = getLeftInset() + getRightInset(); |
| else |
| margin = getTopInset() + getBottomInset(); |
| return requirements[axis].minimum + margin; |
| } |
| |
| /** |
| * Calculates size requirements for a baseline layout. This is not |
| * used by the BoxView itself, but by subclasses that wish to perform |
| * a baseline layout, like the FlowView's rows. |
| * |
| * @param axis the axis that is examined |
| * @param sr the <code>SizeRequirements</code> object to hold the result, |
| * if <code>null</code>, a new one is created |
| * |
| * @return the size requirements for this <code>BoxView</code> along |
| * the specified axis |
| */ |
| protected SizeRequirements baselineRequirements(int axis, |
| SizeRequirements sr) |
| { |
| // Create new instance if sr == null. |
| if (sr == null) |
| sr = new SizeRequirements(); |
| sr.alignment = 0.5F; |
| |
| // Calculate overall ascent and descent. |
| int totalAscentMin = 0; |
| int totalAscentPref = 0; |
| int totalAscentMax = 0; |
| int totalDescentMin = 0; |
| int totalDescentPref = 0; |
| int totalDescentMax = 0; |
| |
| int count = getViewCount(); |
| for (int i = 0; i < count; i++) |
| { |
| View v = getView(i); |
| float align = v.getAlignment(axis); |
| int span = (int) v.getPreferredSpan(axis); |
| int ascent = (int) (align * span); |
| int descent = span - ascent; |
| |
| totalAscentPref = Math.max(ascent, totalAscentPref); |
| totalDescentPref = Math.max(descent, totalDescentPref); |
| if (v.getResizeWeight(axis) > 0) |
| { |
| // If the view is resizable, then use the min and max size |
| // of the view. |
| span = (int) v.getMinimumSpan(axis); |
| ascent = (int) (align * span); |
| descent = span - ascent; |
| totalAscentMin = Math.max(ascent, totalAscentMin); |
| totalDescentMin = Math.max(descent, totalDescentMin); |
| |
| span = (int) v.getMaximumSpan(axis); |
| ascent = (int) (align * span); |
| descent = span - ascent; |
| totalAscentMax = Math.max(ascent, totalAscentMax); |
| totalDescentMax = Math.max(descent, totalDescentMax); |
| } |
| else |
| { |
| // If the view is not resizable, use the preferred span. |
| totalAscentMin = Math.max(ascent, totalAscentMin); |
| totalDescentMin = Math.max(descent, totalDescentMin); |
| totalAscentMax = Math.max(ascent, totalAscentMax); |
| totalDescentMax = Math.max(descent, totalDescentMax); |
| } |
| } |
| |
| // Preferred overall span is the sum of the preferred ascent and descent. |
| // With overflow check. |
| sr.preferred = (int) Math.min((long) totalAscentPref |
| + (long) totalDescentPref, |
| Integer.MAX_VALUE); |
| |
| // Align along the baseline. |
| if (sr.preferred > 0) |
| sr.alignment = (float) totalAscentPref / sr.preferred; |
| |
| if (sr.alignment == 0) |
| { |
| // Nothing above the baseline, use the descent. |
| sr.minimum = totalDescentMin; |
| sr.maximum = totalDescentMax; |
| } |
| else if (sr.alignment == 1.0F) |
| { |
| // Nothing below the baseline, use the descent. |
| sr.minimum = totalAscentMin; |
| sr.maximum = totalAscentMax; |
| } |
| else |
| { |
| sr.minimum = Math.max((int) (totalAscentMin / sr.alignment), |
| (int) (totalDescentMin / (1.0F - sr.alignment))); |
| sr.maximum = Math.min((int) (totalAscentMax / sr.alignment), |
| (int) (totalDescentMax / (1.0F - sr.alignment))); |
| } |
| return sr; |
| } |
| |
| /** |
| * Calculates the baseline layout of the children of this |
| * <code>BoxView</code> along the specified axis. |
| * |
| * This is not used by the BoxView itself, but by subclasses that wish to |
| * perform a baseline layout, like the FlowView's rows. |
| * |
| * @param span the target span |
| * @param axis the axis that is examined |
| * @param offsets an empty array, filled with the offsets of the children |
| * @param spans an empty array, filled with the spans of the children |
| */ |
| protected void baselineLayout(int span, int axis, int[] offsets, |
| int[] spans) |
| { |
| int totalAscent = (int) (span * getAlignment(axis)); |
| int totalDescent = span - totalAscent; |
| |
| int count = getViewCount(); |
| for (int i = 0; i < count; i++) |
| { |
| View v = getView(i); |
| float align = v.getAlignment(axis); |
| int viewSpan; |
| if (v.getResizeWeight(axis) > 0) |
| { |
| // If possible, then resize for best fit. |
| int min = (int) v.getMinimumSpan(axis); |
| int max = (int) v.getMaximumSpan(axis); |
| if (align == 0.0F) |
| viewSpan = Math.max(Math.min(max, totalDescent), min); |
| else if (align == 1.0F) |
| viewSpan = Math.max(Math.min(max, totalAscent), min); |
| else |
| { |
| int fit = (int) Math.min(totalAscent / align, |
| totalDescent / (1.0F - align)); |
| viewSpan = Math.max(Math.min(max, fit), min); |
| } |
| } |
| else |
| viewSpan = (int) v.getPreferredSpan(axis); |
| offsets[i] = totalAscent - (int) (viewSpan * align); |
| spans[i] = viewSpan; |
| } |
| } |
| |
| /** |
| * Calculates the size requirements of this <code>BoxView</code> along |
| * its major axis, that is the axis specified in the constructor. |
| * |
| * @param axis the axis that is examined |
| * @param sr the <code>SizeRequirements</code> object to hold the result, |
| * if <code>null</code>, a new one is created |
| * |
| * @return the size requirements for this <code>BoxView</code> along |
| * the specified axis |
| */ |
| protected SizeRequirements calculateMajorAxisRequirements(int axis, |
| SizeRequirements sr) |
| { |
| SizeRequirements res = sr; |
| if (res == null) |
| res = new SizeRequirements(); |
| |
| float min = 0; |
| float pref = 0; |
| float max = 0; |
| |
| int n = getViewCount(); |
| for (int i = 0; i < n; i++) |
| { |
| View child = getView(i); |
| min += child.getMinimumSpan(axis); |
| pref += child.getPreferredSpan(axis); |
| max += child.getMaximumSpan(axis); |
| } |
| |
| res.minimum = (int) min; |
| res.preferred = (int) pref; |
| res.maximum = (int) max; |
| res.alignment = 0.5F; |
| |
| return res; |
| } |
| |
| /** |
| * Calculates the size requirements of this <code>BoxView</code> along |
| * its minor axis, that is the axis opposite to the axis specified in the |
| * constructor. |
| * |
| * @param axis the axis that is examined |
| * @param sr the <code>SizeRequirements</code> object to hold the result, |
| * if <code>null</code>, a new one is created |
| * |
| * @return the size requirements for this <code>BoxView</code> along |
| * the specified axis |
| */ |
| protected SizeRequirements calculateMinorAxisRequirements(int axis, |
| SizeRequirements sr) |
| { |
| SizeRequirements res = sr; |
| if (res == null) |
| res = new SizeRequirements(); |
| |
| res.minimum = 0; |
| res.preferred = 0; |
| res.maximum = Integer.MAX_VALUE; |
| res.alignment = 0.5F; |
| int n = getViewCount(); |
| for (int i = 0; i < n; i++) |
| { |
| View child = getView(i); |
| res.minimum = Math.max((int) child.getMinimumSpan(axis), res.minimum); |
| res.preferred = Math.max((int) child.getPreferredSpan(axis), |
| res.preferred); |
| res.maximum = Math.max((int) child.getMaximumSpan(axis), res.maximum); |
| } |
| |
| return res; |
| } |
| |
| |
| /** |
| * Returns <code>true</code> if the specified point lies before the |
| * given <code>Rectangle</code>, <code>false</code> otherwise. |
| * |
| * "Before" is typically defined as being to the left or above. |
| * |
| * @param x the X coordinate of the point |
| * @param y the Y coordinate of the point |
| * @param r the rectangle to test the point against |
| * |
| * @return <code>true</code> if the specified point lies before the |
| * given <code>Rectangle</code>, <code>false</code> otherwise |
| */ |
| protected boolean isBefore(int x, int y, Rectangle r) |
| { |
| boolean result = false; |
| |
| if (myAxis == X_AXIS) |
| result = x < r.x; |
| else |
| result = y < r.y; |
| |
| return result; |
| } |
| |
| /** |
| * Returns <code>true</code> if the specified point lies after the |
| * given <code>Rectangle</code>, <code>false</code> otherwise. |
| * |
| * "After" is typically defined as being to the right or below. |
| * |
| * @param x the X coordinate of the point |
| * @param y the Y coordinate of the point |
| * @param r the rectangle to test the point against |
| * |
| * @return <code>true</code> if the specified point lies after the |
| * given <code>Rectangle</code>, <code>false</code> otherwise |
| */ |
| protected boolean isAfter(int x, int y, Rectangle r) |
| { |
| boolean result = false; |
| |
| if (myAxis == X_AXIS) |
| result = x > r.x + r.width; |
| else |
| result = y > r.y + r.height; |
| |
| return result; |
| } |
| |
| /** |
| * Returns the child <code>View</code> at the specified location. |
| * |
| * @param x the X coordinate |
| * @param y the Y coordinate |
| * @param r the inner allocation of this <code>BoxView</code> on entry, |
| * the allocation of the found child on exit |
| * |
| * @return the child <code>View</code> at the specified location |
| */ |
| protected View getViewAtPoint(int x, int y, Rectangle r) |
| { |
| View result = null; |
| int count = getViewCount(); |
| if (myAxis == X_AXIS) |
| { |
| // Border case. Requested point is left from the box. |
| if (x < r.x + offsets[X_AXIS][0]) |
| { |
| childAllocation(0, r); |
| result = getView(0); |
| } |
| else |
| { |
| // Search views inside box. |
| for (int i = 0; i < count && result == null; i++) |
| { |
| if (x < r.x + offsets[X_AXIS][i]) |
| { |
| childAllocation(i - 1, r); |
| result = getView(i - 1); |
| } |
| } |
| } |
| } |
| else // Same algorithm for Y_AXIS. |
| { |
| // Border case. Requested point is above the box. |
| if (y < r.y + offsets[Y_AXIS][0]) |
| { |
| childAllocation(0, r); |
| result = getView(0); |
| } |
| else |
| { |
| // Search views inside box. |
| for (int i = 0; i < count && result == null; i++) |
| { |
| if (y < r.y + offsets[Y_AXIS][i]) |
| { |
| childAllocation(i - 1, r); |
| result = getView(i - 1); |
| } |
| } |
| } |
| } |
| // Not found, other border case: point is right from or below the box. |
| if (result == null) |
| { |
| childAllocation(count - 1, r); |
| result = getView(count - 1); |
| } |
| return result; |
| } |
| |
| /** |
| * Computes the allocation for a child <code>View</code>. The parameter |
| * <code>a</code> stores the allocation of this <code>CompositeView</code> |
| * and is then adjusted to hold the allocation of the child view. |
| * |
| * @param index |
| * the index of the child <code>View</code> |
| * @param a |
| * the allocation of this <code>CompositeView</code> before the |
| * call, the allocation of the child on exit |
| */ |
| protected void childAllocation(int index, Rectangle a) |
| { |
| a.x += offsets[X_AXIS][index]; |
| a.y += offsets[Y_AXIS][index]; |
| a.width = spans[X_AXIS][index]; |
| a.height = spans[Y_AXIS][index]; |
| } |
| |
| /** |
| * Lays out the children of this <code>BoxView</code> with the specified |
| * bounds. |
| * |
| * @param width the width of the allocated region for the children (that |
| * is the inner allocation of this <code>BoxView</code> |
| * @param height the height of the allocated region for the children (that |
| * is the inner allocation of this <code>BoxView</code> |
| */ |
| protected void layout(int width, int height) |
| { |
| layoutAxis(X_AXIS, width); |
| layoutAxis(Y_AXIS, height); |
| } |
| |
| private void layoutAxis(int axis, int s) |
| { |
| if (span[axis] != s) |
| layoutValid[axis] = false; |
| if (! layoutValid[axis]) |
| { |
| span[axis] = s; |
| updateRequirements(axis); |
| if (axis == myAxis) |
| layoutMajorAxis(span[axis], axis, offsets[axis], spans[axis]); |
| else |
| layoutMinorAxis(span[axis], axis, offsets[axis], spans[axis]); |
| layoutValid[axis] = true; |
| |
| // Push out child layout. |
| int viewCount = getViewCount(); |
| for (int i = 0; i < viewCount; i++) |
| { |
| View v = getView(i); |
| v.setSize(spans[X_AXIS][i], spans[Y_AXIS][i]); |
| } |
| } |
| } |
| |
| /** |
| * Performs the layout along the major axis of a <code>BoxView</code>. |
| * |
| * @param targetSpan the (inner) span of the <code>BoxView</code> in which |
| * to layout the children |
| * @param axis the axis along which the layout is performed |
| * @param offsets the array that holds the offsets of the children on exit |
| * @param spans the array that holds the spans of the children on exit |
| */ |
| protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets, |
| int[] spans) |
| { |
| // Set the spans to the preferred sizes. Determine the space |
| // that we have to adjust the sizes afterwards. |
| long sumPref = 0; |
| int n = getViewCount(); |
| for (int i = 0; i < n; i++) |
| { |
| View child = getView(i); |
| spans[i] = (int) child.getPreferredSpan(axis); |
| sumPref += spans[i]; |
| } |
| |
| // Try to adjust the spans so that we fill the targetSpan. |
| long diff = targetSpan - sumPref; |
| float factor = 0.0F; |
| int[] diffs = null; |
| if (diff != 0) |
| { |
| long total = 0; |
| diffs = new int[n]; |
| for (int i = 0; i < n; i++) |
| { |
| View child = getView(i); |
| int span; |
| if (diff < 0) |
| { |
| span = (int) child.getMinimumSpan(axis); |
| diffs[i] = spans[i] - span; |
| } |
| else |
| { |
| span = (int) child.getMaximumSpan(axis); |
| diffs[i] = span - spans[i]; |
| } |
| total += span; |
| } |
| |
| float maxAdjust = Math.abs(total - sumPref); |
| factor = diff / maxAdjust; |
| factor = Math.min(factor, 1.0F); |
| factor = Math.max(factor, -1.0F); |
| } |
| |
| // Actually perform adjustments. |
| int totalOffs = 0; |
| for (int i = 0; i < n; i++) |
| { |
| offsets[i] = totalOffs; |
| if (diff != 0) |
| { |
| float adjust = factor * diffs[i]; |
| spans[i] += Math.round(adjust); |
| } |
| // Avoid overflow here. |
| totalOffs = (int) Math.min((long) totalOffs + (long) spans[i], |
| Integer.MAX_VALUE); |
| } |
| } |
| |
| /** |
| * Performs the layout along the minor axis of a <code>BoxView</code>. |
| * |
| * @param targetSpan the (inner) span of the <code>BoxView</code> in which |
| * to layout the children |
| * @param axis the axis along which the layout is performed |
| * @param offsets the array that holds the offsets of the children on exit |
| * @param spans the array that holds the spans of the children on exit |
| */ |
| protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets, |
| int[] spans) |
| { |
| int count = getViewCount(); |
| for (int i = 0; i < count; i++) |
| { |
| View child = getView(i); |
| int max = (int) child.getMaximumSpan(axis); |
| if (max < targetSpan) |
| { |
| // Align child when it can't be made as wide as the target span. |
| float align = child.getAlignment(axis); |
| offsets[i] = (int) ((targetSpan - max) * align); |
| spans[i] = max; |
| } |
| else |
| { |
| // Expand child to target width if possible. |
| int min = (int) child.getMinimumSpan(axis); |
| offsets[i] = 0; |
| spans[i] = Math.max(min, targetSpan); |
| } |
| } |
| } |
| |
| /** |
| * Returns <code>true</code> if the cached allocations for the children |
| * are still valid, <code>false</code> otherwise. |
| * |
| * @return <code>true</code> if the cached allocations for the children |
| * are still valid, <code>false</code> otherwise |
| */ |
| protected boolean isAllocationValid() |
| { |
| return isLayoutValid(X_AXIS) && isLayoutValid(Y_AXIS); |
| } |
| |
| /** |
| * Return the current width of the box. This is the last allocated width. |
| * |
| * @return the current width of the box |
| */ |
| public int getWidth() |
| { |
| // The RI returns the following here, however, I'd think that is a bug. |
| // return span[X_AXIS] + getLeftInset() - getRightInset(); |
| return span[X_AXIS] + getLeftInset() + getRightInset(); |
| } |
| |
| /** |
| * Return the current height of the box. This is the last allocated height. |
| * |
| * @return the current height of the box |
| */ |
| public int getHeight() |
| { |
| // The RI returns the following here, however, I'd think that is a bug. |
| // return span[Y_AXIS] + getTopInset() - getBottomInset(); |
| return span[Y_AXIS] + getTopInset() + getBottomInset(); |
| } |
| |
| /** |
| * Sets the size of the view. If the actual size has changed, the layout |
| * is updated accordingly. |
| * |
| * @param width the new width |
| * @param height the new height |
| */ |
| public void setSize(float width, float height) |
| { |
| layout((int) (width - getLeftInset() - getRightInset()), |
| (int) (height - getTopInset() - getBottomInset())); |
| } |
| |
| /** |
| * Returns the span for the child view with the given index for the specified |
| * axis. |
| * |
| * @param axis the axis to examine, either <code>X_AXIS</code> or |
| * <code>Y_AXIS</code> |
| * @param childIndex the index of the child for for which to return the span |
| * |
| * @return the span for the child view with the given index for the specified |
| * axis |
| */ |
| protected int getSpan(int axis, int childIndex) |
| { |
| if (axis != X_AXIS && axis != Y_AXIS) |
| throw new IllegalArgumentException("Illegal axis argument"); |
| return spans[axis][childIndex]; |
| } |
| |
| /** |
| * Returns the offset for the child view with the given index for the |
| * specified axis. |
| * |
| * @param axis the axis to examine, either <code>X_AXIS</code> or |
| * <code>Y_AXIS</code> |
| * @param childIndex the index of the child for for which to return the span |
| * |
| * @return the offset for the child view with the given index for the |
| * specified axis |
| */ |
| protected int getOffset(int axis, int childIndex) |
| { |
| if (axis != X_AXIS && axis != Y_AXIS) |
| throw new IllegalArgumentException("Illegal axis argument"); |
| return offsets[axis][childIndex]; |
| } |
| |
| /** |
| * Returns the alignment for this box view for the specified axis. The |
| * axis that is tiled (the major axis) will be requested to be aligned |
| * centered (0.5F). The minor axis alignment depends on the child view's |
| * total alignment. |
| * |
| * @param axis the axis which is examined |
| * |
| * @return the alignment for this box view for the specified axis |
| */ |
| public float getAlignment(int axis) |
| { |
| updateRequirements(axis); |
| return requirements[axis].alignment; |
| } |
| |
| /** |
| * Called by a child View when its preferred span has changed. |
| * |
| * @param width indicates that the preferred width of the child changed. |
| * @param height indicates that the preferred height of the child changed. |
| * @param child the child View. |
| */ |
| public void preferenceChanged(View child, boolean width, boolean height) |
| { |
| if (width) |
| { |
| layoutValid[X_AXIS] = false; |
| requirementsValid[X_AXIS] = false; |
| } |
| if (height) |
| { |
| layoutValid[Y_AXIS] = false; |
| requirementsValid[Y_AXIS] = false; |
| } |
| super.preferenceChanged(child, width, height); |
| } |
| |
| /** |
| * Maps the document model position <code>pos</code> to a Shape |
| * in the view coordinate space. This method overrides CompositeView's |
| * method to make sure the children are allocated properly before |
| * calling the super's behaviour. |
| */ |
| public Shape modelToView(int pos, Shape a, Position.Bias bias) |
| throws BadLocationException |
| { |
| // Make sure everything is allocated properly and then call super |
| if (! isAllocationValid()) |
| { |
| Rectangle bounds = a.getBounds(); |
| setSize(bounds.width, bounds.height); |
| } |
| return super.modelToView(pos, a, bias); |
| } |
| |
| /** |
| * Returns the resize weight of this view. A value of <code>0</code> or less |
| * means this view is not resizeable. Positive values make the view |
| * resizeable. This implementation returns <code>0</code> for the major |
| * axis and <code>1</code> for the minor axis of this box view. |
| * |
| * @param axis the axis |
| * |
| * @return the resizability of this view along the specified axis |
| * |
| * @throws IllegalArgumentException if <code>axis</code> is invalid |
| */ |
| public int getResizeWeight(int axis) |
| { |
| if (axis != X_AXIS && axis != Y_AXIS) |
| throw new IllegalArgumentException("Illegal axis argument"); |
| updateRequirements(axis); |
| int weight = 0; |
| if ((requirements[axis].preferred != requirements[axis].minimum) |
| || (requirements[axis].preferred != requirements[axis].maximum)) |
| weight = 1; |
| return weight; |
| } |
| |
| /** |
| * Returns the child allocation for the child view with the specified |
| * <code>index</code>. If the layout is invalid, this returns |
| * <code>null</code>. |
| * |
| * @param index the child view index |
| * @param a the allocation to this view |
| * |
| * @return the child allocation for the child view with the specified |
| * <code>index</code> or <code>null</code> if the layout is invalid |
| * or <code>a</code> is null |
| */ |
| public Shape getChildAllocation(int index, Shape a) |
| { |
| Shape ret = null; |
| if (isAllocationValid() && a != null) |
| ret = super.getChildAllocation(index, a); |
| return ret; |
| } |
| |
| protected void forwardUpdate(DocumentEvent.ElementChange ec, DocumentEvent e, |
| Shape a, ViewFactory vf) |
| { |
| boolean wasValid = isLayoutValid(myAxis); |
| super.forwardUpdate(ec, e, a, vf); |
| // Trigger repaint when one of the children changed the major axis. |
| if (wasValid && ! isLayoutValid(myAxis)) |
| { |
| Container c = getContainer(); |
| if (a != null && c != null) |
| { |
| int pos = e.getOffset(); |
| int index = getViewIndexAtPosition(pos); |
| Rectangle r = getInsideAllocation(a); |
| if (myAxis == X_AXIS) |
| { |
| r.x += offsets[myAxis][index]; |
| r.width -= offsets[myAxis][index]; |
| } |
| else |
| { |
| r.y += offsets[myAxis][index]; |
| r.height -= offsets[myAxis][index]; |
| } |
| c.repaint(r.x, r.y, r.width, r.height); |
| } |
| } |
| } |
| |
| public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) |
| { |
| if (! isAllocationValid()) |
| { |
| Rectangle r = a instanceof Rectangle ? (Rectangle) a : a.getBounds(); |
| setSize(r.width, r.height); |
| } |
| return super.viewToModel(x, y, a, bias); |
| } |
| |
| protected boolean flipEastAndWestAtEnds(int position, Position.Bias bias) |
| { |
| // FIXME: What to do here? |
| return super.flipEastAndWestAtEnds(position, bias); |
| } |
| |
| /** |
| * Updates the view's cached requirements along the specified axis if |
| * necessary. The requirements are only updated if the layout for the |
| * specified axis is marked as invalid. |
| * |
| * @param axis the axis |
| */ |
| private void updateRequirements(int axis) |
| { |
| if (axis != Y_AXIS && axis != X_AXIS) |
| throw new IllegalArgumentException("Illegal axis: " + axis); |
| if (! requirementsValid[axis]) |
| { |
| if (axis == myAxis) |
| requirements[axis] = calculateMajorAxisRequirements(axis, |
| requirements[axis]); |
| else |
| requirements[axis] = calculateMinorAxisRequirements(axis, |
| requirements[axis]); |
| requirementsValid[axis] = true; |
| } |
| } |
| } |