Container semantics.
* Each child component of a Layered Pane is placed within one
* of several layers. JLayeredPane defines a set of standard
* layers. The pre-defined sets are (in the order from button to top):
*
* A child is in exactly one of these layers at any time, though there may * be other layers if someone creates them.
* *You can add a component to a specific layer using the
* {@link Container#add(Component, Object)} method. I.e.
* layeredPane.add(comp, JLayeredPane.MODAL_LAYER) will add the
* component comp to the modal layer of layeredPane.
*
To change the layer of a component that is already a child of
* a JLayeredPane, use the {@link #setLayer(Component, int)}
* method.
The purpose of this class is to translate this view of "layers" into a * contiguous array of components: the one held in our ancestor, * {@link java.awt.Container}.
* *There is a precise set of words we will use to refer to numbers within * this class:
* *component array held in our ancestor,
* {@link java.awt.Container}, from [0 .. component.length). The drawing
* rule with indices is that 0 is drawn last.int specifying a layer within this component. Negative
* numbers are drawn first, then layer 0, then positive numbered layers, in
* ascending order.Note: the layer numbering order is the reverse of the * component indexing and position order
* * @author Graydon Hoare (graydon@redhat.com) * @author Roman Kennke (kennke@aicas.com) */ public class JLayeredPane extends JComponent implements Accessible { /** * Provides accessibility support forJLayeredPane.
*/
protected class AccessibleJLayeredPane extends AccessibleJComponent
{
/**
* Creates a new instance of AccessibleJLayeredPane.
*/
protected AccessibleJLayeredPane()
{
// Nothing to do here.
}
/**
* Returns the accessble role of JLayeredPane,
* {@link AccessibleRole#LAYERED_PANE}.
*/
public AccessibleRole getAccessibleRole()
{
return AccessibleRole.LAYERED_PANE;
}
}
private static final long serialVersionUID = 5534920399324590459L;
public static final String LAYER_PROPERTY = "layeredContainerLayer";
public static final Integer FRAME_CONTENT_LAYER = new Integer(-30000);
public static final Integer DEFAULT_LAYER = new Integer(0);
public static final Integer PALETTE_LAYER = new Integer(100);
public static final Integer MODAL_LAYER = new Integer(200);
public static final Integer POPUP_LAYER = new Integer(300);
public static final Integer DRAG_LAYER = new Integer(400);
private Hashtable componentToLayer; // Component -> Layer Number (Integer)
public JLayeredPane()
{
componentToLayer = new Hashtable();
setLayout(null);
}
/**
* Looks up the layer a child component is currently assigned to.
*
* If c is an instance of {@link JComponent}, then the layer
* is fetched from the client property with the key {@link #LAYER_PROPERTY}.
* Otherwise it is looked up in an internal hashtable that maps
* non-JComponent components to layers. If the components cannot be found
* in either way, the {@link #DEFAULT_LAYER} is returned.
*
* @param c the component to look up.
*
* @return the layer the component is currently assigned to; if the component
* is not in this layered pane, then 0 (DEFAULT_LAYER) is returned
*/
public int getLayer(Component c)
{
Integer layerObj;
if (c instanceof JComponent)
{
JComponent jc = (JComponent) c;
layerObj = (Integer) jc.getClientProperty(LAYER_PROPERTY);
}
else
layerObj = (Integer) componentToLayer.get(c);
if (layerObj == null)
layerObj = DEFAULT_LAYER;
return layerObj.intValue();
}
/**
* Looks up the layer in the client property with the key
* {@link #LAYER_PROPERTY} of comp. If no such property can be
* found, we return 0 ({@link #DEFAULT_LAYER}).
*
* @param comp the component for which the layer is looked up
*
* @return the layer of comp as stored in the corresponding
* client property, or 0 if there is no such property
*/
public static int getLayer(JComponent comp)
{
Integer layerObj = (Integer) comp.getClientProperty(LAYER_PROPERTY);
if (layerObj == null)
layerObj = DEFAULT_LAYER;
return layerObj.intValue();
}
/**
* Returns the first JLayeredPane that contains the Component
* comp or null if comp is
* not contained in a JLayeredPane.
*
* @param comp the component for which we are searching the JLayeredPane
* ancestor
*
* @return the first JLayeredPane that contains the Component
* comp or null if comp is
* not contained in a JLayeredPane
*/
public static JLayeredPane getLayeredPaneAbove(Component comp)
{
JLayeredPane lp = (JLayeredPane) SwingUtilities.getAncestorOfClass
(JLayeredPane.class, comp);
return lp;
}
/**
* Return the greatest layer number currently in use, in this container.
* This number may legally be positive or negative.
*
* @return the highest layer number
*
* @see #lowestLayer()
*/
public int highestLayer()
{
Component[] components = getComponents();
int highest;
if (components.length == 0)
highest = 0;
else
{
highest = Integer.MIN_VALUE;
for (int i = 0; i < components.length; i++)
highest = Math.max(highest, getLayer(components[i]));
}
return highest;
}
/**
* Return the least layer number currently in use, in this container.
* This number may legally be positive or negative.
*
* @return the least layer number
*
* @see #highestLayer()
*/
public int lowestLayer()
{
Component[] components = getComponents();
int lowest;
if (components.length == 0)
lowest = 0;
else
{
lowest = Integer.MAX_VALUE;
for (int i = 0; i < components.length; i++)
lowest = Math.max(lowest, getLayer(components[i]));
}
return lowest;
}
/**
* Moves a component to the "front" of its layer. The "front" is a
* synonym for position 0, which is also the last position drawn in each
* layer, so is usually the component which occludes the most other
* components in its layer.
*
* @param c the component to move to the front of its layer
*
* @see #moveToBack
*/
public void moveToFront(Component c)
{
setPosition (c, 0);
}
/**
* Moves a component to the "back" of its layer. The "back" is a * synonym for position N-1 (also known as position -1), where N is the * size of the layer.
* *The "back" of a layer is the first position drawn, so the component at * the "back" is usually the component which is occluded by the most * other components in its layer.
* * @param c the component to move to the back of its layer. * * @see #moveToFront */ public void moveToBack(Component c) { setPosition (c, -1); } /** * Return the position of a component within its layer. Positions are assigned * from the "front" (position 0) to the "back" (position N-1), and drawn from * the back towards the front. * * @param c the component to get the position of * * @return the position ofc within its layer or -1 if
* c is not a child of this layered pane
*
* @see #setPosition
*/
public int getPosition(Component c)
{
int pos = -1;
int index = getIndexOf(c);
if (index >= 0)
{
pos = 0;
int layer = getLayer(c);
for (int i = index - 1; i >= 0; --i)
{
if (layer == getLayer(getComponent(i)))
pos++;
else
break;
}
}
return pos;
}
/**
* Change the position of a component within its layer. Positions are assigned
* from the "front" (position 0) to the "back" (position N-1), and drawn from
* the back towards the front.
*
* @param c the component to change the position of
* @param position the position to assign the component to
*
* @see #getPosition
*/
public void setPosition(Component c, int position)
{
setLayer(c, getLayer(c), position);
}
/**
* Return an array of all components within a layer of this
* container. Components are ordered front-to-back, with the "front"
* element (which draws last) at position 0 of the returned array.
*
* @param layer the layer to return components from
*
* @return the components in the layer
*/
public Component[] getComponentsInLayer(int layer)
{
Component[] inLayer = new Component[getComponentCountInLayer(layer)];
Component[] components = getComponents();
int j = 0;
for (int i = 0; i < components.length; ++i)
{
if (layer == getLayer(components[i]))
{
inLayer[j] = components[i];
j++;
}
}
return inLayer;
}
/**
* Return the number of components within a layer of this
* container.
*
* @param layer the layer count components in
*
* @return the number of components in the layer
*/
public int getComponentCountInLayer(int layer)
{
Component[] components = getComponents();
int count = 0;
for (int i = components.length - 1; i >= 0; --i)
{
if (getLayer(components[i]) == layer)
count++;
}
return count;
}
/**
* Return a hashtable mapping child components of this container to
* Integer objects representing the component's layer assignments.
*/
protected Hashtable-1 if
* c is not a child of this layered pane
*/
public int getIndexOf(Component c)
{
return getComponentZOrder(c);
}
/**
* Return an Integer object which holds the same int value as the
* parameter. This is strictly an optimization to minimize the number of
* identical Integer objects which we allocate.
*
* @param layer the layer number as an int.
*
* @return the layer number as an Integer, possibly shared.
*/
protected Integer getObjectForLayer(int layer)
{
switch (layer)
{
case -30000:
return FRAME_CONTENT_LAYER;
case 0:
return DEFAULT_LAYER;
case 100:
return PALETTE_LAYER;
case 200:
return MODAL_LAYER;
case 300:
return POPUP_LAYER;
case 400:
return DRAG_LAYER;
default:
break;
}
return new Integer(layer);
}
/**
* Computes an index at which to request the superclass {@link
* java.awt.Container} inserts a component, given an abstract layer and
* position number.
*
* @param layer the layer in which to insert a component.
* @param position the position in the layer at which to insert a component.
*
* @return the index at which to insert the component.
*/
protected int insertIndexForLayer(int layer, int position)
{
return insertIndexForLayer(null, layer, position);
}
/**
* Similar to {@link #insertIndexForLayer(int, int)}, only that it takes a
* component parameter, which should be ignored in the search. This is
* necessary to support {@link #setLayer(Component, int, int)} which uses
* Container.setComponentZOrder(), which doesn't remove the component.
*
* @param comp the component to ignore
* @param layer the layer
* @param position the position
*
* @return the insertion index
*/
private int insertIndexForLayer(Component comp, int layer, int position)
{
// Create the component list to search through.
ArrayList l = new ArrayList();
int count = getComponentCount();
for (int i = 0; i < count; i++)
{
Component c = getComponent(i);
if (c != comp)
l.add(c);
}
count = l.size();
int layerStart = -1;
int layerEnd = -1;
for (int i = 0; i < count; i++)
{
int layerOfComponent = getLayer((Component) l.get(i));
if (layerStart == -1 && layerOfComponent == layer)
layerStart = i;
if (layerOfComponent < layer)
{
// We are beyond the layer that we are looking for. Update the
// layerStart and layerEnd and exit the loop.
if (i == 0)
{
layerStart = 0;
layerEnd = 0;
}
else
layerEnd = i;
break;
}
}
// No layer found. The requested layer is lower than any existing layer,
// put the component at the end.
int insertIndex;
if (layerStart == -1 && layerEnd == -1)
{
insertIndex = count;
}
else
{
// Corner cases.
if (layerStart != -1 && layerEnd == -1)
layerEnd = count;
if (layerStart == -1 && layerEnd != -1)
layerStart = layerEnd;
// Adding to the bottom of a layer returns the end index
// in the layer.
if (position == -1)
insertIndex = layerEnd;
else
{
// Insert into a layer.
if (position > -1 && layerStart + position <= layerEnd)
insertIndex = layerStart + position;
else
insertIndex = layerEnd;
}
}
return insertIndex;
}
/**
* Removes a child from this container. The child is specified by
* index. After removal, the child no longer occupies a layer.
*
* @param index the index of the child component to remove.
*/
public void remove(int index)
{
Component c = getComponent(index);
if (! (c instanceof JComponent))
componentToLayer.remove(c);
super.remove(index);
}
/**
* Removes all components from this container.
*
* @since 1.5
*/
public void removeAll()
{
componentToLayer.clear();
super.removeAll();
}
/**
* Set the layer property for a component, within this container. The * component will be implicitly mapped to the bottom-most position in the * layer, but only if added after calling this method.
* *Read that carefully: this method should be called before the * component is added to the container.
* * @param c the component to set the layer property for. * @param layer the layer number to assign to the component. */ public void setLayer(Component c, int layer) { setLayer(c, layer, -1); } /** * Set the layer and position of a component, within this container. * * @param c the child component to set the layer property for. * @param layer the layer number to assign to the component. * @param position the position number to assign to the component. */ public void setLayer(Component c, int layer, int position) { Integer layerObj = getObjectForLayer(layer); // Nothing to do if neither the layer nor the position is // changed. if (layer != getLayer(c) || position != getPosition(c)) { // Store the layer either in the JComponent or in the hashtable if (c instanceof JComponent) { JComponent jc = (JComponent) c; jc.putClientProperty(LAYER_PROPERTY, layerObj); } else componentToLayer.put (c, layerObj); // Update the component in the Z order of the Container. Container parent = c.getParent(); if (parent == this) { int index = insertIndexForLayer(c, layer, position); setComponentZOrder(c, index); } } repaint(c.getX(), c.getY(), c.getWidth(), c.getHeight()); } /** * Overrides the default implementation from {@link java.awt.Container} * such thatlayerConstraint is interpreted as an {@link
* Integer}, specifying the layer to which the component will be added
* (at the bottom position).
*
* The argument index specifies the position within the layer
* at which the component should be added, where 0 is the top
* position greater values specify positions below that and -1
* specifies the bottom position.
*
* @param comp the component to add
* @param layerConstraint an integer specifying the layer to add the
* component to
* @param index the position within the layer
*/
protected void addImpl(Component comp, Object layerConstraint, int index)
{
int layer;
if (layerConstraint != null && layerConstraint instanceof Integer)
{
layer = ((Integer) layerConstraint).intValue();
setLayer(comp, layer);
}
else
layer = getLayer(comp);
int newIdx = insertIndexForLayer(layer, index);
super.addImpl(comp, layerConstraint, newIdx);
comp.validate();
comp.repaint();
}
/**
* Sets the layer property for a JComponent.
*
* @param component the component for which to set the layer
* @param layer the layer property to set
*/
public static void putLayer(JComponent component, int layer)
{
component.putClientProperty(LAYER_PROPERTY, new Integer(layer));
}
/**
* Returns the accessible context for this JLayeredPane.
*
* @return the accessible context for this JLayeredPane
*/
public AccessibleContext getAccessibleContext()
{
if (accessibleContext == null)
accessibleContext = new AccessibleJLayeredPane();
return accessibleContext;
}
/**
* This method is overridden order to provide a reasonable painting
* mechanism for JLayeredPane. This is necessary since
* JLayeredPane's do not have an own UI delegate.
*
* Basically this method clears the background for the
* JLayeredPane and then calls super.paint(g).
*
* @param g the graphics context to use
*/
public void paint(Graphics g)
{
if (isOpaque())
{
Color oldColor = g.getColor();
Rectangle clip = g.getClipBounds();
g.setColor(getBackground());
g.fillRect(clip.x, clip.y, clip.width, clip.height);
g.setColor(oldColor);
}
super.paint(g);
}
/**
* Returns false if components in this layered pane can overlap,
* otherwise true.
*
* @return false if components in this layered pane can overlap,
* otherwise true
*/
public boolean isOptimizedDrawingEnabled()
{
int numChildren = getComponentCount();
boolean result = true;
for (int i = 0; i < numChildren; ++i)
{
Component c1 = getComponent(i);
if (! c1.isVisible())
continue;
Rectangle r1 = c1.getBounds();
if (r1.isEmpty())
continue;
for (int j = i + 1; j < numChildren; ++j)
{
Component c2 = getComponent(j);
if (! c2.isVisible())
continue;
Rectangle r2 = c2.getBounds();
if (r2.isEmpty())
continue;
if (r1.intersects(r2))
{
result = false;
break;
}
if (result == false)
break;
}
}
return result;
}
}