/* * Copyright (c) 1997, 2006, 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<sup><font size="-2">TM</font></sup> * 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 */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]; }}
/*
* Copyright (c) 1997, 2006, 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<sup><font size="-2">TM</font></sup>
* 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
*/
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];
}
}