// Author: Graham Freeman. November 2005
// This version: 3rd August 2007
// Copyright (c) Graham Freeman.  g-freeman@adfa.edu.au
// The author accepts no responsibility for any problems caused by use of 
// this software.  It is supplied free of charge, and usage is unrestricted, 
// provided this copyright notice remains intact, regardless of how the 
// software may be modified by other people. 

// April 2006 release: the algorithm for determining size of the container has
// been revised to make it more robust. The first release sometimes gave too
// small a container.

// July 2008 release: handling of proportional placement has been improved.
// There can still be overlapping components and the need to call pack() twice, 
// but errors in the earlier version in determining container size and
// placement have mostly been fixed.

import java.awt.*;
import java.util.*;

   /** FormLayout provides a simple means of controlling layout which is
    * sufficiently powerful to enable many layouts to be achieved with few
    * programming statements.  Four types of constraint are provided:
    * <ul><li> placement at a fixed distance from an edge of the container;
    *     <li> placement at a fixed distance in relation to a neighbouring 
    *          component;
    *     <li> placement with one edge aligned with the same edge of another 
    *          component;
    *     <li> placement at a fractional position within the available width 
    *          or height of the container.
    * </ul>
    * By this process, adding a component requires no more than two or three 
    * placement instructions.
    * <p>
    * Unlike other layout managers, the FormLayout constructor requires a
    * parameter, the container it is responsible for.  With this layout manager,
    * components should not be added to the container by the programmer;  
    * instead, calls should
    * be made to the layout manager indicating how the children are to be
    * constrained, and the layout manager will itself tell the container of the
    * children it has gained.  The FormLayout object needs to be told of these
    * constraints with methods:
    * <p><table>
    * <tr><td>Methods:</td><td>Actions:</td></tr>
    *
    * <tr><td valign="top"> 
    *  {@code setLeftAnchor}, {@code setRightAnchor}, 
    *  {@code setTopAnchor}, {@code setBottomAnchor}
    *      </td><td valign="top"> Fixed distance from an edge of the container
    *
    * </td></tr><tr><td valign="top"> 
    *  {@code setLeftRelative}, {@code setRightRelative}, 
    *  {@code setTopRelative}, {@code setBottomRelative}
    *      </td><td valign="top"> Fixed distance relative to a neighbouring 
    *                             component
    *
    * </td></tr><tr><td valign="top"> 
    *  {@code setLeftAlign}, {@code setRightAlign}, {@code setTopAlign}, 
    *  {@code setBottomAlign}
    *      </td><td valign="top"> One edge aligned with another component
    *
    * </td></tr><tr><td valign="top"> 
    *  {@code setHorizontalAnchor}, {@code setVerticalAnchor}
    *      </td><td valign="top"> Fractional position within the available 
    *                             width or height
    * </td></tr></table> 
    * <p>
    * The inspiration for this design came from the form widget in X Windows.
    * There is also a FormLayout in SWT developed by IBM and maintained now by
    * Eclipse, which is more sophisticated and flexible, but requires more
    * lines of code to insert the components.  It is also similar to Sun's
    * SpringLayout, but with fewer features and requiring rather less code.
    * <p>
    * The size of the container is determined from the components placed with
    * respect to the edges or the other components in the container.  Components
    * placed at a fraction of the width or height of the container are not
    * considered in determining size; they rely on space being 
    * present as a result of the size of the other components.
    * <p>
    * Relative placement can be made with respect to more than one 
    * neighbour on the left or top side.  FormLayout will determine which takes 
    * the greater amount of space and set this position for the component.
    * <h2>Example</h2>
    * <p align="center">
    *<img src="FormLayoutExample.png" alt=""></p>
    <pre>
      Container cpane = getContentPane();
      <b>FormLayout form = new FormLayout(cpane);</b>

      JLabel lab1 = new JLabel("Name: ") ;
      <b>form.setTopAnchor( lab1, 3 );
      form.setLeftAnchor( lab1, 4 );</b>
      JLabel lab2 = new JLabel("Address: ");

      JTextField name = new JTextField(" ",50);
      <b>form.setLeftRelative( name, lab1, 3 );
      form.setLeftRelative( name, lab2, 3 );
      form.setTopAnchor( name, 3 );

      form.setLeftAnchor( lab2, 4 );
      form.setTopRelative( lab2, name, 3 );</b>
      JTextArea addr = new JTextArea(" ",3,50 );
      JScrollPane jsp = new JScrollPane( addr, 
               JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, 
               JScrollPane.HORIZONTAL_SCROLLBAR_NEVER );
      <b>form.setLeftAlign( jsp, name );
      form.setTopRelative( jsp, name, 3 );
      form.setRightAnchor( jsp, 4 );</b>

      JLabel lab4 = new JLabel("Adult ");
      <b>form.setLeftAlign( lab4, name );
      form.setTopRelative( lab4, jsp, 3 );</b>

      JTextField adults = new JTextField(" ",3);
      <b>form.setLeftRelative( adults, lab4, 3 );
      form.setTopRelative( adults, jsp, 3 );</b>

      JLabel Ch = new JLabel("Child");
      <b>form.setLeftRelative( Ch, adults, 16 );
      form.setTopRelative( Ch, jsp, 3 );</b>

      JTextField children = new JTextField(" ",3);
      <b>form.setLeftRelative( children, Ch, 3 );
      form.setTopRelative( children, jsp, 3 );</b>

      JLabel Con = new JLabel("Concession");
      <b>form.setLeftRelative( Con, children, 16 );
      form.setTopRelative( Con, jsp, 3 );</b>

      JTextField concess = new JTextField(" ",3);
      <b>form.setLeftRelative( concess, Con, 3 );
      form.setTopRelative( concess, jsp, 3 );</b>

      JButton accept = new JButton("Accept");
      <b>form.setHorizontalAnchor( accept, 0.2 );
      form.setTopRelative( accept, adults, 3 );</b>
      JButton reject = new JButton("Reject");
      <b>form.setHorizontalAnchor( reject, 0.5 );
      form.setTopAlign( reject, accept );</b>
      accept.addActionListener( this );
      reject.addActionListener( this );

      JButton quit = new JButton("Exit");
      <b>form.setHorizontalAnchor( quit, 0.8 );
      form.setTopAlign( quit, accept );
      form.setBottomAnchor( quit, 5 );</b>
      quit.addActionListener( this );
      pack();
      </pre>
      FormLayout does not have any concept of filling available space, so there are
situations where it will not give as neat appearance as GridBag, such as with
JScrollPanes.  There are also occasions after <code>pack()</code> has been called when
FormLayout requests the preferred size of the components within it, and resizes
the container accordingly.  If the size reported by a component is incorrect,
FormLayout will have no way of detecting this.  It may be necessary to call
<code>pack()</code> a second time in these situations.
    */
