| /* | |
| * Copyright (c) 1997, 2014, 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; | |
| import java.awt.*; | |
| import java.io.Serializable; | |
| /** | |
| * For the convenience of layout managers, | |
| * calculates information about the size and position of components. | |
| * All size and position calculation methods are class methods | |
| * that take arrays of SizeRequirements as arguments. | |
| * The SizeRequirements class supports two types of layout: | |
| * | |
| * <blockquote> | |
| * <dl> | |
| * <dt> tiled | |
| * <dd> The components are placed end-to-end, | |
| * starting either at coordinate 0 (the leftmost or topmost position) | |
| * or at the coordinate representing the end of the allocated span | |
| * (the rightmost or bottommost position). | |
| * | |
| * <dt> aligned | |
| * <dd> The components are aligned as specified | |
| * by each component's X or Y alignment value. | |
| * </dl> | |
| * </blockquote> | |
| * | |
| * <p> | |
| * | |
| * Each SizeRequirements object contains information | |
| * about either the width (and X alignment) | |
| * or height (and Y alignment) | |
| * of a single component or a group of components: | |
| * | |
| * <blockquote> | |
| * <dl> | |
| * <dt> <code>minimum</code> | |
| * <dd> The smallest reasonable width/height of the component | |
| * or component group, in pixels. | |
| * | |
| * <dt> <code>preferred</code> | |
| * <dd> The natural width/height of the component | |
| * or component group, in pixels. | |
| * | |
| * <dt> <code>maximum</code> | |
| * <dd> The largest reasonable width/height of the component | |
| * or component group, in pixels. | |
| * | |
| * <dt> <code>alignment</code> | |
| * <dd> The X/Y alignment of the component | |
| * or component group. | |
| * </dl> | |
| * </blockquote> | |
| * <p> | |
| * <strong>Warning:</strong> | |
| * Serialized objects of this class will not be compatible with | |
| * future Swing releases. The current serialization support is | |
| * appropriate for short term storage or RMI between applications running | |
| * the same version of Swing. As of 1.4, support for long term storage | |
| * of all JavaBeans | |
| * has been added to the <code>java.beans</code> package. | |
| * Please see {@link java.beans.XMLEncoder}. | |
| * | |
| * @see Component#getMinimumSize | |
| * @see Component#getPreferredSize | |
| * @see Component#getMaximumSize | |
| * @see Component#getAlignmentX | |
| * @see Component#getAlignmentY | |
| * | |
| * @author Timothy Prinzing | |
| * @since 1.2 | |
| */ | |
| @SuppressWarnings("serial") // Same-version serialization only | |
| public class SizeRequirements implements Serializable { | |
| /** | |
| * The minimum size required. | |
| * For a component <code>comp</code>, this should be equal to either | |
| * <code>comp.getMinimumSize().width</code> or | |
| * <code>comp.getMinimumSize().height</code>. | |
| */ | |
| public int minimum; | |
| /** | |
| * The preferred (natural) size. | |
| * For a component <code>comp</code>, this should be equal to either | |
| * <code>comp.getPreferredSize().width</code> or | |
| * <code>comp.getPreferredSize().height</code>. | |
| */ | |
| public int preferred; | |
| /** | |
| * The maximum size allowed. | |
| * For a component <code>comp</code>, this should be equal to either | |
| * <code>comp.getMaximumSize().width</code> or | |
| * <code>comp.getMaximumSize().height</code>. | |
| */ | |
| public int maximum; | |
| /** | |
| * The alignment, specified as a value between 0.0 and 1.0, | |
| * inclusive. | |
| * To specify centering, the alignment should be 0.5. | |
| */ | |
| public float alignment; | |
| /** | |
| * Creates a SizeRequirements object with the minimum, preferred, | |
| * and maximum sizes set to zero and an alignment value of 0.5 | |
| * (centered). | |
| */ | |
| public SizeRequirements() { | |
| minimum = 0; | |
| preferred = 0; | |
| maximum = 0; | |
| alignment = 0.5f; | |
| } | |
| /** | |
| * Creates a SizeRequirements object with the specified minimum, preferred, | |
| * and maximum sizes and the specified alignment. | |
| * | |
| * @param min the minimum size >= 0 | |
| * @param pref the preferred size >= 0 | |
| * @param max the maximum size >= 0 | |
| * @param a the alignment >= 0.0f && <= 1.0f | |
| */ | |
| public SizeRequirements(int min, int pref, int max, float a) { | |
| minimum = min; | |
| preferred = pref; | |
| maximum = max; | |
| alignment = a > 1.0f ? 1.0f : a < 0.0f ? 0.0f : a; | |
| } | |
| /** | |
| * Returns a string describing the minimum, preferred, and maximum | |
| * size requirements, along with the alignment. | |
| * | |
| * @return the string | |
| */ | |
| public String toString() { | |
| return "[" + minimum + "," + preferred + "," + maximum + "]@" + alignment; | |
| } | |
| /** | |
| * Determines the total space necessary to | |
| * place a set of components end-to-end. The needs | |
| * of each component in the set are represented by an entry in the | |
| * passed-in SizeRequirements array. | |
| * The returned SizeRequirements object has an alignment of 0.5 | |
| * (centered). The space requirement is never more than | |
| * Integer.MAX_VALUE. | |
| * | |
| * @param children the space requirements for a set of components. | |
| * The vector may be of zero length, which will result in a | |
| * default SizeRequirements object instance being passed back. | |
| * @return the total space requirements. | |
| */ | |
| public static SizeRequirements getTiledSizeRequirements(SizeRequirements[] | |
| children) { | |
| SizeRequirements total = new SizeRequirements(); | |
| for (int i = 0; i < children.length; i++) { | |
| SizeRequirements req = children[i]; | |
| total.minimum = (int) Math.min((long) total.minimum + (long) req.minimum, Integer.MAX_VALUE); | |
| total.preferred = (int) Math.min((long) total.preferred + (long) req.preferred, Integer.MAX_VALUE); | |
| total.maximum = (int) Math.min((long) total.maximum + (long) req.maximum, Integer.MAX_VALUE); | |
| } | |
| return total; | |
| } | |
| /** | |
| * Determines the total space necessary to | |
| * align a set of components. The needs | |
| * of each component in the set are represented by an entry in the | |
| * passed-in SizeRequirements array. The total space required will | |
| * never be more than Integer.MAX_VALUE. | |
| * | |
| * @param children the set of child requirements. If of zero length, | |
| * the returns result will be a default instance of SizeRequirements. | |
| * @return the total space requirements. | |
| */ | |
| public static SizeRequirements getAlignedSizeRequirements(SizeRequirements[] | |
| children) { | |
| SizeRequirements totalAscent = new SizeRequirements(); | |
| SizeRequirements totalDescent = new SizeRequirements(); | |
| for (int i = 0; i < children.length; i++) { | |
| SizeRequirements req = children[i]; | |
| int ascent = (int) (req.alignment * req.minimum); | |
| int descent = req.minimum - ascent; | |
| totalAscent.minimum = Math.max(ascent, totalAscent.minimum); | |
| totalDescent.minimum = Math.max(descent, totalDescent.minimum); | |
| ascent = (int) (req.alignment * req.preferred); | |
| descent = req.preferred - ascent; | |
| totalAscent.preferred = Math.max(ascent, totalAscent.preferred); | |
| totalDescent.preferred = Math.max(descent, totalDescent.preferred); | |
| ascent = (int) (req.alignment * req.maximum); | |
| descent = req.maximum - ascent; | |
| totalAscent.maximum = Math.max(ascent, totalAscent.maximum); | |
| totalDescent.maximum = Math.max(descent, totalDescent.maximum); | |
| } | |
| int min = (int) Math.min((long) totalAscent.minimum + (long) totalDescent.minimum, Integer.MAX_VALUE); | |
| int pref = (int) Math.min((long) totalAscent.preferred + (long) totalDescent.preferred, Integer.MAX_VALUE); | |
| int max = (int) Math.min((long) totalAscent.maximum + (long) totalDescent.maximum, Integer.MAX_VALUE); | |
| float alignment = 0.0f; | |
| if (min > 0) { | |
| alignment = (float) totalAscent.minimum / min; | |
| alignment = alignment > 1.0f ? 1.0f : alignment < 0.0f ? 0.0f : alignment; | |
| } | |
| return new SizeRequirements(min, pref, max, alignment); | |
| } | |
| /** | |
| * Creates a set of offset/span pairs representing how to | |
| * lay out a set of components end-to-end. | |
| * This method requires that you specify | |
| * the total amount of space to be allocated, | |
| * the size requirements for each component to be placed | |
| * (specified as an array of SizeRequirements), and | |
| * the total size requirement of the set of components. | |
| * You can get the total size requirement | |
| * by invoking the getTiledSizeRequirements method. The components | |
| * will be tiled in the forward direction with offsets increasing from 0. | |
| * | |
| * @param allocated the total span to be allocated >= 0. | |
| * @param total the total of the children requests. This argument | |
| * is optional and may be null. | |
| * @param children the size requirements for each component. | |
| * @param offsets the offset from 0 for each child where | |
| * the spans were allocated (determines placement of the span). | |
| * @param spans the span allocated for each child to make the | |
| * total target span. | |
| */ | |
| public static void calculateTiledPositions(int allocated, | |
| SizeRequirements total, | |
| SizeRequirements[] children, | |
| int[] offsets, | |
| int[] spans) { | |
| calculateTiledPositions(allocated, total, children, offsets, spans, true); | |
| } | |
| /** | |
| * Creates a set of offset/span pairs representing how to | |
| * lay out a set of components end-to-end. | |
| * This method requires that you specify | |
| * the total amount of space to be allocated, | |
| * the size requirements for each component to be placed | |
| * (specified as an array of SizeRequirements), and | |
| * the total size requirement of the set of components. | |
| * You can get the total size requirement | |
| * by invoking the getTiledSizeRequirements method. | |
| * | |
| * This method also requires a flag indicating whether components | |
| * should be tiled in the forward direction (offsets increasing | |
| * from 0) or reverse direction (offsets decreasing from the end | |
| * of the allocated space). The forward direction represents | |
| * components tiled from left to right or top to bottom. The | |
| * reverse direction represents components tiled from right to left | |
| * or bottom to top. | |
| * | |
| * @param allocated the total span to be allocated >= 0. | |
| * @param total the total of the children requests. This argument | |
| * is optional and may be null. | |
| * @param children the size requirements for each component. | |
| * @param offsets the offset from 0 for each child where | |
| * the spans were allocated (determines placement of the span). | |
| * @param spans the span allocated for each child to make the | |
| * total target span. | |
| * @param forward tile with offsets increasing from 0 if true | |
| * and with offsets decreasing from the end of the allocated space | |
| * if false. | |
| * @since 1.4 | |
| */ | |
| public static void calculateTiledPositions(int allocated, | |
| SizeRequirements total, | |
| SizeRequirements[] children, | |
| int[] offsets, | |
| int[] spans, | |
| boolean forward) { | |
| // The total argument turns out to be a bad idea since the | |
| // total of all the children can overflow the integer used to | |
| // hold the total. The total must therefore be calculated and | |
| // stored in long variables. | |
| long min = 0; | |
| long pref = 0; | |
| long max = 0; | |
| for (int i = 0; i < children.length; i++) { | |
| min += children[i].minimum; | |
| pref += children[i].preferred; | |
| max += children[i].maximum; | |
| } | |
| if (allocated >= pref) { | |
| expandedTile(allocated, min, pref, max, children, offsets, spans, forward); | |
| } else { | |
| compressedTile(allocated, min, pref, max, children, offsets, spans, forward); | |
| } | |
| } | |
| private static void compressedTile(int allocated, long min, long pref, long max, | |
| SizeRequirements[] request, | |
| int[] offsets, int[] spans, | |
| boolean forward) { | |
| // ---- determine what we have to work with ---- | |
| float totalPlay = Math.min(pref - allocated, pref - min); | |
| float factor = (pref - min == 0) ? 0.0f : totalPlay / (pref - min); | |
| // ---- make the adjustments ---- | |
| int totalOffset; | |
| if( forward ) { | |
| // lay out with offsets increasing from 0 | |
| totalOffset = 0; | |
| for (int i = 0; i < spans.length; i++) { | |
| offsets[i] = totalOffset; | |
| SizeRequirements req = request[i]; | |
| float play = factor * (req.preferred - req.minimum); | |
| spans[i] = (int)(req.preferred - play); | |
| totalOffset = (int) Math.min((long) totalOffset + (long) spans[i], Integer.MAX_VALUE); | |
| } | |
| } else { | |
| // lay out with offsets decreasing from the end of the allocation | |
| totalOffset = allocated; | |
| for (int i = 0; i < spans.length; i++) { | |
| SizeRequirements req = request[i]; | |
| float play = factor * (req.preferred - req.minimum); | |
| spans[i] = (int)(req.preferred - play); | |
| offsets[i] = totalOffset - spans[i]; | |
| totalOffset = (int) Math.max((long) totalOffset - (long) spans[i], 0); | |
| } | |
| } | |
| } | |
| private static void expandedTile(int allocated, long min, long pref, long max, | |
| SizeRequirements[] request, | |
| int[] offsets, int[] spans, | |
| boolean forward) { | |
| // ---- determine what we have to work with ---- | |
| float totalPlay = Math.min(allocated - pref, max - pref); | |
| float factor = (max - pref == 0) ? 0.0f : totalPlay / (max - pref); | |
| // ---- make the adjustments ---- | |
| int totalOffset; | |
| if( forward ) { | |
| // lay out with offsets increasing from 0 | |
| totalOffset = 0; | |
| for (int i = 0; i < spans.length; i++) { | |
| offsets[i] = totalOffset; | |
| SizeRequirements req = request[i]; | |
| int play = (int)(factor * (req.maximum - req.preferred)); | |
| spans[i] = (int) Math.min((long) req.preferred + (long) play, Integer.MAX_VALUE); | |
| totalOffset = (int) Math.min((long) totalOffset + (long) spans[i], Integer.MAX_VALUE); | |
| } | |
| } else { | |
| // lay out with offsets decreasing from the end of the allocation | |
| totalOffset = allocated; | |
| for (int i = 0; i < spans.length; i++) { | |
| SizeRequirements req = request[i]; | |
| int play = (int)(factor * (req.maximum - req.preferred)); | |
| spans[i] = (int) Math.min((long) req.preferred + (long) play, Integer.MAX_VALUE); | |
| offsets[i] = totalOffset - spans[i]; | |
| totalOffset = (int) Math.max((long) totalOffset - (long) spans[i], 0); | |
| } | |
| } | |
| } | |
| /** | |
| * Creates a bunch of offset/span pairs specifying how to | |
| * lay out a set of components with the specified alignments. | |
| * The resulting span allocations will overlap, with each one | |
| * fitting as well as possible into the given total allocation. | |
| * This method requires that you specify | |
| * the total amount of space to be allocated, | |
| * the size requirements for each component to be placed | |
| * (specified as an array of SizeRequirements), and | |
| * the total size requirements of the set of components | |
| * (only the alignment field of which is actually used). | |
| * You can get the total size requirement by invoking | |
| * getAlignedSizeRequirements. | |
| * | |
| * Normal alignment will be done with an alignment value of 0.0f | |
| * representing the left/top edge of a component. | |
| * | |
| * @param allocated the total span to be allocated >= 0. | |
| * @param total the total of the children requests. | |
| * @param children the size requirements for each component. | |
| * @param offsets the offset from 0 for each child where | |
| * the spans were allocated (determines placement of the span). | |
| * @param spans the span allocated for each child to make the | |
| * total target span. | |
| */ | |
| public static void calculateAlignedPositions(int allocated, | |
| SizeRequirements total, | |
| SizeRequirements[] children, | |
| int[] offsets, | |
| int[] spans) { | |
| calculateAlignedPositions( allocated, total, children, offsets, spans, true ); | |
| } | |
| /** | |
| * Creates a set of offset/span pairs specifying how to | |
| * lay out a set of components with the specified alignments. | |
| * The resulting span allocations will overlap, with each one | |
| * fitting as well as possible into the given total allocation. | |
| * This method requires that you specify | |
| * the total amount of space to be allocated, | |
| * the size requirements for each component to be placed | |
| * (specified as an array of SizeRequirements), and | |
| * the total size requirements of the set of components | |
| * (only the alignment field of which is actually used) | |
| * You can get the total size requirement by invoking | |
| * getAlignedSizeRequirements. | |
| * | |
| * This method also requires a flag indicating whether normal or | |
| * reverse alignment should be performed. With normal alignment | |
| * the value 0.0f represents the left/top edge of the component | |
| * to be aligned. With reverse alignment, 0.0f represents the | |
| * right/bottom edge. | |
| * | |
| * @param allocated the total span to be allocated >= 0. | |
| * @param total the total of the children requests. | |
| * @param children the size requirements for each component. | |
| * @param offsets the offset from 0 for each child where | |
| * the spans were allocated (determines placement of the span). | |
| * @param spans the span allocated for each child to make the | |
| * total target span. | |
| * @param normal when true, the alignment value 0.0f means | |
| * left/top; when false, it means right/bottom. | |
| * @since 1.4 | |
| */ | |
| public static void calculateAlignedPositions(int allocated, | |
| SizeRequirements total, | |
| SizeRequirements[] children, | |
| int[] offsets, | |
| int[] spans, | |
| boolean normal) { | |
| float totalAlignment = normal ? total.alignment : 1.0f - total.alignment; | |
| int totalAscent = (int)(allocated * totalAlignment); | |
| int totalDescent = allocated - totalAscent; | |
| for (int i = 0; i < children.length; i++) { | |
| SizeRequirements req = children[i]; | |
| float alignment = normal ? req.alignment : 1.0f - req.alignment; | |
| int maxAscent = (int)(req.maximum * alignment); | |
| int maxDescent = req.maximum - maxAscent; | |
| int ascent = Math.min(totalAscent, maxAscent); | |
| int descent = Math.min(totalDescent, maxDescent); | |
| offsets[i] = totalAscent - ascent; | |
| spans[i] = (int) Math.min((long) ascent + (long) descent, Integer.MAX_VALUE); | |
| } | |
| } | |
| // This method was used by the JTable - which now uses a different technique. | |
| /** | |
| * Adjust a specified array of sizes by a given amount. | |
| * | |
| * @param delta an int specifying the size difference | |
| * @param children an array of SizeRequirements objects | |
| * @return an array of ints containing the final size for each item | |
| */ | |
| public static int[] adjustSizes(int delta, SizeRequirements[] children) { | |
| return new int[0]; | |
| } | |
| } |