289 lines
10 KiB
Java
289 lines
10 KiB
Java
/*
|
|
* Copyright 1997-2007 Sun Microsystems, Inc. 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. Sun designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
* CA 95054 USA or visit www.sun.com if you need additional information or
|
|
* have any questions.
|
|
*/
|
|
package javax.swing;
|
|
|
|
|
|
import java.awt.*;
|
|
import java.beans.ConstructorProperties;
|
|
import java.io.Serializable;
|
|
|
|
/**
|
|
* A layout manager to arrange components over the top
|
|
* of each other. The requested size of the container
|
|
* will be the largest requested size of the children,
|
|
* taking alignment needs into consideration.
|
|
*
|
|
* The alignment is based upon what is needed to properly
|
|
* fit the children in the allocation area. The children
|
|
* will be placed such that their alignment points are all
|
|
* on top of each other.
|
|
* <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}.
|
|
*
|
|
* @author Timothy Prinzing
|
|
*/
|
|
public class OverlayLayout implements LayoutManager2,Serializable {
|
|
|
|
/**
|
|
* Constructs a layout manager that performs overlay
|
|
* arrangement of the children. The layout manager
|
|
* created is dedicated to the given container.
|
|
*
|
|
* @param target the container to do layout against
|
|
*/
|
|
@ConstructorProperties({"target"})
|
|
public OverlayLayout(Container target) {
|
|
this.target = target;
|
|
}
|
|
|
|
/**
|
|
* Returns the container that uses this layout manager.
|
|
*
|
|
* @return the container that uses this layout manager
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public final Container getTarget() {
|
|
return this.target;
|
|
}
|
|
|
|
/**
|
|
* Indicates a child has changed its layout related information,
|
|
* which causes any cached calculations to be flushed.
|
|
*
|
|
* @param target the container
|
|
*/
|
|
public void invalidateLayout(Container target) {
|
|
checkContainer(target);
|
|
xChildren = null;
|
|
yChildren = null;
|
|
xTotal = null;
|
|
yTotal = null;
|
|
}
|
|
|
|
/**
|
|
* Adds the specified component to the layout. Used by
|
|
* this class to know when to invalidate layout.
|
|
*
|
|
* @param name the name of the component
|
|
* @param comp the the component to be added
|
|
*/
|
|
public void addLayoutComponent(String name, Component comp) {
|
|
invalidateLayout(comp.getParent());
|
|
}
|
|
|
|
/**
|
|
* Removes the specified component from the layout. Used by
|
|
* this class to know when to invalidate layout.
|
|
*
|
|
* @param comp the component to remove
|
|
*/
|
|
public void removeLayoutComponent(Component comp) {
|
|
invalidateLayout(comp.getParent());
|
|
}
|
|
|
|
/**
|
|
* Adds the specified component to the layout, using the specified
|
|
* constraint object. Used by this class to know when to invalidate
|
|
* layout.
|
|
*
|
|
* @param comp the component to be added
|
|
* @param constraints where/how the component is added to the layout.
|
|
*/
|
|
public void addLayoutComponent(Component comp, Object constraints) {
|
|
invalidateLayout(comp.getParent());
|
|
}
|
|
|
|
/**
|
|
* Returns the preferred dimensions for this layout given the components
|
|
* in the specified target container. Recomputes the layout if it
|
|
* has been invalidated. Factors in the current inset setting returned
|
|
* by getInsets().
|
|
*
|
|
* @param target the component which needs to be laid out
|
|
* @return a Dimension object containing the preferred dimensions
|
|
* @see #minimumLayoutSize
|
|
*/
|
|
public Dimension preferredLayoutSize(Container target) {
|
|
checkContainer(target);
|
|
checkRequests();
|
|
|
|
Dimension size = new Dimension(xTotal.preferred, yTotal.preferred);
|
|
Insets insets = target.getInsets();
|
|
size.width += insets.left + insets.right;
|
|
size.height += insets.top + insets.bottom;
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Returns the minimum dimensions needed to lay out the components
|
|
* contained in the specified target container. Recomputes the layout
|
|
* if it has been invalidated, and factors in the current inset setting.
|
|
*
|
|
* @param target the component which needs to be laid out
|
|
* @return a Dimension object containing the minimum dimensions
|
|
* @see #preferredLayoutSize
|
|
*/
|
|
public Dimension minimumLayoutSize(Container target) {
|
|
checkContainer(target);
|
|
checkRequests();
|
|
|
|
Dimension size = new Dimension(xTotal.minimum, yTotal.minimum);
|
|
Insets insets = target.getInsets();
|
|
size.width += insets.left + insets.right;
|
|
size.height += insets.top + insets.bottom;
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Returns the maximum dimensions needed to lay out the components
|
|
* contained in the specified target container. Recomputes the
|
|
* layout if it has been invalidated, and factors in the inset setting
|
|
* returned by <code>getInset</code>.
|
|
*
|
|
* @param target the component that needs to be laid out
|
|
* @return a <code>Dimension</code> object containing the maximum
|
|
* dimensions
|
|
* @see #preferredLayoutSize
|
|
*/
|
|
public Dimension maximumLayoutSize(Container target) {
|
|
checkContainer(target);
|
|
checkRequests();
|
|
|
|
Dimension size = new Dimension(xTotal.maximum, yTotal.maximum);
|
|
Insets insets = target.getInsets();
|
|
size.width += insets.left + insets.right;
|
|
size.height += insets.top + insets.bottom;
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Returns the alignment along the x axis for the container.
|
|
*
|
|
* @param target the container
|
|
* @return the alignment >= 0.0f && <= 1.0f
|
|
*/
|
|
public float getLayoutAlignmentX(Container target) {
|
|
checkContainer(target);
|
|
checkRequests();
|
|
return xTotal.alignment;
|
|
}
|
|
|
|
/**
|
|
* Returns the alignment along the y axis for the container.
|
|
*
|
|
* @param target the container
|
|
* @return the alignment >= 0.0f && <= 1.0f
|
|
*/
|
|
public float getLayoutAlignmentY(Container target) {
|
|
checkContainer(target);
|
|
checkRequests();
|
|
return yTotal.alignment;
|
|
}
|
|
|
|
/**
|
|
* Called by the AWT when the specified container needs to be laid out.
|
|
*
|
|
* @param target the container to lay out
|
|
*
|
|
* @exception AWTError if the target isn't the container specified to the
|
|
* constructor
|
|
*/
|
|
public void layoutContainer(Container target) {
|
|
checkContainer(target);
|
|
checkRequests();
|
|
|
|
int nChildren = target.getComponentCount();
|
|
int[] xOffsets = new int[nChildren];
|
|
int[] xSpans = new int[nChildren];
|
|
int[] yOffsets = new int[nChildren];
|
|
int[] ySpans = new int[nChildren];
|
|
|
|
// determine the child placements
|
|
Dimension alloc = target.getSize();
|
|
Insets in = target.getInsets();
|
|
alloc.width -= in.left + in.right;
|
|
alloc.height -= in.top + in.bottom;
|
|
SizeRequirements.calculateAlignedPositions(alloc.width, xTotal,
|
|
xChildren, xOffsets,
|
|
xSpans);
|
|
SizeRequirements.calculateAlignedPositions(alloc.height, yTotal,
|
|
yChildren, yOffsets,
|
|
ySpans);
|
|
|
|
// flush changes to the container
|
|
for (int i = 0; i < nChildren; i++) {
|
|
Component c = target.getComponent(i);
|
|
c.setBounds(in.left + xOffsets[i], in.top + yOffsets[i],
|
|
xSpans[i], ySpans[i]);
|
|
}
|
|
}
|
|
|
|
void checkContainer(Container target) {
|
|
if (this.target != target) {
|
|
throw new AWTError("OverlayLayout can't be shared");
|
|
}
|
|
}
|
|
|
|
void checkRequests() {
|
|
if (xChildren == null || yChildren == null) {
|
|
// The requests have been invalidated... recalculate
|
|
// the request information.
|
|
int n = target.getComponentCount();
|
|
xChildren = new SizeRequirements[n];
|
|
yChildren = new SizeRequirements[n];
|
|
for (int i = 0; i < n; i++) {
|
|
Component c = target.getComponent(i);
|
|
Dimension min = c.getMinimumSize();
|
|
Dimension typ = c.getPreferredSize();
|
|
Dimension max = c.getMaximumSize();
|
|
xChildren[i] = new SizeRequirements(min.width, typ.width,
|
|
max.width,
|
|
c.getAlignmentX());
|
|
yChildren[i] = new SizeRequirements(min.height, typ.height,
|
|
max.height,
|
|
c.getAlignmentY());
|
|
}
|
|
|
|
xTotal = SizeRequirements.getAlignedSizeRequirements(xChildren);
|
|
yTotal = SizeRequirements.getAlignedSizeRequirements(yChildren);
|
|
}
|
|
}
|
|
|
|
private Container target;
|
|
private SizeRequirements[] xChildren;
|
|
private SizeRequirements[] yChildren;
|
|
private SizeRequirements xTotal;
|
|
private SizeRequirements yTotal;
|
|
|
|
}
|