public class FormLayout implements LayoutManager
{
   //protected ArrayList constrain = new ArrayList();
   //protected ArrayList sizepos = new ArrayList();
   protected ArrayList<Constraint> constrain = new ArrayList<Constraint>();
   protected ArrayList<Placement> sizepos = new ArrayList<Placement>();
   protected Container container;
   protected boolean changedConstraints = false;
   
   static protected int LEFT=1, RIGHT=2, TOP=3, BOTTOM=4;
   static protected int HORIZONTAL=5, VERTICAL=6;
   static protected int RELATIVE=11, POSITION=12, PROPORTION=13, ALIGN=14;
   static protected int PREFERRED=18, MINIMUM=19;
         /** End-of-line character(s) on the current machine. */
   static public String EOL = System.getProperty("line.separator");
   
      /** Construct a FormLayout object, telling the layout manager which 
       * container it is responsible for.
       */
   public FormLayout( Container c )
   {
      container = c;
      c.setLayout(this);
   }
   
      /** Lays out the specified container.  Normally called by the container
       *  when it needs to draw itself. 
       *  @exception RuntimeException Is thrown if the parameter does not match
       *  the container being laid out by this manager. */
   public void layoutContainer( Container parent )
   {
         // The interface does not allow me to throw an ordinary exception.
      if (parent != container)
         throw new RuntimeException( "The container in FormLayout is "
         + "inconsistent with the layout manager in the Container.");
      if (changedConstraints) orderConstraints();
      
      Insets insets = container.getInsets();
      Dimension cont = container.getSize();
      
         // Set up a vector of contained components, and determine positions
      sizepos.clear();
      Iterator iter = constrain.iterator();
      
      while ( iter.hasNext() )
      {
         Constraint c = (Constraint) iter.next();
         Placement p = null;
         for (int i=0; i<sizepos.size(); i++)
         {
            Placement t = (Placement)(sizepos.get(i));
            if (t.comp == c.thisObj)   // A placement already exists
            {
               p = t;
               break;
            }
         }
         if (p == null) 
         {
            p = new Placement(c.thisObj);
            Dimension d = c.thisObj.getPreferredSize();
            p.width = d.width;
            p.height = d.height;
            if ( ! c.thisObj.isVisible())
            {
               p.width = 0;
               p.height = 0;
            }
            sizepos.add( p );
         }
         
         if (c.type == POSITION) 
         {
            if (c.side == TOP) 
            {
               p.y = Math.max( p.y, insets.top + (int)c.dist );
            }
            else if (c.side == LEFT) 
            {
               p.x = Math.max( p.x, insets.left + (int)c.dist );
            }
            else if (c.side == RIGHT) 
            {
               if (p.x < 0) p.x = cont.width - insets.right
                           - (int)c.dist - p.width;
               else p.x = Math.max( p.x, 
                          cont.width - insets.right - (int)c.dist - p.width);
            }
            else if (c.side == BOTTOM) 
            {
               if (p.y < 0) p.y = cont.height 
                          - insets.bottom - (int)c.dist - p.height;
               else p.y = Math.max( p.y, 
                          cont.height - insets.bottom - (int)c.dist - p.height);
            }
         }
         else if (c.type == PROPORTION) 
         {
            if (c.side == VERTICAL)  
            {
               p.y = Math.max( p.y, (int)( insets.top +
                  (cont.height-insets.top-insets.bottom) * c.dist - p.height/2)
                   );
            }
            else if (c.side == HORIZONTAL) 
            {
               p.x = Math.max( Math.max(insets.left, p.x), (int)( insets.left + 
                  (cont.width-insets.left-insets.right) * c.dist - p.width/2) );
            }
         }
         else if (c.type == ALIGN)
         {
            Placement n = null;
            for (int i=0; i<sizepos.size(); i++)
            {
               n = (Placement)(sizepos.get(i));
               if (n.comp == c.nbr) break;
            }
         
            if (c.side == TOP) 
            {
               p.y = n.y;
            }
            else if (c.side == LEFT) 
            {
               p.x = n.x;
            }
            else if (c.side == RIGHT) 
            {
               p.x = n.x + n.width - p.width; 
            }
            else if (c.side == BOTTOM) 
            {
               p.y = n.y + n.height - p.height;
            }
         }
         else  // c.type == RELATIVE
         {
            Placement n = null;
            for (int i=0; i<sizepos.size(); i++)
            {
               n = (Placement)(sizepos.get(i));
               if (n.comp == c.nbr) 
               {
                  if (c.side == TOP) 
                  {
                     p.y = Math.max(p.y, n.y + n.height + c.gap);
                  }
                  else if (c.side == LEFT) 
                  {
                     p.x = Math.max(p.x, n.x + n.width + c.gap);
                  }
                  else if (c.side == RIGHT) 
                  {
                     if (p.x < 0) p.x = n.x - c.gap - p.width; 
                     else         p.x = Math.max(p.x, n.x - c.gap - p.width); 
                  }
                  else if (c.side == BOTTOM) 
                  {
                     if (p.y < 0) p.y = n.y - c.gap - p.height;
                     else         p.y = Math.max( p.y, n.y - c.gap - p.height);
                  }
               }
            }
         }
      }
      
         // Set the position and size to each component in the container
      synchronized (container.getTreeLock()) 
      {
         for (int i=0; i<sizepos.size(); ++i)
         {
            Placement p = (Placement) (sizepos.get(i));
            Component c = p.comp;
            c.setBounds( Math.max(0,p.x), Math.max(0,p.y), p.width, p.height );
         }
      }
   }
   
