Warning: 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^TM has been added to the java.beans package. Please see {@link java.beans.XMLEncoder}. 

Also see:

JFrame

 public JLayeredPane() 
{
        setLayout(null);
}

Create a new JLayeredPane

 protected  void addImpl(Component comp,
    Object constraints,
    int index) 
{
        int layer;
        int pos;
        if(constraints instanceof Integer) {
            layer = ((Integer)constraints).intValue();
            setLayer(comp, layer);
        } else
            layer = getLayer(comp);
        pos = insertIndexForLayer(layer, index);
        super.addImpl(comp, constraints, pos);
        comp.validate();
        comp.repaint();
        validateOptimizedDrawing();
}

 public AccessibleContext getAccessibleContext() 
{
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJLayeredPane();
        }
        return accessibleContext;
}

Gets the AccessibleContext associated with this JLayeredPane. For layered panes, the AccessibleContext takes the form of an AccessibleJLayeredPane. A new AccessibleJLayeredPane instance is created if necessary.

 public int getComponentCountInLayer(int layer) 
{
        int i, count, curLayer;
        int layerCount = 0;
        count = getComponentCount();
        for(i = 0; i <  count; i++) {
            curLayer = getLayer(getComponent(i));
            if(curLayer == layer) {
                layerCount++;
            /// Short circut the counting when we have them all
            } else if(layerCount  > 0 || curLayer <  layer) {
                break;
            }
        }
        return layerCount;
}

Returns the number of children currently in the specified layer.

 protected Hashtable<Component, Integer> getComponentToLayer() 
{
        if(componentToLayer == null)
            componentToLayer = new Hashtable< Component,Integer >(4);
        return componentToLayer;
}

Returns the hashtable that maps components to layers.

 public Component[] getComponentsInLayer(int layer) 
{
        int i, count, curLayer;
        int layerCount = 0;
        Component[] results;
        results = new Component[getComponentCountInLayer(layer)];
        count = getComponentCount();
        for(i = 0; i <  count; i++) {
            curLayer = getLayer(getComponent(i));
            if(curLayer == layer) {
                results[layerCount++] = getComponent(i);
            /// Short circut the counting when we have them all
            } else if(layerCount  > 0 || curLayer <  layer) {
                break;
            }
        }
        return results;
}

Returns an array of the components in the specified layer.

 public int getIndexOf(Component c) 
{
        int i, count;
        count = getComponentCount();
        for(i = 0; i <  count; i++) {
            if(c == getComponent(i))
                return i;
        }
        return -1;
}

Returns the index of the specified Component. This is the absolute index, ignoring layers. Index numbers, like position numbers, have the topmost component at index zero. Larger numbers are closer to the bottom.

 public static int getLayer(JComponent c) 
{
        Integer i;
        if((i = (Integer)c.getClientProperty(LAYER_PROPERTY)) != null)
            return i.intValue();
        return DEFAULT_LAYER.intValue();
}

Gets the layer property for a JComponent, it does not cause any side effects like setLayer(). (painting, add/remove, etc) Normally you should use the instance method getLayer().

 public int getLayer(Component c) 
{
        Integer i;
        if(c instanceof JComponent)
            i = (Integer)((JComponent)c).getClientProperty(LAYER_PROPERTY);
        else
            i = getComponentToLayer().get(c);
        if(i == null)
            return DEFAULT_LAYER.intValue();
        return i.intValue();
}

Returns the layer attribute for the specified Component.

 public static JLayeredPane getLayeredPaneAbove(Component c) 
{
        if(c == null) return null;
        Component parent = c.getParent();
        while(parent != null && !(parent instanceof JLayeredPane))
            parent = parent.getParent();
        return (JLayeredPane)parent;
}

Convenience method that returns the first JLayeredPane which contains the specified component. Note that all JFrames have a JLayeredPane at their root, so any component in a JFrame will have a JLayeredPane parent.

 protected Integer getObjectForLayer(int layer) 
{
        Integer layerObj;
        switch(layer) {
        case 0:
            layerObj = DEFAULT_LAYER;
            break;
        case 100:
            layerObj = PALETTE_LAYER;
            break;
        case 200:
            layerObj = MODAL_LAYER;
            break;
        case 300:
            layerObj = POPUP_LAYER;
            break;
        case 400:
            layerObj = DRAG_LAYER;
            break;
        default:
            layerObj = new Integer(layer);
        }
        return layerObj;
}

Returns the Integer object associated with a specified layer.

 public int getPosition(Component c) 
{
        int i, startLayer, curLayer, startLocation, pos = 0;
        getComponentCount();
        startLocation = getIndexOf(c);
        if(startLocation == -1)
            return -1;
        startLayer = getLayer(c);
        for(i = startLocation - 1; i  >= 0; i--) {
            curLayer = getLayer(getComponent(i));
            if(curLayer == startLayer)
                pos++;
            else
                return pos;
        }
        return pos;
}

