borderlayout.java

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

/*
 * @(#)BorderLayout.java	1.41 06/10/10
 *
 * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation. 
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt). 
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA 
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions. 
 *
 */

package java.awt;

import java.util.Hashtable;

/**
 * A border layout lays out a container, arranging and resizing
 * its components to fit in five regions:
 * <code>North</code>, <code>South</code>, <code>East</code>, 
 * <code>West</code>, and <code>Center</code>.  When adding a 
 * component to a container with a border layout, use one of these
 * five names, for example:
 * <pre>
 *    Panel p = new Panel();
 *    p.setLayout(new BorderLayout());
 *    p.add(new Button("Okay"), "South");
 * </pre>
 * As a convenience, BorderLayout interprets the absence of a string
 * specification the same as "Center":
 * <pre>
 *    Panel p2 = new Panel();
 *    p2.setLayout(new BorderLayout());
 *    p2.add(new TextArea());  // Same as p.add(new TextArea(), "Center");
 * </pre>
 * <p>
 * The components are laid out according to their 
 * preferred sizes and the constraints of the container's size. 
 * The <code>North</code> and <code>South</code> components may 
 * be stretched horizontally; the <code>East</code> and 
 * <code>West</code> components may be stretched vertically; 
 * the <code>Center</code> component may stretch both horizontally 
 * and vertically to fill any space left over. 
 * <p>
 * Here is an example of five buttons in an applet laid out using 
 * the <code>BorderLayout</code> layout manager:
 * <p>
 * <img src="images-awt/BorderLayout-1.gif"
 * ALIGN=center HSPACE=10 VSPACE=7>
 * <p>
 * The code for this applet is as follows: 
 * <p>
 * <hr><blockquote><pre>
 * import java.awt.*;
 * import java.applet.Applet;
 * 
 * public class buttonDir extends Applet {
 *   public void init() {
 *     setLayout(new BorderLayout());
 *     add("North",  new Button("North"));
 *     add("South",  new Button("South"));
 *     add("East",   new Button("East"));
 *     add("West",   new Button("West"));
 *     add("Center", new Button("Center"));
 *   }
 * }
 * </pre></blockquote><hr>
 * <p>
 * @version 	1.27 02/11/97
 * @author 	Arthur van Hoff
 * @see         java.awt.Container#add(String, Component)
 * @since       JDK1.0
 */
public class BorderLayout implements LayoutManager2,
        java.io.Serializable {
    int hgap;
    int vgap;
    Component north;
    Component west;
    Component east;
    Component south;
    Component center;
    /**
     * The north layout constraint (top of container).
     */
    public static final String NORTH = "North";
    /**
     * The south layout constraint (bottom of container).
     */
    public static final String SOUTH = "South";
    /**
     * The east layout constraint (left side of container).
     */
    public static final String EAST = "East";
    /**
     * The west layout constraint (right side of container).
     */
    public static final String WEST = "West";
    /**
     * The center layout constraint (middle of container).
     */
    public static final String CENTER = "Center";
    /*
     * JDK 1.1 serialVersionUID 
     */
    private static final long serialVersionUID = -8658291919501921765L;
    /**
     * Constructs a new border layout with  
     * no gaps between components.
     * @since     JDK1.0
     */
    public BorderLayout() {
        this(0, 0);
    }

    /**
     * Constructs a border layout with the specified gaps 
     * between components.
     * The horizontal gap is specified by <code>hgap</code> 
     * and the vertical gap is specified by <code>vgap</code>.
     * @param   hgap   the horizontal gap.
     * @param   vgap   the vertical gap.	
     * @since   JDK1.0
     */	
    public BorderLayout(int hgap, int vgap) {
        this.hgap = hgap;
        this.vgap = vgap;
    }

    /**
     * Returns the horizontal gap between components.
     * @since   JDK1.1
     */
    public int getHgap() {
        return hgap;
    }
    
    /**
     * Sets the horizontal gap between components.
     * @param hgap the horizontal gap between components
     * @since   JDK1.1
     */
    public void setHgap(int hgap) {
        this.hgap = hgap;
    }
    
    /**
     * Returns the vertical gap between components.
     * @since   JDK1.1
     */
    public int getVgap() {
        return vgap;
    }
    
    /**
     * Sets the vertical gap between components.
     * @param vgap the vertical gap between components
     * @since   JDK1.1
     */
    public void setVgap(int vgap) {
        this.vgap = vgap;
    }

    /**
     * Adds the specified component to the layout, using the specified
     * constraint object.  For border layouts, the constraint must be
     * one of the following strings:  <code>"North"</code>,
     * <code>"South"</code>, <code>"East"</code>,
     * <code>"West"</code>, or <code>"Center"</code>.  
     * <p>
     * Most applications do not call this method directly. This method 
     * is called when a component is added to a container using the 
     * <code>Container.add</code> method with the same argument types.
     * @param   comp         the component to be added.
     * @param   constraints  an object that specifies how and where 
     *                       the component is added to the layout.
     * @see     java.awt.Container#add(java.awt.Component, java.lang.Object)
     * @exception   IllegalArgumentException  if the constraint object is not
     *                 a string, or if it not one of the five specified strings.
     * @since   JDK1.1
     */
    public void addLayoutComponent(Component comp, Object constraints) {
        synchronized (comp.getTreeLock()) {
            if ((constraints == null) || (constraints instanceof String)) {
                addLayoutComponent((String) constraints, comp);
            } else {
                throw new IllegalArgumentException("cannot add to layout: constraint must be a string (or null)");
            }
        }
    }

    /**
     * @deprecated  replaced by <code>addLayoutComponent(Component, Object)</code>.
     */
    public void addLayoutComponent(String name, Component comp) {
        synchronized (comp.getTreeLock()) {
            /* Special case:  treat null the same as "Center". */
            if (name == null) {
                name = "Center";
            }
            /* Assign the component to one of the known regions of the layout.
             */
            if ("Center".equals(name)) {
                center = comp;
            } else if ("North".equals(name)) {
                north = comp;
            } else if ("South".equals(name)) {
                south = comp;
            } else if ("East".equals(name)) {
                east = comp;
            } else if ("West".equals(name)) {
                west = comp;
            } else {
                throw new IllegalArgumentException("cannot add to layout: unknown constraint: " + name);
            }
        }
    }

    /**