      /** Calculates the minimum size dimensions for the specified container, 
       * given the components it contains.
       * @return the size of container required.  
       * @exception  RuntimeException can occur because the parent parameter is
       * not the container which the layout manager is responsible for, or
       * because the constraints are not consistent, eg. because they are 
       * circular or because a component given as a neighbour has not been
       * added to the layout manager.
       */
   public Dimension minimumLayoutSize( Container parent )
   {
      return findLayoutSize( parent, MINIMUM );
   }
   
      /** Calculates the preferred size dimensions for the specified 
       * container, given the components it contains.
       * <p>
       * @return the size of container required.  
       * @exception  RuntimeException can occur because the parent parameter is
       * not the container which the layout manager is responsible for, or
       * because the constraints are not consistent, eg. because they are 
       * circular or because a component given as a neighbour has not been
       * added to the layout manager.
       */
   public Dimension preferredLayoutSize( Container parent )
   {
      Dimension d = findLayoutSize( parent, PREFERRED );
      return d;
   }
   
      /** Implemention of the minimumLayoutSize or preferredLayoutSize method.
       *  This will first sort the constraints into a feasible implementation
       *  order.  Then, each constraint will be considered in turn.
       *  <p>
       *  The size of the constrained component will be requested and placed
       *  with the constraint.
       *  @exception RuntimeException is thrown if the parameter does not match
       *  the container being laid out.
       */
   protected Dimension findLayoutSize( Container parent, int which )
   {
      int maxwid = 0;
      int maxht = 0;
      
         // The interface does not allow me to throw an ordinary exception.
      if (parent != container)
         throw new RuntimeException( "The container in FormLayout is "
         + "inconsistent with the layout manager in the Container.");
      
      if (changedConstraints) orderConstraints();
      
      Insets insets = container.getInsets();
      
      sizepos.clear();
      Iterator iter = constrain.iterator();
      
            // Loop over all constraints
      while ( iter.hasNext() )
      {
                                 // Determine the "placement" object for each of
                                 // the constraints in turn
         Constraint c = (Constraint) iter.next();
         Placement p = null;
         for (int i=0; i<sizepos.size(); i++)
         {
            Placement t = (Placement)(sizepos.get(i));
            if (t.comp == c.thisObj)   // A placement already exists
            {
               p = t;
               break;
            }
         }
         if (p == null) 
         {
            p = new Placement(c.thisObj);
            Dimension d = (which == PREFERRED) ? c.thisObj.getPreferredSize()
                                               : c.thisObj.getMinimumSize();
            p.width = d.width;
            p.height = d.height;
            if ( ! c.thisObj.isVisible())
            {
               p.width = 0;
               p.height = 0;
            }
            sizepos.add( p );
         }
         
         if (c.type == POSITION) 
         {
            if (c.side == TOP) 
            {
               p.my = (int)c.dist + p.height;
               p.y = (int)c.dist;
               maxht = Math.max( maxht, p.my );
            }
            else if (c.side == LEFT) 
            {
               p.mx = (int)c.dist + p.width;
               p.x = (int)c.dist;
               maxwid = Math.max( maxwid, p.mx );
            }
            else if (c.side == RIGHT) 
            {
               p.mx = Math.max(p.mx, p.x + p.width);
               maxwid = Math.max( maxwid, p.mx+(int)c.dist );
            }
            else if (c.side == BOTTOM) 
            {
               p.my = Math.max( p.my, p.y + p.height );
               maxht = Math.max( maxht, p.my+(int)c.dist );
            }
         }
         else if (c.type == PROPORTION) 
         {   //this is a bit weak at present
            if (c.side == VERTICAL) 
            {
               p.y = Math.max(0, (int)(maxht*c.dist-p.height/2));
               p.my = Math.max( p.my, p.y + p.height );
               maxht = Math.max(maxht,p.my);
            }
            else if (c.side == HORIZONTAL)
            {
               p.x = Math.max(0, (int)(maxwid*c.dist-p.width/2));
               p.mx = Math.max( p.mx, p.x + p.width );
               maxwid = Math.max( maxwid, p.mx);
            }
         }
         else if (c.type == ALIGN) 
         {
            Placement n = null;
            for (int i=0; i<sizepos.size(); i++)
            {
               n = (Placement)(sizepos.get(i));
               if (n.comp == c.nbr) break;
            }
         
            if (c.side == TOP) 
            {
               p.y = n.y;
               p.my = p.y + p.height;
               maxht = Math.max( maxht, p.my );
            }
            else if (c.side == LEFT) 
            {
               p.x = n.x;
               p.mx = p.x + p.width;
               maxwid = Math.max( maxwid, p.mx );
            }
            else if (c.side == RIGHT) 
            {
               p.mx = n.mx; 
               p.x = p.mx - p.width;
            }
            else if (c.side == BOTTOM) 
            {
               p.my = n.my; 
               p.y = p.my - p.height;
            }
         }
         else  // c.type == RELATIVE
         {
            Placement n = null;
            for (int i=0; i<sizepos.size(); i++)
            {
               n = (Placement)(sizepos.get(i));
               if (n.comp == c.nbr) break;
            }
            
            if (c.side == TOP) 
            {
               p.y = Math.max( p.y, n.my + c.gap );
               p.my = Math.max( p.my, p.y + p.height );
               maxht = Math.max( maxht, p.my );
            }
            else if (c.side == LEFT) 
            {
               p.x = Math.max( p.x, n.mx + c.gap );
               p.mx = Math.max( p.mx, p.x + p.width );
               maxwid = Math.max( maxwid, p.mx );
            }
            else if (c.side == RIGHT) 
            {
               p.mx = Math.max( p.mx, n.x - c.gap );
               p.x = p.mx - p.width ;
            }
            else if (c.side == BOTTOM) 
            {
               p.my = Math.max( p.my, n.y - c.gap );
               p.y = p.my - p.height ;
            }
         }
      }
      
      maxwid += insets.left + insets.right;
      maxht += insets.top + insets.bottom;
      
      return new Dimension (maxwid, maxht);
   }
   