Get the relative position of the component within its layer.

 public int highestLayer() 
{
        if(getComponentCount()  > 0)
            return getLayer(getComponent(0));
        return 0;
}

Returns the highest layer value from all current children. Returns 0 if there are no children.

 protected int insertIndexForLayer(int layer,
    int position) 
{
        return insertIndexForLayer(null, layer, position);
}

Primitive method that determines the proper location to insert a new child based on layer and position requests.

 public boolean isOptimizedDrawingEnabled() 
{
        return optimizedDrawingPossible;
}

Returns false if components in the pane can overlap, which makes optimized drawing impossible. Otherwise, returns true.

 public int lowestLayer() 
{
        int count = getComponentCount();
        if(count  > 0)
            return getLayer(getComponent(count-1));
        return 0;
}

Returns the lowest layer value from all current children. Returns 0 if there are no children.

 public  void moveToBack(Component c) 
{
        setPosition(c, -1);
}

Moves the component to the bottom of the components in its current layer (position -1).

 public  void moveToFront(Component c) 
{
        setPosition(c, 0);
}

Moves the component to the top of the components in its current layer (position 0).

 public  void paint(Graphics g) 
{
        if(isOpaque()) {
            Rectangle r = g.getClipBounds();
            Color c = getBackground();
            if(c == null)
                c = Color.lightGray;
            g.setColor(c);
            if (r != null) {
                g.fillRect(r.x, r.y, r.width, r.height);
            }
            else {
                g.fillRect(0, 0, getWidth(), getHeight());
            }
        }
        super.paint(g);
}

Paints this JLayeredPane within the specified graphics context.

 protected String paramString() 
{
        String optimizedDrawingPossibleString = (optimizedDrawingPossible ?
                                                 "true" : "false");
        return super.paramString() +
        ",optimizedDrawingPossible=" + optimizedDrawingPossibleString;
}

Returns a string representation of this JLayeredPane. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null.

 public static  void putLayer(JComponent c,
    int layer) 
{
        /// MAKE SURE THIS AND setLayer(Component c, int layer, int position)  are SYNCED
        Integer layerObj;
        layerObj = new Integer(layer);
        c.putClientProperty(LAYER_PROPERTY, layerObj);
}

Sets the layer property on a JComponent. This method does not cause any side effects like setLayer() (painting, add/remove, etc). Normally you should use the instance method setLayer(), in order to get the desired side-effects (like repainting).

 public  void remove(int index) 
{
        Component c = getComponent(index);
        super.remove(index);
        if (c != null && !(c instanceof JComponent)) {
            getComponentToLayer().remove(c);
        }
        validateOptimizedDrawing();
}

Remove the indexed component from this pane. This is the absolute index, ignoring layers.

 public  void removeAll() 
{
        Component[] children = getComponents();
        Hashtable cToL = getComponentToLayer();
        for (int counter = children.length - 1; counter  >= 0; counter--) {
            Component c = children[counter];
            if (c != null && !(c instanceof JComponent)) {
                cToL.remove(c);
            }
        }
        super.removeAll();
}

Removes all the components from this container.

 public  void setLayer(Component c,
    int layer) 
{
        setLayer(c, layer, -1);
}

Sets the layer attribute on the specified component, making it the bottommost component in that layer. Should be called before adding to parent.

 public  void setLayer(Component c,
    int layer,
    int position) 
{
        Integer layerObj;
        layerObj = getObjectForLayer(layer);
        if(layer == getLayer(c) && position == getPosition(c)) {
                repaint(c.getBounds());
            return;
        }
        /// MAKE SURE THIS AND putLayer(JComponent c, int layer) are SYNCED
        if(c instanceof JComponent)
            ((JComponent)c).putClientProperty(LAYER_PROPERTY, layerObj);
        else
            getComponentToLayer().put(c, layerObj);
        if(c.getParent() == null || c.getParent() != this) {
            repaint(c.getBounds());
            return;
        }
        int index = insertIndexForLayer(c, layer, position);
        setComponentZOrder(c, index);
        repaint(c.getBounds());
}

Sets the layer attribute for the specified component and also sets its position within that layer.

 public  void setPosition(Component c,
    int position) 
{
        setLayer(c, getLayer(c), position);
}

Moves the component to position within its current layer, where 0 is the topmost position within the layer and -1 is the bottommost position.

Note: Position numbering is defined by java.awt.Container, and is the opposite of layer numbering. Lower position numbers are closer to the top (0 is topmost), and higher position numbers are closer to the bottom.