1. /*

  2.  * @(#)OverlayLayout.java	1.25 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package javax.swing;

  8. 

  9. 

  10. import java.awt.*;

  11. import java.io.Serializable;

  12. 

  13. /**

  14.  * A layout manager to arrange components over the top

  15.  * of each other.  The requested size of the container

  16.  * will be the largest requested size of the children, 

  17.  * taking alignment needs into consideration.  

  18.  *

  19.  * The alignment is based upon what is needed to properly

  20.  * fit the children in the allocation area.  The children

  21.  * will be placed such that their alignment points are all

  22.  * on top of each other.

  23.  * <p>

  24.  * <strong>Warning:</strong>

  25.  * Serialized objects of this class will not be compatible with

  26.  * future Swing releases. The current serialization support is

  27.  * appropriate for short term storage or RMI between applications running

  28.  * the same version of Swing.  As of 1.4, support for long term storage

  29.  * of all JavaBeans<sup><font size="-2">TM</font></sup>

  30.  * has been added to the <code>java.beans</code> package.

  31.  * Please see {@link java.beans.XMLEncoder}.

  32.  *

  33.  * @version 1.25 01/23/03

  34.  * @author   Timothy Prinzing

  35.  */

  36. public class OverlayLayout implements LayoutManager2,Serializable {

  37. 

  38.     /**

  39.      * Constructs a layout manager that performs overlay

  40.      * arrangement of the children.  The layout manager

  41.      * created is dedicated to the given container.

  42.      *

  43.      * @param target  the container to do layout against

  44.      */

  45.     public OverlayLayout(Container target) {

  46. 	this.target = target;

  47.     }

  48. 

  49.     /**

  50.      * Indicates a child has changed its layout related information,

  51.      * which causes any cached calculations to be flushed.

  52.      *

  53.      * @param target the container

  54.      */

  55.     public void invalidateLayout(Container target) {

  56. 	checkContainer(target);

  57. 	xChildren = null;

  58. 	yChildren = null;

  59. 	xTotal = null;

  60. 	yTotal = null;

  61.     }

  62. 

  63.     /**

  64.      * Adds the specified component to the layout. Used by

  65.      * this class to know when to invalidate layout.

  66.      *

  67.      * @param name the name of the component

  68.      * @param comp the the component to be added

  69.      */

  70.     public void addLayoutComponent(String name, Component comp) {

  71.         invalidateLayout(comp.getParent());

  72.     }

  73. 

  74.     /**

  75.      * Removes the specified component from the layout. Used by

  76.      * this class to know when to invalidate layout.

  77.      *

  78.      * @param comp the component to remove

  79.      */

  80.     public void removeLayoutComponent(Component comp) {

  81.         invalidateLayout(comp.getParent());

  82.     }

  83. 

  84.     /**

  85.      * Adds the specified component to the layout, using the specified

  86.      * constraint object. Used by this class to know when to invalidate

  87.      * layout.

  88.      *

  89.      * @param comp the component to be added

  90.      * @param constraints  where/how the component is added to the layout.

  91.      */

  92.     public void addLayoutComponent(Component comp, Object constraints) {

  93.         invalidateLayout(comp.getParent());

  94.     }

  95. 

  96.     /**

  97.      * Returns the preferred dimensions for this layout given the components

  98.      * in the specified target container.  Recomputes the layout if it

  99.      * has been invalidated.  Factors in the current inset setting returned

  100.      * by getInsets().

  101.      *

  102.      * @param target the component which needs to be laid out

  103.      * @return a Dimension object containing the preferred dimensions

  104.      * @see #minimumLayoutSize

  105.      */

  106.     public Dimension preferredLayoutSize(Container target) {

  107. 	checkContainer(target);

  108. 	checkRequests();

  109. 

  110. 	Dimension size = new Dimension(xTotal.preferred, yTotal.preferred);

  111. 	Insets insets = target.getInsets();

  112. 	size.width += insets.left + insets.right;

  113. 	size.height += insets.top + insets.bottom;

  114. 	return size;

  115.     }

  116. 

  117.     /**

  118.      * Returns the minimum dimensions needed to lay out the components

  119.      * contained in the specified target container.  Recomputes the layout

  120.      * if it has been invalidated, and factors in the current inset setting.

  121.      *

  122.      * @param target the component which needs to be laid out 

  123.      * @return a Dimension object containing the minimum dimensions

  124.      * @see #preferredLayoutSize

  125.      */

  126.     public Dimension minimumLayoutSize(Container target) {

  127. 	checkContainer(target);

  128. 	checkRequests();

  129. 

  130. 	Dimension size = new Dimension(xTotal.minimum, yTotal.minimum);

  131. 	Insets insets = target.getInsets();

  132. 	size.width += insets.left + insets.right;

  133. 	size.height += insets.top + insets.bottom;

  134. 	return size;

  135.     }

  136. 

  137.     /**

  138.      * Returns the minimum dimensions needed to lay out the components

  139.      * contained in the specified target container.  Recomputes the

  140.      * layout if it has been invalidated, and factors in the inset setting

  141.      * returned by getInset().

  142.      *

  143.      * @param target the component which needs to be laid out 

  144.      * @return a Dimension object containing the maximum dimensions

  145.      * @see #preferredLayoutSize

  146.      */

  147.     public Dimension maximumLayoutSize(Container target) {

  148. 	checkContainer(target);

  149. 	checkRequests();

  150. 

  151. 	Dimension size = new Dimension(xTotal.maximum, yTotal.maximum);

  152. 	Insets insets = target.getInsets();

  153. 	size.width += insets.left + insets.right;

  154. 	size.height += insets.top + insets.bottom;

  155. 	return size;

  156.     }

  157. 

  158.     /**

  159.      * Returns the alignment along the x axis for the container.

  160.      *

  161.      * @param target the container

  162.      * @return the alignment >= 0.0f && <= 1.0f

  163.      */

  164.     public float getLayoutAlignmentX(Container target) {

  165. 	checkContainer(target);

  166. 	checkRequests();

  167. 	return xTotal.alignment;

  168.     }

  169. 

  170.     /**

  171.      * Returns the alignment along the y axis for the container.

  172.      *

  173.      * @param target the container

  174.      * @return the alignment >= 0.0f && <= 1.0f

  175.      */

  176.     public float getLayoutAlignmentY(Container target) {

  177. 	checkContainer(target);

  178. 	checkRequests();

  179. 	return yTotal.alignment;

  180.     }

  181. 

  182.     /**

  183.      * Called by the AWT when the specified container needs to be laid out.

  184.      *

  185.      * @param target  the container to lay out

  186.      *

  187.      * @exception AWTError  if the target isn't the container specified to the

  188.      *                      constructor

  189.      */

  190.     public void layoutContainer(Container target) {

  191. 	checkContainer(target);

  192. 	checkRequests();

  193. 	

  194. 	int nChildren = target.getComponentCount();

  195. 	int[] xOffsets = new int[nChildren];

  196. 	int[] xSpans = new int[nChildren];

  197. 	int[] yOffsets = new int[nChildren];

  198. 	int[] ySpans = new int[nChildren];

  199. 

  200. 	// determine the child placements

  201. 	Dimension alloc = target.getSize();

  202. 	Insets in = target.getInsets();

  203. 	alloc.width -= in.left + in.right;

  204. 	alloc.height -= in.top + in.bottom;

  205. 	SizeRequirements.calculateAlignedPositions(alloc.width, xTotal, 

  206. 						   xChildren, xOffsets,

  207. 						   xSpans);

  208. 	SizeRequirements.calculateAlignedPositions(alloc.height, yTotal,

  209. 						   yChildren, yOffsets,

  210. 						   ySpans);

  211. 

  212. 	// flush changes to the container

  213. 	for (int i = 0; i < nChildren; i++) {

  214. 	    Component c = target.getComponent(i);

  215. 	    c.setBounds(in.left + xOffsets[i], in.top + yOffsets[i],

  216. 			xSpans[i], ySpans[i]);

  217. 	}

  218.     }

  219. 

  220.     void checkContainer(Container target) {

  221. 	if (this.target != target) {

  222. 	    throw new AWTError("OverlayLayout can't be shared");

  223. 	}

  224.     }

  225.     

  226.     void checkRequests() {

  227. 	if (xChildren == null || yChildren == null) {

  228. 	    // The requests have been invalidated... recalculate

  229. 	    // the request information.

  230. 	    int n = target.getComponentCount();

  231. 	    xChildren = new SizeRequirements[n];

  232. 	    yChildren = new SizeRequirements[n];

  233. 	    for (int i = 0; i < n; i++) {

  234. 		Component c = target.getComponent(i);

  235. 		Dimension min = c.getMinimumSize();

  236. 		Dimension typ = c.getPreferredSize();

  237. 		Dimension max = c.getMaximumSize();

  238. 		xChildren[i] = new SizeRequirements(min.width, typ.width, 

  239. 						    max.width, 

  240. 						    c.getAlignmentX());

  241. 		yChildren[i] = new SizeRequirements(min.height, typ.height, 

  242. 						    max.height, 

  243. 						    c.getAlignmentY());

  244. 	    }

  245. 	    

  246. 	    xTotal = SizeRequirements.getAlignedSizeRequirements(xChildren);

  247. 	    yTotal = SizeRequirements.getAlignedSizeRequirements(yChildren);

  248. 	}

  249.     }

  250. 	    

  251.     private Container target;

  252.     private SizeRequirements[] xChildren;

  253.     private SizeRequirements[] yChildren;

  254.     private SizeRequirements xTotal;

  255.     private SizeRequirements yTotal;

  256.     

  257. }

  258.