      /** Removes the specified component from the layout. 
       * Actually, we will not allow this.  It may cause a dependency to be
       * removed.  Simply return.
       */
   public void removeLayoutComponent( Component comp )
   {
      // return.
   }
   
      /** Sets the distance the component will be from a neighbour on its left
       * side. */
   public void setLeftRelative( Component thisobj, Component leftnbr, int gap ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, leftnbr, LEFT, gap ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the distance the component will be from a neighbour on its right
       * side. */
   public void setRightRelative( Component thisobj, Component rightnbr, int gap) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, rightnbr, RIGHT, gap ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the distance the component will be from a neighbour on its top
       * side. */
   public void setTopRelative( Component thisobj, Component topnbr, int gap ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, topnbr, TOP, gap ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the distance the component will be from a neighbour on its bottom
       * side. */
   public void setBottomRelative( Component thisobj, Component botnbr, int gap )
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, botnbr, BOTTOM, gap ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the component to which thisobj will be aligned on the left side.
       */
   public void setLeftAlign( Component thisobj, Component leftnbr ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, leftnbr, LEFT ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the component to which thisobj will be aligned on the right
       * side. */
   public void setRightAlign( Component thisobj, Component rightnbr ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, rightnbr, RIGHT ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the component to which thisobj will be aligned on the top
       * side. */
   public void setTopAlign( Component thisobj, Component topnbr ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, topnbr, TOP ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the component to which thisobj will be aligned on the bottom
       * side. */
   public void setBottomAlign( Component thisobj, Component botnbr )
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, botnbr, BOTTOM ));
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the distance in pixels between the left edge of the component
       *  and the left container margin.
       */
   public void setLeftAnchor( Component thisobj, int dist ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, LEFT, dist ) );
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the distance in pixels between the right edge of the component
       *  and the right container margin.
       */
   public void setRightAnchor( Component thisobj, int dist ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, RIGHT, dist ) );
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the distance in pixels between the top edge of the component
       *  and the top container margin.
       */
   public void setTopAnchor( Component thisobj, int dist ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, TOP, dist ) );
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the distance in pixels between the bottom edge of the component
       *  and the bottom container margin.
       */
   public void setBottomAnchor( Component thisobj, int dist ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, BOTTOM, dist ) );
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the horizontal position of the centre of the component.
       * @param  dist  is a fraction of the container dimension.
       */
   public void setHorizontalAnchor( Component thisobj, double dist ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, HORIZONTAL, dist ) );
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** Sets the vertical position of the centre of the component.
       * @param  dist  is a fraction of the container dimension.
       */
   public void setVerticalAnchor( Component thisobj, double dist ) 
   {
      addFirstConstraint( thisobj );
      constrain.add( new Constraint( thisobj, VERTICAL, dist ) );
      changedConstraints = true;
      thisobj.invalidate();
   }
   
      /** If the layout manager uses a per-component string, adds the component 
       * "comp" to the layout, associating it with the string specified by
       * "name".
       * <p>
       * Actually, this does nothing.  Components must be added by setting
       * constraints.  We will tell the container about the additions, so there
       * is no need for the container to tell us when something is added.
       */
   public void addLayoutComponent( String name, Component comp )
   {
      // Simply return.
   }
   
      /** Notify the container that this component is to be added to it.
       *  The container will only be notified if the component has not already
       *  been added. */
   protected void addFirstConstraint( Component thisobj )
   {
      Iterator iter = constrain.iterator();
      while ( iter.hasNext() )
      {
         Constraint o = (Constraint) iter.next();
         if (o.thisObj == thisobj) return;
      }
      container.add( "", thisobj );
   }
   
      /** Process the constraints on the components managed by this layout
          manager, sorting them into an order which allows the size and
          placement of all of them to be determined.
          <p>
          Iteratively go through the constraints, finding any that are 
          absolute or that depend only on constraints that are already in the
          ordered set.  Move these over to the end of the ordered list.
          <p>
          If a pass does not move any items from the list and the list 
          is not empty, there is a circular constraint or a placement relative
          to a component which is not within this layout manager.
          @exception  RuntimeException if there are circular constraints or 
          dependence on a component not managed by this layout manager.
       */
   synchronized protected void orderConstraints()
   {
      //ArrayList ordered = new ArrayList(constrain.size()+2);
      ArrayList<Constraint> ordered = new ArrayList<Constraint>(constrain.size()+2);
      Iterator iter = constrain.iterator();
      while ( iter.hasNext() )
      {
         Constraint c = (Constraint) iter.next();
         if ((c.type == POSITION && (c.side == TOP || c.side == LEFT))
            || c.type == PROPORTION) 
         {
            ordered.add(c);
            iter.remove();
         }
      }
      while (constrain.size() > 0)
      {
         iter = constrain.iterator();
         boolean moved = false;
         while ( iter.hasNext() )
         {
            Constraint c = (Constraint) iter.next();
            if (c.type == POSITION) continue; // do right and bottom later
                 // check in 'ordered' for dependency
            if (c.side == TOP || c.side == BOTTOM)
            {
               Iterator oiter = ordered.iterator();
               while ( oiter.hasNext() )
               {
                      Constraint o = (Constraint) oiter.next();
                      if (o.thisObj != c.nbr) continue;
                      if (o.side == TOP || o.side == BOTTOM)
                      {
                         ordered.add(c);
                         iter.remove();
                         moved = true;
                         break;
                      }
               }
            }
            else if (c.side == LEFT || c.side == RIGHT)
            {
               Iterator oiter = ordered.iterator();
               while ( oiter.hasNext() )
               {
                      Constraint o = (Constraint) oiter.next();
                      if (o.thisObj != c.nbr) continue;
                      if (o.side == LEFT || o.side == RIGHT)
                      {
                         ordered.add(c);
                         iter.remove();
                         moved = true;
                         break;
                      }
               }
            }
         }
         if (!moved) 
         {
            iter = constrain.iterator();
            Constraint c = null;
            while (iter.hasNext() )
            {
               c = (Constraint) iter.next();
               if (c.type == POSITION)  // pick up right and bottom absolutes
               {
                  ordered.add(c);
                  iter.remove();
                  moved = true;
                  continue;
               }
            }
            if (constrain.size() > 0 && !moved) 
            {
               iter = constrain.iterator();
               c = (Constraint) iter.next();
               String errmsg = "Unresolvable " + c + " in FormLayout.\n";
               changedConstraints = false;
               throw new RuntimeException( errmsg );
            }
         }
      }
      
      constrain = ordered;
      
      changedConstraints = false;
   }
   
      /** For debugging purposes, it can be useful to fetch the size and
      placement of each component controlled by this FormLayout object. */
   public String fetchPlacements()
   {
      StringBuffer sb = new StringBuffer();
      if (sizepos == null) return("Layout not yet completed");
      for (int i=0; i<sizepos.size(); ++i)
      {
         sb.append( sizepos.get(i).toString() + EOL );
      }
      return sb.toString();
   }
   
      /** Hold the details of a component and how it is constrained in one 
      direction. */
   protected static class Constraint
   {
         /** The component being constrained. */
      Component thisObj;
         /** The neighbour to which this component is to be related. */
      Component nbr;
         /** Which side is being located: LEFT, RIGHT, TOP, BOTTOM, or (for
          *  proportional placement) HORIZONTAL or VERTICAL. */
      int side;
         /** The distance from a neighbour. */
      int gap;
         /** Hold the fractional distance for a proportional placement, or the
          *  distance from an edge for positional placement. */
      double dist;
         /** Possible values are RELATIVE, POSITION, PROPORTION or ALIGN. */
      int type;
      
         /** Constrain a component with respect to another component. 
          * @param c the component being constrained.
          * @param n the neighbour.
          * @param s the side of c to be related to the neighbour; could be
          *   TOP, BOTTOM, LEFT, RIGHT.
          * @param gap the distance in pixels required between the components.
          */
      Constraint( Component c, Component n, int s, int gap )
      {
         thisObj = c;
         nbr = n;
         side = s;
         this.gap = gap;
         type = RELATIVE;
      }
      
         /** Constrain a component with respect to another component. 
          * @param c the component being constrained.
          * @param n the neighbour.
          * @param s the side of c to be related to the neighbour; could be
          *   TOP, BOTTOM, LEFT, RIGHT.
          */
      Constraint( Component c, Component n, int s )
      {
         thisObj = c;
         nbr = n;
         side = s;
         type = ALIGN;
      }
      
         /** Constrain a component within its container. 
          * @param  c  the component being constrained.
          * @param  s  the side of 'c' which is being constrained; can be TOP,
          *  BOTTOM, LEFT, RIGHT, VERTICAL, HORIZONTAL.
          * @param  dist  If <i>s</i> is an edge, then dist is taken to be the
          *  distance in pixels from the edge of the container.  If <i>s</i> is
          *  VERTICAL or HORIZONTAL, dist is interpreted as a fraction of the 
          *  available space within the container.
          */
      Constraint( Component c, int s, double dist )
      {
         thisObj = c;
         side = s;
         this.dist = dist;
         if (s == VERTICAL || s == HORIZONTAL) type = PROPORTION;
         else                                  type = POSITION;
      }
      
      protected String constraintType()
      {
         switch (type)
         {
            case 11: return "RELATIVE";
            case 12: return "POSITION";
            case 13: return "PROPORTION";
            case 14: return "ALIGN";
            default: return "UNKNOWN";
         }
      }
      
      protected String constraintSide()
      {
         switch (side)
         {
            case 1: return "LEFT";
            case 2: return "RIGHT";
            case 3: return "TOP";
            case 4: return "BOTTOM";
            case 5: return "HORIZONTAL";
            case 6: return "VERTICAL";
            default: return "UNKNOWN";
         }
      }
      
         /** Represent this constraint in some way as a String. */
      public String toString()
      {
         return constraintSide() + " " + constraintType() + " " + dist +
               " constraint on " + thisObj.getClass() + " object";
      }
   }
   
      /** Class holding data about how a component is placed. 
        * Objects of this type are required to determine the required size 
        * of the container.*/
   protected static class Placement
   {
      Component comp;
      int x = -1, y = -1, width = 0, height = 0, mx = -1, my = -1;
      
      Placement( Component c )
      {
         comp = c;
      }
      public String toString()
      {
         return "X="+x+" Y="+y+" Wid="+width+" Ht="+height+" (Mx="+mx+
               " My="+my+") " + comp.getClass();
      }
   }
}