gcc/libjava/java/awt/BorderLayout.java

/* Copyright (C) 1999, 2000  Free Software Foundation

   This file is part of libjava.

This software is copyrighted work licensed under the terms of the
Libjava License.  Please consult the file "LIBJAVA_LICENSE" for
details.  */

package java.awt;

public class BorderLayout implements LayoutManager2, java.io.Serializable
{
  public static final String NORTH  = "North",
                             SOUTH  = "South",
                             EAST   = "East",
                             WEST   = "West",
                             CENTER = "Center";
  
  // FIXME: use these too
  public static final String BEFORE_FIRST_LINE = "First",
                             AFTER_LAST_LINE = "Last",
                             BEFORE_LINE_BEGINS = "Before",
                             AFTER_LINE_ENDS = "After";


  // FIXME: check serialization of fields
  int hgap;
  int vgap;
  Component north, south, east, west, center;

  public BorderLayout ()
  {
    this (0, 0);
  }

  public BorderLayout (int hgap, int vgap)
  {
    this.hgap = hgap;
    this.vgap = vgap;
  }

  public int getHgap()
  {
    return hgap;
  }    

  public void setHgap(int hgap)
  {
    this.hgap = hgap;
  }

  public int getVgap()
  {
    return vgap;
  }    

  public void setVgap(int vgap)
  {
    this.vgap = vgap;
  }
  
  public void addLayoutComponent(Component comp, Object constraints)
  {
    if ((constraints == null) || CENTER.equals(constraints))
      {
	center = comp; 
      }
    else if (NORTH.equals(constraints))
      {
	north = comp;
      }
    else if (SOUTH.equals(constraints))
      {
	south = comp;
      }
    else if (EAST.equals(constraints))
      {
	east = comp;
      }
    else if (WEST.equals(constraints))
      {
	west = comp;
      }
  }
    
  public void addLayoutComponent(String name, Component comp)
  {
    addLayoutComponent(comp, name);
  }

  public void removeLayoutComponent(Component comp)
  {
    if (center == comp)
      {
	center = null;
      }
    else if (north == comp)
      {
	north = null;
      }
    else if (south == comp)
      {
	south = null;
      }
    else if (east == comp)
      {
	east = null;
      }
    else if (west == comp)
      {
	west = null;
      }
  }

  public Dimension minimumLayoutSize(Container target)
  {
    return calcSize(getMinimumSize(center),
		    getMinimumSize(north),
		    getMinimumSize(south),
		    getMinimumSize(east),
		    getMinimumSize(west),
		    target);
  }

  public Dimension preferredLayoutSize(Container target)
  {
    return calcSize(getPreferredSize(center),
		    getPreferredSize(north),
		    getPreferredSize(south),
		    getPreferredSize(east),
		    getPreferredSize(west),
		    target);	
  }
    
  /**
   * Completely disregards the requested maximum sizes of the
   * components, and states that the container has no upper size
   * limit.
   *
   * @return a dimension of width and height Integer.MAX_VALUE.
   */
  public Dimension maximumLayoutSize(Container target)
  {
    return (Dimension) DIM_MAX.clone();
  }	

  public float getLayoutAlignmentX(Container parent)
  {
    return Component.CENTER_ALIGNMENT;
  }

  public float getLayoutAlignmentY(Container parent)
  {
    return Component.CENTER_ALIGNMENT;
  }
    
  public void invalidateLayout(Container target)
  {
    // TODO... implement caching?
  }

  public void layoutContainer(Container target)
  {
    Insets i = target.getInsets();
    Dimension c = getPreferredSize(center);
    Dimension n = getPreferredSize(north);
    Dimension s = getPreferredSize(south);
    Dimension e = getPreferredSize(east);
    Dimension w = getPreferredSize(west);
    Dimension t = target.getSize();
    
    /*
             <-> hgap     <-> hgap
      +----------------------------+          }
      |t                           |          } i.top
      |  +----------------------+  |  --- y1  }
      |  |n                     |  |
      |  +----------------------+  |          } vgap
      |  +---+ +----------+ +---+  |  --- y2  }        }
      |  |w  | |c         | |e  |  |                   } hh
      |  +---+ +----------+ +---+  |          } vgap   }
      |  +----------------------+  |  --- y3  }
      |  |s                     |  |
      |  +----------------------+  |          }
      |                            |          } i.bottom
      +----------------------------+          }
         |x1   |x2          |x3
         <---------------------->
      <-->         ww           <-->
     i.left                    i.right
    */

    int x1 = i.left;
    int x2 = x1 + w.width + hgap;
    int x3 = t.width - i.right - e.width;
    int ww = t.width - i.right - i.left;

    int y1 = i.top;
    int y2 = y1 + n.height + vgap;
    int y3 = t.height - i.bottom - s.height;
    int hh = y3-y2-vgap;

    setBounds(center, x2, y2, x3-x2-hgap, hh);
    setBounds(north, x1, y1, ww, n.height);
    setBounds(south, x1, y3, ww, s.height);
    setBounds(west, x1, y2, w.width, hh);
    setBounds(east, x3, y2, e.width, hh);
  }
  
  public String toString()
  {
    return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
  }


  // Support:

  static final Dimension DIM_0   = new Dimension(0, 0);
  static final Dimension DIM_MAX = new Dimension(Integer.MAX_VALUE,
						 Integer.MAX_VALUE);

  void setBounds(Component comp, int x, int y, int w, int h)
  {
    if (comp == null)
      return;
    comp.setBounds(x, y, w, h);
  }

  Dimension getMinimumSize(Component comp)
  {
    if (comp == null)
      return DIM_0;
    return comp.getMinimumSize();
  }

  Dimension getPreferredSize(Component comp)
  {
    if (comp == null)
      return DIM_0;
    return comp.getPreferredSize();
  }

  Dimension calcSize(Dimension c, Dimension n, Dimension s,
		     Dimension e, Dimension w, Container target)
  {
    Insets i = target.getInsets();
    
    return new Dimension(c.width + e.width + w.width + hgap*2 +
			 i.left + i.right,
			 c.height + n.height + s.height + vgap*2 +
			 i.top + i.bottom
			 );
  }
}