if (d.width > w) {                    w = d.width;                }                if (d.height > h) {                    h = d.height;                }            }            return new Dimension(insets.left + insets.right + w + hgap*2,                                 insets.top + insets.bottom + h + vgap*2);        }    }    /**     * Returns the maximum dimensions for this layout given the components     * in the specified target container.     * @param target the component which needs to be laid out     * @see Container     * @see #minimumLayoutSize     * @see #preferredLayoutSize     */    public Dimension maximumLayoutSize(Container target) {	return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);    }    /**     * Returns the alignment along the x axis.  This specifies how     * the component would like to be aligned relative to other     * components.  The value should be a number between 0 and 1     * where 0 represents alignment along the origin, 1 is aligned     * the furthest away from the origin, 0.5 is centered, etc.     */    public float getLayoutAlignmentX(Container parent) {	return 0.5f;    }    /**     * Returns the alignment along the y axis.  This specifies how     * the component would like to be aligned relative to other     * components.  The value should be a number between 0 and 1     * where 0 represents alignment along the origin, 1 is aligned     * the furthest away from the origin, 0.5 is centered, etc.     */    public float getLayoutAlignmentY(Container parent) {	return 0.5f;    }    /**     * Invalidates the layout, indicating that if the layout manager     * has cached information it should be discarded.     */    public void invalidateLayout(Container target) {    }    /**     * Lays out the specified container using this card layout.     * <p>     * Each component in the <code>parent</code> container is reshaped     * to be the size of the container, minus space for surrounding     * insets, horizontal gaps, and vertical gaps.     *     * @param     parent the name of the parent container     *                             in which to do the layout.     * @see       java.awt.Container#doLayout     */    public void layoutContainer(Container parent) {        synchronized (parent.getTreeLock()) {            Insets insets = parent.getInsets();            int ncomponents = parent.getComponentCount();            Component comp = null;            boolean currentFound = false;            for (int i = 0 ; i < ncomponents ; i++) {                comp = parent.getComponent(i);                comp.setBounds(hgap + insets.left, vgap + insets.top,                               parent.width - (hgap*2 + insets.left + insets.right),                               parent.height - (vgap*2 + insets.top + insets.bottom));                if (comp.isVisible()) {                    currentFound = true;                }            }            if (!currentFound && ncomponents > 0) {                parent.getComponent(0).setVisible(true);            }        }    }    /**     * Make sure that the Container really has a CardLayout installed.     * Otherwise havoc can ensue!     */    void checkLayout(Container parent) {	if (parent.getLayout() != this) {	    throw new IllegalArgumentException("wrong parent for CardLayout");	}    }    /**     * Flips to the first card of the container.     * @param     parent   the name of the parent container     *                          in which to do the layout.     * @see       java.awt.CardLayout#last     */    public void first(Container parent) {	synchronized (parent.getTreeLock()) {	    checkLayout(parent);            int ncomponents = parent.getComponentCount();            for (int i = 0 ; i < ncomponents ; i++) {                Component comp = parent.getComponent(i);                if (comp.isVisible()) {                    comp.setVisible(false);                    break;                }            }            if (ncomponents > 0) {                currentCard = 0;                parent.getComponent(0).setVisible(true);                parent.validate();            }	}    }    /**     * Flips to the next card of the specified container. If the     * currently visible card is the last one, this method flips to the     * first card in the layout.     * @param     parent   the name of the parent container     *                          in which to do the layout.     * @see       java.awt.CardLayout#previous     */    public void next(Container parent) {	synchronized (parent.getTreeLock()) {	    checkLayout(parent);            int ncomponents = parent.getComponentCount();            for (int i = 0 ; i < ncomponents ; i++) {                Component comp = parent.getComponent(i);                if (comp.isVisible()) {                    comp.setVisible(false);                    currentCard = (i + 1) % ncomponents;                    comp = parent.getComponent(currentCard);                    comp.setVisible(true);                    parent.validate();                    return;                }            }            showDefaultComponent(parent);	}    }    /**     * Flips to the previous card of the specified container. If the     * currently visible card is the first one, this method flips to the     * last card in the layout.     * @param     parent   the name of the parent container     *                          in which to do the layout.     * @see       java.awt.CardLayout#next     */    public void previous(Container parent) {	synchronized (parent.getTreeLock()) {	    checkLayout(parent);            int ncomponents = parent.getComponentCount();            for (int i = 0 ; i < ncomponents ; i++) {                Component comp = parent.getComponent(i);                if (comp.isVisible()) {                    comp.setVisible(false);                    currentCard = ((i > 0) ? i-1 : ncomponents-1);                    comp = parent.getComponent(currentCard);                    comp.setVisible(true);                    parent.validate();                    return;                }            }            showDefaultComponent(parent);	}    }    void showDefaultComponent(Container parent) {        if (parent.getComponentCount() > 0) {            currentCard = 0;            parent.getComponent(0).setVisible(true);            parent.validate();        }    }    /**     * Flips to the last card of the container.     * @param     parent   the name of the parent container     *                          in which to do the layout.     * @see       java.awt.CardLayout#first     */    public void last(Container parent) {	synchronized (parent.getTreeLock()) {	    checkLayout(parent);            int ncomponents = parent.getComponentCount();            for (int i = 0 ; i < ncomponents ; i++) {                Component comp = parent.getComponent(i);                if (comp.isVisible()) {                    comp.setVisible(false);                    break;                }            }            if (ncomponents > 0) {                currentCard = ncomponents - 1;                parent.getComponent(currentCard).setVisible(true);                parent.validate();            }	}    }    /**     * Flips to the component that was added to this layout with the     * specified <code>name</code>, using <code>addLayoutComponent</code>.     * If no such component exists, then nothing happens.     * @param     parent   the name of the parent container     *                     in which to do the layout.     * @param     name     the component name.     * @see       java.awt.CardLayout#addLayoutComponent(java.awt.Component, java.lang.Object)     */    public void show(Container parent, String name) {	synchronized (parent.getTreeLock()) {	    checkLayout(parent);            Component next = null;            int ncomponents = vector.size();            for (int i = 0; i < ncomponents; i++) {                Card card = (Card)vector.get(i);                if (card.name.equals(name)) {                    next = card.comp;                    currentCard = i;                    break;                }            }            if ((next != null) && !next.isVisible()) {                ncomponents = parent.getComponentCount();                for (int i = 0; i < ncomponents; i++) {                    Component comp = parent.getComponent(i);                    if (comp.isVisible()) {                        comp.setVisible(false);                        break;                    }                }                next.setVisible(true);                parent.validate();            }	}    }    /**     * Returns a string representation of the state of this card layout.     * @return    a string representation of this card layout.     */    public String toString() {	return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";    }    /**     * Reads serializable fields from stream.     */    private void readObject(ObjectInputStream s)	throws ClassNotFoundException, IOException    {        ObjectInputStream.GetField f = s.readFields();        hgap = f.get("hgap", 0);        vgap = f.get("vgap", 0);        if (f.defaulted("vector")) {              //  pre-1.4 stream            Hashtable tab = (Hashtable)f.get("tab", null);            vector = new Vector();            if (tab != null && !tab.isEmpty()) {                for (Enumeration e = tab.keys() ; e.hasMoreElements() ; ) {                    String key = (String)e.nextElement();                    Component comp = (Component)tab.get(key);                    vector.add(new Card(key, comp));                    if (comp.isVisible()) {                        currentCard = vector.size() - 1;                    }                }            }        } else {            vector = (Vector)f.get("vector", null);            currentCard = f.get("currentCard", 0);        }    }    /**     * Writes serializable fields to stream.     */    private void writeObject(ObjectOutputStream s)        throws IOException    {        Hashtable tab = new Hashtable();        int ncomponents = vector.size();        for (int i = 0; i < ncomponents; i++) {            Card card = (Card)vector.get(i);            tab.put(card.name, card.comp);        }        ObjectOutputStream.PutField f = s.putFields();        f.put("hgap", hgap);        f.put("vgap", vgap);        f.put("vector", vector);        f.put("currentCard", currentCard);        f.put("tab", tab);        s.writeFields();    }}