borderlayout.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

     * Removes the specified component from this border layout. This 
     * method is called when a container calls its <code>remove</code> or 
     * <code>removeAll</code> methods. Most applications do not call this 
     * method directly. 
     * @param   comp   the component to be removed.
     * @see     java.awt.Container#remove(java.awt.Component)
     * @see     java.awt.Container#removeAll()
     * @since   JDK1.0
     */
    public void removeLayoutComponent(Component comp) {
        synchronized (comp.getTreeLock()) {
            if (comp == center) {
                center = null;
            } else if (comp == north) {
                north = null;
            } else if (comp == south) {
                south = null;
            } else if (comp == east) {
                east = null;
            } else if (comp == west) {
                west = null;
            }
        }
    }

    /**
     * Determines the minimum size of the <code>target</code> container 
     * using this layout manager. 
     * <p>
     * This method is called when a container calls its 
     * <code>getMinimumSize</code> method. Most applications do not call 
     * this method directly. 
     * @param   target   the container in which to do the layout.
     * @return  the minimum dimensions needed to lay out the subcomponents 
     *          of the specified container.
     * @see     java.awt.Container  
     * @see     java.awt.BorderLayout#preferredLayoutSize
     * @see     java.awt.Container#getMinimumSize()
     * @since   JDK1.0
     */
    public Dimension minimumLayoutSize(Container target) {
        synchronized (target.getTreeLock()) {
            Dimension dim = new Dimension(0, 0);
            if ((east != null) && east.visible) {
                Dimension d = east.getMinimumSize();
                dim.width += d.width + hgap;
                dim.height = Math.max(d.height, dim.height);
            }
            if ((west != null) && west.visible) {
                Dimension d = west.getMinimumSize();
                dim.width += d.width + hgap;
                dim.height = Math.max(d.height, dim.height);
            }
            if ((center != null) && center.visible) {
                Dimension d = center.getMinimumSize();
                dim.width += d.width;
                dim.height = Math.max(d.height, dim.height);
            }
            if ((north != null) && north.visible) {
                Dimension d = north.getMinimumSize();
                dim.width = Math.max(d.width, dim.width);
                dim.height += d.height + vgap;
            }
            if ((south != null) && south.visible) {
                Dimension d = south.getMinimumSize();
                dim.width = Math.max(d.width, dim.width);
                dim.height += d.height + vgap;
            }
            Insets insets = target.getInsets();
            dim.width += insets.left + insets.right;
            dim.height += insets.top + insets.bottom;
            return dim;
        }
    }
    
    /**
     * Determines the preferred size of the <code>target</code> 
     * container using this layout manager, based on the components
     * in the container. 
     * <p>
     * Most applications do not call this method directly. This method
     * is called when a container calls its <code>getPreferredSize</code> 
     * method.
     * @param   target   the container in which to do the layout.
     * @return  the preferred dimensions to lay out the subcomponents 
     *          of the specified container.
     * @see     java.awt.Container  
     * @see     java.awt.BorderLayout#minimumLayoutSize  
     * @see     java.awt.Container#getPreferredSize()
     * @since   JDK1.0
     */
    public Dimension preferredLayoutSize(Container target) {
        synchronized (target.getTreeLock()) {
            Dimension dim = new Dimension(0, 0);
            if ((east != null) && east.visible) {
                Dimension d = east.getPreferredSize();
                dim.width += d.width + hgap;
                dim.height = Math.max(d.height, dim.height);
            }
            if ((west != null) && west.visible) {
                Dimension d = west.getPreferredSize();
                dim.width += d.width + hgap;
                dim.height = Math.max(d.height, dim.height);
            }
            if ((center != null) && center.visible) {
                Dimension d = center.getPreferredSize();
                dim.width += d.width;
                dim.height = Math.max(d.height, dim.height);
            }
            if ((north != null) && north.visible) {
                Dimension d = north.getPreferredSize();
                dim.width = Math.max(d.width, dim.width);
                dim.height += d.height + vgap;
            }
            if ((south != null) && south.visible) {
                Dimension d = south.getPreferredSize();
                dim.width = Math.max(d.width, dim.width);
                dim.height += d.height + vgap;
            }
            Insets insets = target.getInsets();
            dim.width += insets.left + insets.right;
            dim.height += insets.top + insets.bottom;
            return dim;
        }
    }

    /**
     * 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 container argument using this border layout. 
     * <p>
     * This method actually reshapes the components in the specified
     * container in order to satisfy the constraints of this 
     * <code>BorderLayout</code> object. The <code>North</code> 
     * and <code>South</code>components, if any, are placed at 
     * the top and bottom of the container, respectively. The 
     * <code>West</code> and <code>East</code> components are 
     * then placed on the left and right, respectively. Finally, 
     * the <code>Center</code> object is placed in any remaining 
     * space in the middle. 
     * <p>
     * Most applications do not call this method directly. This method 
     * is called when a container calls its <code>doLayout</code> method. 
     * @param   target   the container in which to do the layout.
     * @see     java.awt.Container  
     * @see     java.awt.Container#doLayout()
     * @since   JDK1.0
     */
    public void layoutContainer(Container target) {
        synchronized (target.getTreeLock()) {
            Insets insets = target.getInsets();
            int top = insets.top;
            int bottom = target.height - insets.bottom;
            int left = insets.left;
            int right = target.width - insets.right;
            if ((north != null) && north.visible) {
                north.setSize(right - left, north.height);
                Dimension d = north.getPreferredSize();
                north.setBounds(left, top, right - left, d.height);
                top += d.height + vgap;
            }
            if ((south != null) && south.visible) {
                south.setSize(right - left, south.height);
                Dimension d = south.getPreferredSize();
                south.setBounds(left, bottom - d.height, right - left, d.height);
                bottom -= d.height + vgap;
            }
            if ((east != null) && east.visible) {
                east.setSize(east.width, bottom - top);
                Dimension d = east.getPreferredSize();
                east.setBounds(right - d.width, top, d.width, bottom - top);
                right -= d.width + hgap;
            }
            if ((west != null) && west.visible) {
                west.setSize(west.width, bottom - top);
                Dimension d = west.getPreferredSize();
                west.setBounds(left, top, d.width, bottom - top);
                left += d.width + hgap;
            }
            if ((center != null) && center.visible) {
                center.setBounds(left, top, right - left, bottom - top);
            }
        }
    }
    
    /**
     * Returns a string representation of the state of this border layout.
     * @return    a string representation of this border layout.
     * @since     JDK1.0
     */
    public String toString() {
        return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
    }
}