Initial import from SVN

31 files changed, 10406 insertions, 0 deletions

diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AbsoluteLayout.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AbsoluteLayout.java
new file mode 100644
index 0000000..1fef587
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AbsoluteLayout.java
@@ -0,0 +1,74 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.LayoutManager;
+import java.io.Serializable;
+
+/**
+ * AbsoluteLayout specifies that all components in the
+ * container will be placed according to their size
+ * and their location relative to the container's origin. <br><br>
+ *
+ * You can achieve the same effect by setting a container's
+ * layout manager to null, but this class allows you to subclass
+ * it if you need specific control or functionality.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 904 $
+ */
+public class AbsoluteLayout implements LayoutManager, Serializable
+{
+    public void addLayoutComponent(String name,
+                                   Component comp)
+    {
+    }
+
+    public void removeLayoutComponent(Component comp)
+    {
+    }
+
+    public Dimension preferredLayoutSize(Container parent)
+    {
+        return minimumLayoutSize( parent );
+    }
+
+    public Dimension minimumLayoutSize(Container parent)
+    {
+        int width = 0;
+        int height = 0;
+
+        Component[] c = parent.getComponents();
+        for ( int i = 0; i < c.length; i++ )
+        {
+            width = Math.max( width, c[i].getLocation().x + c[i].getBounds().width );
+            height = Math.max( height, c[i].getLocation().y + c[i].getBounds().height );
+        }
+
+        return new Dimension( width, height );
+    }
+
+    public void layoutContainer(Container parent)
+    {
+    }
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AlphaTextField.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AlphaTextField.java
new file mode 100644
index 0000000..c36f5e2
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AlphaTextField.java
@@ -0,0 +1,335 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+/**
+* AlphaTextField is a "smart" text field that restricts the user's input.  The
+* input can be restricted to alphabetic, alphanumeric, or all characters.  The
+* maximum number of characters can also be limited.
+* The defaults for this component is alphabetic only string of unlimited length.
+*
+* @author rob@straylight.princeton.com
+* @author $Author: cgruber $
+* @version $Revision: 893 $
+*/
+public class AlphaTextField extends SmartTextField
+{
+
+/*******************************
+* CONSTANTS
+*******************************/
+
+/**
+* Sets the input to alphabetic characters only.  The characters "a-z" and "A-Z"
+* are the only valid characters.  All other characters will be ignored.
+* @see #getAlphaType()
+*/
+   public static final int ALPHABETIC = 0;
+
+/**
+* Sets the input to alphanumeric characters only.  The characters "a-z", "A-Z"
+* and "0-9" are the only valid characters.  All other characters will be ignored.
+* @see #getAlphaType()
+*/
+   public static final int ALPHANUMERIC = 1;
+
+/**
+* Sets the input to alphanumeric characters and a few special characters only.
+* The valid characters are "a-z", "A-Z", "0-9", space, "-", "_", "\", and ":".
+* This is helpful for file names (with paths) as input strings.
+* All other characters will be ignored.
+* @see #getAlphaType()
+*/
+   public static final int ALPHANUMERIC_PLUS = 2;
+
+/**
+* Sets the input to all characters without restriction.
+* @see #getAlphaType()
+*/
+   public static final int ALL = 3;
+
+
+/*******************************
+* DATA MEMBERS
+*******************************/
+
+   // The level of input restrictions, defaults to ALPHABETIC
+   private int alphaType;
+
+   // The maximum length of the input string, defaults to 0, no maximum
+   private int stringLength;
+
+
+/*******************************
+* PUBLIC METHODS
+*******************************/
+
+/**
+* The default constructor of this class.  The default string of this text
+* field is set to the empty string ("").  The maximum length is set to 0,
+* which specifies no limit.
+*/
+   public AlphaTextField()
+   {
+      this("", 0);
+   }
+
+/**
+* Constructor of this class with the initial text of the text field specified.
+* The maximum length is set to 0, which specifies no limit.
+* @param text Initial text of the text field.
+*/
+   public AlphaTextField(String text)
+   {
+      this(text, 0);
+   }
+
+/**
+* Constructor of this class with width (in columns) of the text field specified.
+* The initial text is set to the empty string (""). The maximum length is set
+* to 0, which specifies no limit.
+* @param columns The width of the text field in characters.
+*/
+   public AlphaTextField(int columns)
+   {
+      this("", columns);
+   }
+
+/**
+* Constructor of this class with width (in columns) and initial text of the
+* text field specified.  The maximum length is set to 0, which specifies no limit.
+* @param text Initial text of the text field.
+* @param columns The width of the text field in characters.
+*/
+   public AlphaTextField(String text, int columns)
+   {
+      super(text, columns);
+   }
+
+/**
+* Constructor that allows the user to set the Alpha type of the text field
+* and the maximum string length.
+* @param anAlphaType The character restriction type.
+* @param aLength The maximum number of characters allowed in the string.
+*/
+   public AlphaTextField(int anAlphaType, int aLength)
+   {
+       super( "", 0 );
+       setAlphaType( anAlphaType );
+       setStringLength( aLength );
+   }
+
+/**
+* Gets the current restriction type of this text field.
+* @see #ALPHABETIC
+* @see #ALPHANUMERIC
+* @see #ALPHANUMERIC_PLUS
+* @see #ALL
+* @return The current restriction type as defined by the constansts of this class.
+*/
+   public int getAlphaType()
+   {
+      return alphaType;
+   }
+
+/**
+* Sets the restriction type of this text field.
+* @see #ALPHABETIC
+* @see #ALPHANUMERIC
+* @see #ALPHANUMERIC_PLUS
+* @see #ALL
+* @param newAlphaType The restriction of this text field.
+*/
+   public void setAlphaType(int newAlphaType)
+   {
+      switch (newAlphaType)
+      {
+         case ALPHABETIC:
+         case ALPHANUMERIC:
+         case ALPHANUMERIC_PLUS:
+         case ALL:
+         {
+            alphaType = newAlphaType;
+            break;
+         }
+         default:
+         {
+            alphaType = ALPHABETIC;
+            break;
+         }
+      }
+   }
+
+/**
+* Sets the maximum string length of this text field.  If the length is set to
+* zero, then there is no limit.  The default string length is zero.  Negative
+* sizes will set the length to zero.
+* @param newStringLength The maximum length of the string that the user can input.
+*/
+   public void setStringLength(int newStringLength)
+   {
+      if (newStringLength < 0)
+      {
+         stringLength = 0;
+      }
+      else
+      {
+         stringLength = newStringLength;
+      }
+   }
+
+/**
+* Gets the current length of the maximum string size the user can enter.
+* @return The maximum length the string of the text field can be.
+*/
+   public int getStringLength()
+   {
+      return stringLength;
+   }
+
+
+/*******************************
+* PROTECTED METHODS
+*******************************/
+
+   protected boolean isValidCharacter(char aChar)
+   {
+      // if its a non-printable character, then its ok
+      if ((aChar < ' ') || (aChar > '~'))
+      {
+         return true;
+      }
+
+      // can only be a printable character now, check it for validation
+      return isValidCharacterType(aChar);
+   }
+
+   protected boolean isValidString(String aString)
+   {
+      if (aString.length() > stringLength)
+      {
+         return false;
+      }
+
+      for (int i = 0; i < aString.length(); ++i)
+      {
+         if (!(isValidCharacterType(aString.charAt(i))))
+         {
+            return false;
+         }
+      }
+
+      return true;
+   }
+
+   protected void postProcessing()
+   {
+      // No need to do anything.
+   }
+
+
+/*******************************
+* PROTECTED METHODS
+*******************************/
+
+   private boolean isValidCharacterType(char aChar)
+   {
+      switch (alphaType)
+      {
+         case ALPHABETIC:
+         {
+            if (!(isValidAlphabeticCharacter(aChar)))
+            {
+               return false;
+            }
+            break;
+         }
+         case ALPHANUMERIC:
+         {
+            if (!(isValidAlphanumericCharacter(aChar)))
+            {
+               return false;
+            }
+            break;
+         }
+         case ALPHANUMERIC_PLUS:
+         {
+            if (!(isValidAlphanumericPlusCharacter(aChar)))
+            {
+               return false;
+            }
+            break;
+         }
+         case ALL:
+         {
+            if (!(isValidAllCharacter(aChar)))
+            {
+               return false;
+            }
+            break;
+         }
+         default:
+         {
+            return false;
+         }
+      }
+
+      return true;
+   }
+
+   private boolean isValidAlphabeticCharacter(char aChar)
+   {
+      if (((aChar < 'A') || (aChar > 'Z')) && ((aChar < 'a') || (aChar > 'z')))
+      {
+         return false;
+      }
+      return true;
+   }
+
+   private boolean isValidAlphanumericCharacter(char aChar)
+   {
+      if (((aChar < 'A') || (aChar > 'Z')) && ((aChar < 'a') || (aChar > 'z')) && ((aChar < '0') || (aChar > '9')))
+      {
+         return false;
+      }
+      return true;
+   }
+
+   private boolean isValidAlphanumericPlusCharacter(char aChar)
+   {
+      if (((aChar < 'A') || (aChar > 'Z')) && ((aChar < 'a') || (aChar > 'z')) && ((aChar < '0') || (aChar > '9')))
+      {
+         if ((aChar != ' ') && (aChar != '_') && (aChar != '-') && (aChar != ':') && (aChar != '\\'))
+         {
+            return false;
+         }
+      }
+      return true;
+   }
+
+   private boolean isValidAllCharacter(char aChar)
+   {
+      if ((aChar < ' ') || (aChar > '~'))
+      {
+         return false;
+      }
+      return true;
+   }
+
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AlternatingRowCellRenderer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AlternatingRowCellRenderer.java
new file mode 100644
index 0000000..46d2693
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/AlternatingRowCellRenderer.java
@@ -0,0 +1,129 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2001 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+
+import javax.swing.JComponent;
+import javax.swing.JTable;
+import javax.swing.UIManager;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellRenderer;
+
+/**
+* A TableCellRenderer that wraps another TableCellRenderer
+* and sets the background to the specified color for odd-numbered rows.
+* This makes every other row appear to be a different color,
+* which helps users distinguish rows of data in densely-packed 
+* tables.  
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class AlternatingRowCellRenderer implements TableCellRenderer {
+
+    protected TableCellRenderer wrappedRenderer;
+    protected Color alternateColor;
+    
+    /**
+    * Default constructor uses a lighter shade of the system control color
+    * and wraps a DefaultTableCellRenderer.
+    */
+    public AlternatingRowCellRenderer()
+    {
+        this( new DefaultTableCellRenderer() );
+    }
+    
+    /**
+    * Uses the specified color for the background of the alternating rows,
+    * and wraps a DefaultTableCellRenderer.
+    */
+    public AlternatingRowCellRenderer( 
+        Color aColor )
+    {
+        this( aColor, new DefaultTableCellRenderer() );
+    }
+
+    /**
+    * Uses the uses a lighter shade of the system control color
+    * for the background of the alternating rows,
+    * and wraps the specified TableCellRenderer.
+    */
+    public AlternatingRowCellRenderer( 
+        TableCellRenderer aRenderer )
+    {
+        Color c = UIManager.getColor( "control" );
+        c = new Color( // lighten this color just slightly
+        (int) ( c.getRed() + ( ( 255 - c.getRed() ) / 1.5 ) ),
+        (int) ( c.getGreen() + ( ( 255 - c.getGreen() ) / 1.5 ) ),
+        (int) ( c.getBlue() + ( ( 255 - c.getBlue() ) / 1.5 ) ) );
+
+        alternateColor = c;
+        wrappedRenderer = aRenderer;
+    }
+
+    /**
+    * Uses the specified color for the background of the alternating rows,
+    * and wraps the specified TableCellRenderer.
+    */
+    public AlternatingRowCellRenderer( 
+        Color aColor, TableCellRenderer aRenderer )
+    {
+        alternateColor = aColor;
+        wrappedRenderer = aRenderer;
+    }
+
+    public Component getTableCellRendererComponent(
+                            JTable table, Object value,
+                            boolean isSelected, boolean hasFocus,
+                            int row, int column)
+    {
+        Component result = wrappedRenderer.getTableCellRendererComponent(
+            table, value, isSelected, hasFocus, row, column );
+        if ( ! isSelected )
+        {
+            if ( row % 2 == 0 )
+            {
+                if ( ! result.getBackground().equals( table.getBackground() ) )
+                {
+                    result.setBackground( table.getBackground() );              
+                }
+            }
+            else
+            {
+                if ( ! result.getBackground().equals( alternateColor ) )
+                {
+                    // jdk1.3's default renderer is opaque
+                    if ( result instanceof JComponent )
+                    {
+                        ((JComponent)result).setOpaque( true );
+                    }
+                    
+                    result.setBackground( alternateColor );              
+                }
+            }                    
+        }
+        return result;
+    }
+}
+
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterFlowLayout.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterFlowLayout.java
new file mode 100644
index 0000000..1c438b6
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterFlowLayout.java
@@ -0,0 +1,515 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Insets;
+
+/**
+ * BetterFlowLayout works just like FlowLayout, except that
+ * you can specify a vertical orientation in addition to the
+ * usual horizontal orientations.  You can also specify that
+ * all the components be sized to the same height and/or width.
+ * By default, the behavior is identical to FlowLayout.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 904 $
+ * $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+ */
+public class BetterFlowLayout extends FlowLayout {
+
+    /**
+     * This value indicates vertical orientation and
+     * that each column of components should be top-justified.
+     */
+    public static final int TOP 	= 32;
+
+    /**
+     * This value indicates vertical orientation and
+     * that each column of components should be centered.
+     */
+    public static final int CENTER_VERTICAL	= 16;
+
+    /**
+     * This value indicates vertical orientation and
+     * that each column of components should be bottom-justified.
+     */
+    public static final int BOTTOM 	= 8;
+
+    /**
+     * Tracks orientation.
+     */
+    protected boolean isHorizontal = true;
+
+    /**
+     * Tracks component sizing of width.
+     */
+    protected boolean isWidthUniform = false;
+    /**
+     * Tracks component sizing of height.
+     */
+    protected boolean isHeightUniform = false;
+
+    /**
+     * Constructs a new Flow Layout with a centered alignment and a
+     * default 5-unit horizontal and vertical gap.
+     */
+    public BetterFlowLayout() {
+	this(CENTER, 5, 5);
+    }
+
+    /**
+     * Constructs a new Flow Layout with the specified alignment and a
+     * default 5-unit horizontal and vertical gap.
+     * The value of the alignment argument must be one of
+     * <code>BetterFlowLayout.LEFT</code>, <code>BetterFlowLayout.RIGHT</code>,
+     * or <code>BetterFlowLayout.CENTER</code>.
+     * @param align the alignment value
+     */
+    public BetterFlowLayout(int align) {
+	this(align, 5, 5);
+    }
+
+    /**
+     * Creates a new flow layout manager with the indicated alignment
+     * and the indicated horizontal and vertical gaps.
+     * <p>
+     * The value of the alignment argument must be one of
+     * <code>BetterFlowLayout.LEFT</code>, <code>BetterFlowLayout.RIGHT</code>,
+     * or <code>BetterFlowLayout.CENTER</code>.
+     * @param      align   the alignment value.
+     * @param      hgap    the horizontal gap between components.
+     * @param      vgap    the vertical gap between components.
+     */
+    public BetterFlowLayout(int align, int hgap, int vgap) {
+    	setHgap(hgap);
+	    setVgap(vgap);
+        setAlignment(align);
+    }
+
+    /**
+     * Sets whether all components should have the same height.
+     * @param isUniform the new value.
+     * @see #isHeightUniform
+     */
+    public void setHeightUniform(boolean isUniform) {
+        isHeightUniform = isUniform;
+    }
+
+    /**
+     * Sets whether all components should have the same width.
+     * @param isUniform the new value.
+     * @see #isWidthUniform
+     */
+    public void setWidthUniform(boolean isUniform) {
+        isWidthUniform = isUniform;
+    }
+
+    /**
+     * Determines whether all components will have the same height.
+     * The uniform height will be the maximum of the preferred heights
+     * of all the components in the container.
+     * This value defaults to false.
+     * @return whether components will have the same height.
+     */
+    public boolean isHeightUniform() {
+        return isHeightUniform;
+    }
+
+    /**
+     * Determines whether all components will have the same width.
+     * The uniform height will be the maximum of the preferred widths
+     * of all the components in the container.
+     * This value defaults to false.
+     * @return whether components will have the same width.
+     */
+    public boolean isWidthUniform() {
+        return isWidthUniform;
+    }
+
+    /**
+     * Sets the alignment for this layout.
+     * Possible values for horizontal orientation are <code>LEFT</code>,
+     * <code>RIGHT</code>, and <code>CENTER</code>.
+     * Possible values for vertical orientation are <code>TOP</code>,
+     * <code>BOTTOM</code>, and <code>CENTER_VERTICAL</code>.
+     * @param      align the alignment value.
+     * @see        java.awt.FlowLayout#getAlignment
+     */
+    public void setAlignment(int align) {
+        if ( ( align == TOP ) || ( align == BOTTOM ) || ( align == CENTER_VERTICAL ) )
+        {
+            isHorizontal = false;
+        }
+        else
+        {
+            isHorizontal = true;
+        }
+
+        super.setAlignment( align );
+    }
+
+    /**
+     * Returns the preferred dimensions for this layout given the components
+     * in the specified target container.
+     * @param target the component which needs to be laid out
+     * @return    the preferred dimensions to lay out the
+     *                    subcomponents of the specified container.
+     * @see Container
+     * @see #minimumLayoutSize
+     * @see       java.awt.Container#getPreferredSize
+     */
+    public Dimension preferredLayoutSize(Container target) {
+        if ( isHorizontal ) {
+            return preferredLayoutSizeHorizontal( target );
+        } else {
+            return preferredLayoutSizeVertical( target );
+        }
+    }
+
+    /**
+     * Returns the preferred dimensions for this layout given the components
+     * in the specified target container.
+     * @param target the component which needs to be laid out
+     * @return    the preferred dimensions to lay out the
+     *                    subcomponents of the specified container.
+     * @see Container
+     * @see #minimumLayoutSize
+     * @see       java.awt.Container#getPreferredSize
+     */
+    public Dimension preferredLayoutSizeHorizontal(Container target) {
+      synchronized (target.getTreeLock()) {
+        Dimension dim = new Dimension(0, 0);
+        int nmembers = target.getComponentCount();
+        int maxWidth = 0;
+
+        for (int i = 0 ; i < nmembers ; i++) {
+            Component m = target.getComponent(i);
+            if (m.isVisible()) {
+            Dimension d = m.getPreferredSize();
+            dim.height = Math.max(dim.height, d.height);
+            maxWidth = Math.max(maxWidth, d.width);
+            if (i > 0) {
+                dim.width += getHgap();
+            }
+            dim.width += d.width;
+            }
+        }
+        if ( isWidthUniform )
+            dim.width = ( maxWidth + getHgap() ) * nmembers - getHgap();
+        Insets insets = target.getInsets();
+        dim.width += insets.left + insets.right + getHgap()*2;
+        dim.height += insets.top + insets.bottom + getVgap()*2;
+        return dim;
+      }
+    }
+
+    /**
+     * Returns the preferred dimensions for this layout given the components
+     * in the specified target container.
+     * @param target the component which needs to be laid out
+     * @return    the preferred dimensions to lay out the
+     *                    subcomponents of the specified container.
+     * @see Container
+     * @see #minimumLayoutSize
+     * @see       java.awt.Container#getPreferredSize
+     */
+    public Dimension preferredLayoutSizeVertical(Container target) {
+      synchronized (target.getTreeLock()) {
+        Dimension dim = new Dimension(0, 0);
+        int nmembers = target.getComponentCount();
+        int maxHeight = 0;
+
+        for (int i = 0 ; i < nmembers ; i++) {
+            Component m = target.getComponent(i);
+            if (m.isVisible()) {
+            Dimension d = m.getPreferredSize();
+            dim.width = Math.max(dim.width, d.width);
+            maxHeight = Math.max(maxHeight, d.height);
+            if (i > 0) {
+                dim.height += getVgap();
+            }
+            dim.height += d.height;
+            }
+        }
+        if ( isHeightUniform )
+            dim.height = ( maxHeight + getVgap() ) * nmembers - getVgap();
+        Insets insets = target.getInsets();
+        dim.width += insets.left + insets.right + getHgap()*2;
+        dim.height += insets.top + insets.bottom + getVgap()*2;
+        return dim;
+      }
+    }
+
+    /**
+     * Returns the minimum dimensions needed to layout the components
+     * contained in the specified target container.
+     * @param target the component which needs to be laid out
+     * @return    the minimum dimensions to lay out the
+     *                    subcomponents of the specified container.
+     * @see #preferredLayoutSize
+     * @see       java.awt.Container
+     * @see       java.awt.Container#doLayout
+     */
+    public Dimension minimumLayoutSize(Container target) {
+        // preferred size is also the minimum size
+        if ( isHorizontal ) {
+            return preferredLayoutSizeHorizontal( target );
+        } else {
+            return preferredLayoutSizeVertical( target );
+        }
+    }
+
+    /**
+     * Lays out the container. This method lets each component take
+     * its preferred size by reshaping the components in the
+     * target container in order to satisfy the constraints of
+     * this <code>BetterFlowLayout</code> object.
+     * @param target the specified component being laid out.
+     * @see Container
+     * @see       java.awt.Container#doLayout
+     */
+    public void layoutContainer(Container target) {
+        if ( isHorizontal ) {
+            layoutContainerHorizontal( target );
+        } else {
+            layoutContainerVertical( target );
+        }
+    }
+
+    /**
+     * Lays out the container. This method lets each component take
+     * its preferred size by reshaping the components in the
+     * target container in order to satisfy the constraints of
+     * this <code>BetterFlowLayout</code> object.
+     * @param target the specified component being laid out.
+     * @see Container
+     * @see       java.awt.Container#doLayout
+     */
+    protected void layoutContainerHorizontal(Container target) {
+      synchronized (target.getTreeLock()) {
+        Insets insets = target.getInsets();
+        int maxwidth = target.getSize().width - (insets.left + insets.right + getHgap()*2);
+        int nmembers = target.getComponentCount();
+        int x = 0, y = insets.top + getVgap();
+        int rowh = 0, start = 0;
+
+        boolean ltr = true; // target.getComponentOrientation().isLeftToRight();
+        Dimension uniform = getUniformDimension( target );
+
+        for (int i = 0 ; i < nmembers ; i++) {
+            Component m = target.getComponent(i);
+            if (m.isVisible()) {
+                Dimension d = m.getPreferredSize();
+                if ( isWidthUniform )
+                    d.width = uniform.width;
+                if ( isHeightUniform )
+                    d.height = uniform.height;
+                m.setSize(d.width, d.height);
+
+                if ((x == 0) || ((x + d.width) <= maxwidth)) {
+                    if (x > 0) {
+                        x += getHgap();
+                    }
+                    x += d.width;
+                    rowh = Math.max(rowh, d.height);
+                } else {
+                    moveComponentsHorizontal(target, insets.left + getHgap(), y, maxwidth - x, rowh, start, i, ltr);
+                    x = d.width;
+                    y += getVgap() + rowh;
+                    rowh = d.height;
+                    start = i;
+                }
+            }
+        }
+        moveComponentsHorizontal(target, insets.left + getHgap(), y, maxwidth - x, rowh, start, nmembers, ltr);
+      }
+    }
+
+    /**
+     * Centers the elements in the specified row, if there is any slack.
+     * @param target the component which needs to be moved
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param width the width dimensions
+     * @param height the height dimensions
+     * @param rowStart the beginning of the row
+     * @param rowEnd the the ending of the row
+     */
+    private void moveComponentsHorizontal(Container target, int x, int y, int width, int height,
+                                int rowStart, int rowEnd, boolean ltr) {
+      synchronized (target.getTreeLock()) {
+	switch (getAlignment()) {
+	case LEFT:
+	    x += ltr ? 0 : width;
+	    break;
+	case CENTER:
+	    x += width / 2;
+	    break;
+	case RIGHT:
+	    x += ltr ? width : 0;
+	    break;
+//1.2	case LEADING:
+//1.2	    break;
+//1.2	case TRAILING:
+//1.2	    x += width;
+//1.2	    break;
+	}
+	for (int i = rowStart ; i < rowEnd ; i++) {
+	    Component m = target.getComponent(i);
+	    if (m.isVisible()) {
+	        if (ltr) {
+        	    m.setLocation(x, y + (height - m.getBounds().height) / 2);
+	        } else {
+	            m.setLocation(target.getBounds().width - x - m.getBounds().width, y + (height - m.getBounds().height) / 2);
+            }
+                x += m.getBounds().width + getHgap();
+	    }
+	}
+      }
+    }
+
+    /**
+     * Lays out the container. This method lets each component take
+     * its preferred size by reshaping the components in the
+     * target container in order to satisfy the constraints of
+     * this <code>BetterFlowLayout</code> object.
+     * @param target the specified component being laid out.
+     * @see Container
+     * @see       java.awt.Container#doLayout
+     */
+    protected void layoutContainerVertical(Container target) {
+      synchronized (target.getTreeLock()) {
+
+        Insets insets = target.getInsets();
+        int maxheight = target.getBounds().height - (insets.top + insets.bottom + getVgap()*2);
+        int nmembers = target.getComponentCount();
+        int y = 0, x = insets.left + getHgap();
+        int colw = 0, start = 0;
+
+        Dimension uniform = getUniformDimension( target );
+        for (int i = 0 ; i < nmembers ; i++) {
+            Component m = target.getComponent(i);
+            if (m.isVisible()) {
+                Dimension d = m.getPreferredSize();
+                if ( isWidthUniform )
+                    d.width = uniform.width;
+                if ( isHeightUniform )
+                    d.height = uniform.height;
+                m.setSize(d.width, d.height);
+
+                if ((y == 0) || ((y + d.height) <= maxheight)) {
+                    if (y > 0) {
+                    y += getVgap();
+                    }
+                    y += d.height;
+                    colw = Math.max(colw, d.width);
+                } else {
+                    moveComponentsVertical(target, x, insets.top + getVgap(), colw, maxheight - y, start, i );
+                    y = d.height;
+                    x += getHgap() + colw;
+                    colw = d.width;
+                    start = i;
+                }
+            }
+        }
+        moveComponentsVertical(target, x, insets.top + getVgap(), colw, maxheight - y, start, nmembers );
+      }
+    }
+
+    /**
+     * Centers the elements in the specified row, if there is any slack.
+     * @param target the component which needs to be moved
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param width the width dimensions
+     * @param height the height dimensions
+     * @param colStart the beginning of the column
+     * @param colEnd the the ending of the column
+     */
+    private void moveComponentsVertical(Container target, int x, int y, int width, int height,
+                                int colStart, int colEnd) {
+      synchronized (target.getTreeLock()) {
+        switch (getAlignment()) {
+        case TOP:
+            y += 0;
+            break;
+        case CENTER_VERTICAL:
+            y += ( height / 2 ); // - preferredLayoutSize( target ).height ) / 2 );
+            break;
+        case BOTTOM:
+            y += height;
+            break;
+        }
+        for (int i = colStart ; i < colEnd ; i++) {
+            Component m = target.getComponent(i);
+            if (m.isVisible()) {
+                m.setLocation(x + (width - m.getBounds().width) / 2, y );
+//                m.setLocation(x, y );
+//                m.setSize( width, m.getBounds().height ); //!
+                y += m.getBounds().height + getVgap();
+            }
+        }
+      }
+    }
+
+    /**
+     * Returns a dimension representing the maximum preferred
+     * height and width of all the components in the container.
+     * @param target the container to scan.
+     * @return a dimension containing the maximum values.
+     */
+    protected Dimension getUniformDimension(Container target) {
+        Component m = null;
+        Dimension preferred = null;
+        int maxWidth = 0, maxHeight = 0;
+        int nmembers = target.getComponentCount();
+        for ( int i = 0; i < nmembers; i++ ) {
+            m = target.getComponent( i );
+            if ( m.isVisible() ) {
+                preferred = m.getPreferredSize();
+                maxWidth = Math.max( maxWidth, preferred.width );
+                maxHeight = Math.max( maxHeight, preferred.height );
+            }
+        }
+        return new Dimension( maxWidth, maxHeight );
+    }
+
+    /**
+     * Returns a string representation of this <code>BetterFlowLayout</code>
+     * object and its values.
+     * @return     a string representation of this layout.
+     */
+    public String toString() {
+	String str = "";
+	switch (getAlignment()) {
+	  case TOP:        str = ",align=top"; break;
+	  case CENTER_VERTICAL:      str = ",align=vertical"; break;
+	  case BOTTOM:       str = ",align=bottom"; break;
+      default: return super.toString();
+	}
+	return getClass().getName() + "[hgap=" + getHgap() + ",vgap=" + getVgap() + str + "]";
+    }
+
+
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterRootLayout.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterRootLayout.java
new file mode 100644
index 0000000..6e23ca1
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterRootLayout.java
@@ -0,0 +1,274 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Insets;
+import java.awt.Rectangle;
+
+import javax.swing.JPanel;
+import javax.swing.JRootPane;
+
+/** 
+* A custom layout for a JRootPane that handles the the layout of a 
+* JRootPane's layeredPane, glassPane, and menuBar, and in addition
+* handles four decorative components arranged in a border layout.
+* Add the decorative components to the JRootPane using the directional
+* constants; CENTER is reserved for the content pane and menu bar. 
+*
+* @author michael@mpowers.net
+* @version $Revision: 904 $
+*/
+public class BetterRootLayout extends BorderLayout
+{
+	/**
+	 * Returns the amount of space the layout would like to have.
+	 *
+	 * @param the Container for which this layout manager is being used
+	 * @return a Dimension object containing the layout's preferred size
+	 * @throws ClassCastException if parent is not a JRootPane
+	 */ 
+	public Dimension preferredLayoutSize(Container parent) 
+	{
+		JRootPane rootPane = (JRootPane) parent;
+		
+		JPanel proxyPanel = new JPanel();
+		proxyPanel.setLayout( new BorderLayout() );
+		
+		JPanel contentProxy = null;
+		if(rootPane.getContentPane() != null) {
+			contentProxy = new JPanel();
+			contentProxy.setMinimumSize( 
+				rootPane.getContentPane().getMinimumSize() );
+			contentProxy.setMaximumSize( 
+				rootPane.getContentPane().getMaximumSize() );
+			contentProxy.setPreferredSize( 
+				rootPane.getContentPane().getPreferredSize() );
+			proxyPanel.add( contentProxy, CENTER );
+		}
+		JPanel menuProxy = null;
+		if(rootPane.getJMenuBar() != null) {
+			menuProxy = new JPanel();
+			menuProxy.setMinimumSize( 
+				rootPane.getJMenuBar().getMinimumSize() );
+			menuProxy.setMaximumSize( 
+				rootPane.getJMenuBar().getMaximumSize() );
+			menuProxy.setPreferredSize( 
+				rootPane.getJMenuBar().getPreferredSize() );
+			proxyPanel.add( menuProxy, NORTH );
+		}
+		
+		this.addLayoutComponent( proxyPanel, CENTER );
+		
+		Dimension result = super.preferredLayoutSize( parent );
+
+		this.removeLayoutComponent( proxyPanel );
+		
+		proxyPanel.removeAll();
+		
+		return result;
+	}
+	
+	/**
+	 * Returns the minimum amount of space the layout needs.
+	 *
+	 * @param the Container for which this layout manager is being used
+	 * @return a Dimension object containing the layout's minimum size
+	 * @throws ClassCastException if parent is not a JRootPane
+	 */ 
+	public Dimension minimumLayoutSize(Container parent) 
+	{
+		JRootPane rootPane = (JRootPane) parent;
+		
+		JPanel proxyPanel = new JPanel();
+		proxyPanel.setLayout( new BorderLayout() );
+		
+		JPanel contentProxy = null;
+		if(rootPane.getContentPane() != null) {
+			contentProxy = new JPanel();
+			contentProxy.setMinimumSize( 
+				rootPane.getContentPane().getMinimumSize() );
+			contentProxy.setMaximumSize( 
+				rootPane.getContentPane().getMaximumSize() );
+			contentProxy.setPreferredSize( 
+				rootPane.getContentPane().getPreferredSize() );
+			proxyPanel.add( contentProxy, CENTER );
+		}
+		JPanel menuProxy = null;
+		if(rootPane.getJMenuBar() != null) {
+			menuProxy = new JPanel();
+			menuProxy.setMinimumSize( 
+				rootPane.getJMenuBar().getMinimumSize() );
+			menuProxy.setMaximumSize( 
+				rootPane.getJMenuBar().getMaximumSize() );
+			menuProxy.setPreferredSize( 
+				rootPane.getJMenuBar().getPreferredSize() );
+			proxyPanel.add( menuProxy, NORTH );
+		}
+		
+		this.addLayoutComponent( proxyPanel, CENTER );
+		
+		Dimension result = super.minimumLayoutSize( parent );
+
+		this.removeLayoutComponent( proxyPanel );
+		
+		proxyPanel.removeAll();
+		
+		return result;
+	}
+	
+	/**
+	 * Returns the maximum amount of space the layout can use.
+	 *
+	 * @param the Container for which this layout manager is being used
+	 * @return a Dimension object containing the layout's maximum size
+	 * @throws ClassCastException if parent is not a JRootPane
+	 */ 
+	public Dimension maximumLayoutSize(Container target) 
+	{
+		JRootPane rootPane = (JRootPane) target;
+		
+		JPanel proxyPanel = new JPanel();
+		proxyPanel.setLayout( new BorderLayout() );
+		
+		JPanel contentProxy = null;
+		if(rootPane.getContentPane() != null) {
+			contentProxy = new JPanel();
+			contentProxy.setMinimumSize( 
+				rootPane.getContentPane().getMinimumSize() );
+			contentProxy.setMaximumSize( 
+				rootPane.getContentPane().getMaximumSize() );
+			contentProxy.setPreferredSize( 
+				rootPane.getContentPane().getPreferredSize() );
+			proxyPanel.add( contentProxy, CENTER );
+		}
+		JPanel menuProxy = null;
+		if(rootPane.getJMenuBar() != null) {
+			menuProxy = new JPanel();
+			menuProxy.setMinimumSize( 
+				rootPane.getJMenuBar().getMinimumSize() );
+			menuProxy.setMaximumSize( 
+				rootPane.getJMenuBar().getMaximumSize() );
+			menuProxy.setPreferredSize( 
+				rootPane.getJMenuBar().getPreferredSize() );
+			proxyPanel.add( menuProxy, NORTH );
+		}
+		
+		this.addLayoutComponent( proxyPanel, CENTER );
+		
+		Dimension result = super.maximumLayoutSize( target );
+
+		this.removeLayoutComponent( proxyPanel );
+		
+		proxyPanel.removeAll();
+		
+		return result;
+	}
+	
+	/**
+	 * Instructs the layout manager to perform the layout for the specified
+	 * container.
+	 *
+	 * @param the Container for which this layout manager is being used
+	 * @throws ClassCastException if parent is not a JRootPane
+	 */ 
+	public void layoutContainer(Container parent) 
+	{
+		JRootPane rootPane = (JRootPane) parent;
+		
+		Rectangle b = parent.getBounds();
+		Insets i = rootPane.getInsets();
+		int w = b.width - i.right - i.left;
+		int h = b.height - i.top - i.bottom;
+	
+		// layout panes
+
+		if(rootPane.getLayeredPane() != null) {
+			rootPane.getLayeredPane().setBounds(i.left, i.top, w, h);
+		}
+		if(rootPane.getGlassPane() != null) {
+			rootPane.getGlassPane().setBounds(i.left, i.top, w, h);
+		}
+		
+		// handle proxy panel
+		
+		JPanel proxyPanel = new JPanel();
+		proxyPanel.setLayout( new BorderLayout() );
+		
+		this.addLayoutComponent( proxyPanel, CENTER );
+		
+		super.layoutContainer( parent );
+
+		// use proxy sizes to set sizes of layeredPane's children
+
+		Rectangle proxyRect = proxyPanel.getBounds();
+		if(rootPane.getJMenuBar() != null) {
+			Rectangle menuRect = proxyPanel.getBounds();
+			menuRect.height = rootPane.getJMenuBar().getPreferredSize().height;
+			rootPane.getJMenuBar().setBounds( menuRect );
+			proxyRect.y += menuRect.height;
+			proxyRect.height -= menuRect.height;
+		}
+		if(rootPane.getContentPane() != null) {
+			rootPane.getContentPane().setBounds( proxyRect );
+		}
+
+		this.removeLayoutComponent( proxyPanel );
+		
+		proxyPanel.removeAll();
+	}
+	
+	/**
+	* Passes NORTH, SOUTH, EAST, WEST and CENTER to super implementation,
+	* and ignores all others.
+	*/
+	public void addLayoutComponent(Component comp, Object constraints) 
+	{
+		if ( NORTH.equals( constraints ) )
+		{
+			super.addLayoutComponent( comp, constraints );
+		}
+		else
+		if ( SOUTH.equals( constraints ) )
+		{
+			super.addLayoutComponent( comp, constraints );
+		}
+		else
+		if ( EAST.equals( constraints ) )
+		{
+			super.addLayoutComponent( comp, constraints );
+		}
+		else
+		if ( WEST.equals( constraints ) )
+		{
+			super.addLayoutComponent( comp, constraints );
+		}
+		else
+		if ( CENTER.equals( constraints ) )
+		{
+			super.addLayoutComponent( comp, constraints );
+		}
+		
+		// otherwise, ignore
+	}
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterTableUI.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterTableUI.java
new file mode 100644
index 0000000..deb0eb6
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/BetterTableUI.java
@@ -0,0 +1,123 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.event.MouseEvent;
+
+import javax.swing.event.MouseInputListener;
+import javax.swing.plaf.basic.BasicTableUI;
+
+/**
+* BetterTableUI allows a JTable to be disabled by
+* listening for MouseEvents and then forwarding them
+* to the usual MouseInputHandler only if the table
+* is enabled. <BR><BR>
+*
+* This class also works around a bug where an editable
+* table's selection is changed when clicking in an edit
+* cell while the control key is down.  This typically
+* happened while users were copying/pasting data from
+* cell to cell.  <BR><BR>
+*
+* To use, call <code>JTable.setUI()</code> on any
+* JTable with a BetterTableUI as the parameter.
+*
+* @author michael@mpowers.net
+* @version $Revision: 904 $
+*/
+public class BetterTableUI extends BasicTableUI implements MouseInputListener
+{
+/**
+* The listener to get all mouse events when the table is enabled.
+*/
+    protected MouseInputListener delegateHandler;
+
+/**
+* Overridden to set self as mouse listener and create delegate.
+*/
+    protected MouseInputListener createMouseInputListener()
+    {
+        // normal handler is a protected inner class of parent
+        delegateHandler = new MouseInputHandler();
+
+        return this;
+    }
+
+    // interface MouseInputListener
+
+    public void mouseClicked(MouseEvent event)
+    {
+        if ( (table!=null) && (table.isEnabled()) )
+        {
+            delegateHandler.mouseClicked(event);
+        }
+    }
+
+    public void mouseDragged(MouseEvent event)
+    {
+        if ( (table!=null) && (table.isEnabled()) )
+        {
+            delegateHandler.mouseDragged(event);
+        }
+    }
+
+    public void mouseEntered(MouseEvent event)
+    {
+        if ( (table!=null) && (table.isEnabled()) )
+        {
+            delegateHandler.mouseEntered(event);
+        }
+    }
+
+    public void mouseExited(MouseEvent event)
+    {
+        if ( (table!=null) && (table.isEnabled()) )
+        {
+            delegateHandler.mouseExited(event);
+        }
+    }
+
+    public void mouseMoved(MouseEvent event)
+    {
+        if ( (table!=null) && (table.isEnabled()) )
+        {
+            delegateHandler.mouseMoved(event);
+        }
+    }
+
+    public void mousePressed(MouseEvent event)
+    {
+        if ( (table!=null) && (table.isEnabled()) )
+        {
+            // workaround bug - control key removes an existing selection
+            if ( table.isEditing() && event.isControlDown() ) return;
+
+            delegateHandler.mousePressed(event);
+        }
+    }
+
+    public void mouseReleased(MouseEvent event)
+    {
+        if ( (table!=null) && (table.isEnabled()) )
+        {
+            delegateHandler.mouseReleased(event);
+        }
+    }
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ButtonPanel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ButtonPanel.java
new file mode 100644
index 0000000..769e866
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ButtonPanel.java
@@ -0,0 +1,610 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.AWTEventMulticaster;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.FlowLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionListener;
+import java.beans.BeanInfo;
+import java.beans.Introspector;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Enumeration;
+import java.util.Vector;
+
+import javax.swing.AbstractButton;
+import javax.swing.Action;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.UIManager;
+
+/**
+* ButtonPanel handles display and event broadcasting of standard buttons like
+* OK/Cancel/Save/etc. The constructor takes a list or array of strings, each
+* representing a button to appear on the panel from left to right.
+* Any button click will send an action event to all listeners with the action
+* command containing the corresponding string.  Note action events are simply
+* forwarded from the buttons themselves, so the source of the event will be
+* the button, not the button panel.  The button panel is the source of the
+* STATE_CHANGED events that notify about changes to the panel itself.<BR><BR>
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class ButtonPanel extends JPanel implements ActionListener, MouseMotionListener
+{
+    // TODO: Button text should be read from resources.
+/**
+*   Specifies a "OK" button.
+*   This is also the action command sent by the OK button.
+*/
+    public static final String OK = "OK";
+/**
+*   Specifies a "Save" button.
+*   This is also the action command sent by the Save button.
+*/
+    public static final String SAVE = "Save";
+/**
+*   Specifies a "Refresh" button.
+*   This is also the action command sent by the Refresh button.
+*/
+    public static final String REFRESH = "Refresh";
+/**
+*   Specifies a "Clear All" button.
+*   This is also the action command sent by the Clear All button.
+*/
+    public static final String CLEAR_ALL = "Clear All";
+/**
+*   Specifies a "Refresh" button.
+*   This is also the action command sent by the Cancel button.
+*/
+    public static final String CANCEL = "Cancel";
+/**
+*   Specifies a "Yes" button.
+*   This is also the action command sent by the Yes button.
+*/
+    public static final String YES = "Yes";
+/**
+*   Specifies a "No" button.
+*   This is also the action command sent by the No button.
+*/
+    public static final String NO = "No";
+/**
+*   Specifies an "Add" button.
+*   This is also the action command sent by the Add button.
+*/
+    public static final String ADD = "Add";
+/**
+*   Specifies a "Remove" button.
+*   This is also the action command sent by the Remove button.
+*/
+    public static final String REMOVE = "Remove";
+/**
+*   This is the action command to all listeners when the button state is changed.
+*/
+    public static final String STATE_CHANGED = "STATE_CHANGED";
+
+/**
+*   This is the container to which buttons are added.
+*/
+    protected Container buttonContainer = null; // useful for subclasses
+/**
+*   This is the list of all buttons on the panel.
+*/
+    protected Vector buttonList = null;
+/**
+*   The insets for this panel, so they can be modified.
+*/
+    protected Insets insets = new Insets( 5, 5, 5, 5 );
+
+/**
+*   This is the layout manager - which must be a FlowLayout or subclass.
+*/
+    protected FlowLayout buttonPanelLayout = null;
+
+    // for action multicasting
+    protected ActionListener actionListener = null;
+
+
+/**
+* Constructs a ButtonPanel.  Three buttons are created
+* so the panel is filled when used in a GUI-builder environment.
+*/
+    public ButtonPanel()
+    {
+        buttonList = new Vector();
+        initLayout();
+
+        // default labels for bean layout
+        setLabels( new String[] { "One", "Two", "Three" } );
+    }
+
+/**
+* This method is responsible for the initial layout of the panel.
+* Subclasses can implement different layouts, but this method
+* is responsible for initializing buttonContainer and buttonPanelLayout
+* and setting the container to use the layout.
+*/
+    protected void initLayout()
+    {
+        this.setInsets( super.getInsets() );
+        buttonContainer = this;
+        buttonPanelLayout = new BetterFlowLayout( BetterFlowLayout.RIGHT );
+        buttonContainer.setLayout(buttonPanelLayout);
+        ((BetterFlowLayout)buttonPanelLayout).setWidthUniform( true );
+
+        // setBackground( Color.blue ); // useful for debugging
+    }
+
+/**
+* Constructs a ButtonPanel using specified buttons.
+* @param buttonList An array containing the strings to be used in labeling the buttons.
+*/
+    public ButtonPanel( String[] buttonList )
+    {
+        this();
+        setLabels( buttonList );
+    }
+
+/**
+* Constructs a ButtonPane using specified actions.  For each action, a button
+* is created, that when pressed the corresponding action is activated.  The
+* "name" of the action is used as the title of the button.
+* @param actionList An array of actions to be used to create buttons with.
+*/
+    public ButtonPanel( Action[] actionList )
+    {
+        this();
+        setLabels( actionList );
+    }
+
+/**
+* Creates the buttons to appear on the panel.  Any existing buttons
+* are replaced.  The labels are used as names and action commands
+* in addition to labels.
+* @param labels An array of strings to be used in labeling the buttons.
+* If null, all buttons will be removed.
+*/
+    public void setLabels( String[] labels )
+    {
+        if ( labels == null )
+        {
+            labels = new String[] {};
+        }
+
+        buttonContainer.removeAll();
+        this.buttonList = new Vector( labels.length );
+
+        String item = null;
+        Component button;
+        for ( int i = 0; i < labels.length; i++ )
+        {
+            item = labels[i];
+            if ( item != null )
+            {
+                button = createComponentWithLabel( item.toString() );
+                this.buttonList.addElement( item );
+                addComponentToPanel( button );
+                button.setEnabled( this.isEnabled() );
+/*
+                if ( i == 0 )
+                {
+                    JRootPane root = SwingUtilities.getRootPane( button );
+                    if ( root != null )
+                        root.setDefaultButton( button );
+                }
+*/
+            }
+            else
+            {
+                throw new IllegalArgumentException( "ButtonPanel.setButtons: nulls are not allowed." );
+            }
+        }
+
+        this.revalidate();
+        this.repaint();
+        broadcastEvent( new ActionEvent( this, ActionEvent.ACTION_PERFORMED, STATE_CHANGED ) );
+    }
+
+/**
+*
+*/
+    public void setLabels( Action[] actions )
+    {
+        if ( actions == null )
+        {
+            actions = new Action[] {};
+        }
+
+        buttonContainer.removeAll();
+        this.buttonList = new Vector( actions.length );
+
+        Action action = null;
+        Component button;
+        for ( int i = 0; i < actions.length; i++ )
+        {
+            action = actions[i];
+            if ( action != null )
+            {
+                String name = ( String )action.getValue( Action.NAME );
+                button = createComponentWithLabel( name );
+                this.buttonList.addElement( name );
+                addComponentToPanel( button );
+                button.setEnabled( this.isEnabled() ? action.isEnabled() : false );
+
+                // Add the action to the "button" if it knows about action listeners.
+                try
+                {
+                    Method addActionListenerMethod =
+                        button.getClass().getMethod( "addActionListener", new Class[] { ActionListener.class } );
+                    addActionListenerMethod.invoke( button, new Object[] { action } );
+                }
+                catch ( NoSuchMethodException e ) { /* Do Nothing */ }
+                catch ( IllegalAccessException e ) { e.printStackTrace(); /* TODO: Do Something? */ }
+                catch ( InvocationTargetException e ) { e.printStackTrace(); /* TODO: Do Something? */ }
+
+                // Create a new listener for property change events and have
+                // the action broadcast to that listener.
+                PropertyChangeListener pcListener = new ActionChangeListener( button );
+                action.addPropertyChangeListener( pcListener );
+            }
+            else
+            {
+                throw new IllegalArgumentException( "ButtonPanel.setButtons: nulls are not allowed." );
+            }
+        }
+
+        this.revalidate();
+        this.repaint();
+        broadcastEvent( new ActionEvent( this, ActionEvent.ACTION_PERFORMED, STATE_CHANGED ) );
+    }
+
+
+/**
+* Gets the labels of the buttons that appear on the panel, ordered from left to right.
+* @return A new list containing strings used in labeling the buttons.
+*/
+    public String[] getLabels()
+    {
+        String[] labels = new String[ buttonList.size() ];
+        int i = 0;
+        for ( Enumeration it = buttonList.elements(); it.hasMoreElements(); )
+        {
+            labels[i++] = it.nextElement().toString();
+        }
+        return labels;
+    }
+
+/**
+* Gets the first component having the specified name.
+* @return A component with the specified name, or null if none match.
+*/
+    public Component getButton( String aLabel )
+    {
+        if ( aLabel == null ) return null;
+        
+        Component c = null;
+        int count = buttonContainer.getComponentCount();
+        for ( int i = 0; i < count; i++ )
+        {
+            c = buttonContainer.getComponent( i );
+            if ( aLabel.equals( c.getName() ) )
+            {
+                return c;
+            }
+        }
+        return null;
+    }
+
+/**
+* Creates a new component with the specified label.
+* The label is also used for the component's name
+* and action command, if any.
+* (This implementation returns a JButton.)
+* @param aLabel The label for the component that will be created.
+* @return The newly created component.
+*/
+    protected Component createComponentWithLabel( String aLabel )
+    {
+        String buttonLabel = aLabel; // TODO: get string from resource
+        JButton newButton = new JButton(); // might allow other types in future
+        newButton.setName( aLabel );
+        newButton.setText( buttonLabel );
+        newButton.setActionCommand( aLabel );
+        newButton.addActionListener( this );
+        return newButton;
+    }
+
+/**
+* Adds a component to the right-most side of the layout.
+* @param aComponent The component to be added to the layout.
+*/
+    protected void addComponentToPanel( Component aComponent )
+    {
+        buttonContainer.add( aComponent );
+    }
+
+
+/**
+* Changes the alignment of the buttons in the panel.  Defaults to right-justified.
+* @param alignment A valid alignment code, per BetterFlowLayout implementation.
+* @see BetterFlowLayout
+*/
+    public void setAlignment( int alignment )
+    {
+        buttonPanelLayout.setAlignment(alignment);
+        buttonContainer.doLayout();
+    }
+/**
+* Gets the alignment of the buttons in the panel.
+* @return An alignment code, per FlowLayout implementation.
+* @see FlowLayout
+*/
+    public int getAlignment()
+    {
+        return buttonPanelLayout.getAlignment();
+    }
+
+/**
+* Changes the horizontal spacing between components in the panel.
+* @param newHgap the new spacing, in pixels.  May not be negative.
+*/
+    public void setHgap( int newHgap )
+    {
+        if ( newHgap < 0 ) return; // may not be negative
+        buttonPanelLayout.setHgap( newHgap );
+    }
+
+/**
+* Gets the current horizontal spacing between components.
+* @return the current horizontal spacing, in pixels.
+*/
+    public int getHgap()
+    {
+        return buttonPanelLayout.getHgap();
+    }
+
+/**
+* Changes the vertical spacing between components in the panel.
+* @param newVgap the new spacing, in pixels.  May not be negative.
+*/
+    public void setVgap( int newVgap )
+    {
+        if ( newVgap < 0 ) return; // may not be negative
+        buttonPanelLayout.setVgap( newVgap );
+    }
+
+/**
+* Gets the current vertical spacing between components.
+* @return the current vertical spacing, in pixels.
+*/
+    public int getVgap()
+    {
+        return buttonPanelLayout.getVgap();
+    }
+
+/**
+* Changes the insets for this panel.
+* @param newInsets the new insets.
+*/
+    public void setInsets( Insets newInsets )
+    {
+        insets = newInsets;
+    }
+
+/**
+* Overridden to return the user-specified insets for this panel.
+* @return the current insets for this panel.
+*/
+    public Insets getInsets()
+    {
+        return insets;
+    }
+
+/**
+* Overridden to call setEnabled on all components on panel.
+* @param isEnabled whether to enable the panel and all components on it.
+*/
+    public void setEnabled( boolean isEnabled )
+    {
+        super.setEnabled( isEnabled );
+        int count = buttonContainer.getComponentCount();
+        for ( int i = 0; i < count; i++ )
+        {
+            buttonContainer.getComponent( i ).setEnabled( isEnabled );
+        }
+    }
+
+    // Action Multicast methods
+
+/**
+* Adds an action listener to the list that will be
+* notified by button events and changes in button state.
+* @param l An action listener to be notified.
+*/
+     public void addActionListener(ActionListener l)
+     {
+           actionListener = AWTEventMulticaster.add(actionListener, l);
+     }
+/**
+* Removes an action listener from the list that will be
+* notified by button events and changes in button state.
+* @param l An action listener to be removed.
+*/
+     public void removeActionListener(ActionListener l)
+     {
+           actionListener = AWTEventMulticaster.remove(actionListener, l);
+     }
+/**
+* Notifies all registered action listeners of a pending Action Event.
+* @param e An action event to be broadcast.
+*/
+     protected void broadcastEvent(ActionEvent e)
+     {
+         if (actionListener != null)
+         {
+             actionListener.actionPerformed(e);
+         }
+     }
+
+    // interface ActionListener
+
+/**
+* Called by buttons on panel and by other components that
+* might be set to broadcast events to this listener.
+* @param e An action event to be received.
+*/
+     public void actionPerformed(ActionEvent e)
+     {
+            broadcastEvent(e);
+     }
+
+/**
+* A property change listener that listens specifically for property changes
+* from action objects.  This is the class that ties in the action to the
+* button.  This class is added to an action as a property change listener.
+* The corresponding component is referenced by this class toe easily handle
+* updates to the component caused by changes to the action.
+*/
+     public class ActionChangeListener implements PropertyChangeListener
+     {
+        /** The UI component that is affected by the action's changes. */
+        Component theComponent;
+
+        /**
+        * Constructs an ActionChangeListener with the given component being
+        * the recipient of the action's changes.
+        * @param The component to bind with the action.
+        */
+        public ActionChangeListener( Component aComponent )
+        {
+            super();
+            theComponent = aComponent;
+        }
+
+        /**
+        * Called whenever a property changes on the action object.
+        * @pram e The property change event generated by the action.
+        */
+        public void propertyChange( PropertyChangeEvent e )
+        {
+            String propertyName = e.getPropertyName();
+            if ( propertyName.equals( Action.NAME ) )
+            {
+                String name = ( String )e.getNewValue();
+                if ( theComponent instanceof AbstractButton )
+                {
+                    AbstractButton button = ( AbstractButton )theComponent;
+                    String oldName = button.getName();
+                    button.setText( name );
+                    button.setName( name );
+                    button.setActionCommand( name );
+
+                    // Replace the old name of the component with the new name
+                    // in the ButtonPanel's list of components.
+                    buttonList.setElementAt( name, buttonList.indexOf( oldName ) );
+                }
+
+                // TODO: If component is not a button (or doesn't define the getText()
+                // then what should be done.
+            }
+            else if ( propertyName.equals( "enabled" ) )
+            {
+                Boolean enabled = ( Boolean )e.getNewValue();
+                theComponent.setEnabled( ButtonPanel.this.isEnabled() ? enabled.booleanValue() : false );
+            }
+
+            // TODO: Icon?
+        }
+     }
+
+
+    // for testing
+
+    public static void main( String[] argv )
+    {
+        try
+        {
+            UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );
+        }
+        catch (Exception exc)
+        {
+
+        }
+
+        JFrame dialog = new JFrame();
+        BorderLayout bl = new BorderLayout( 20, 20 );
+
+        ButtonPanel panel = new ButtonPanel();
+//        ButtonPanel panel = new ButtonPanel( new String[] { "OkayOkay", "CancelCancel" } );
+
+        dialog.getContentPane().setLayout( bl );
+        dialog.getContentPane().add( panel, BorderLayout.CENTER );
+        dialog.setLocation( 50, 50 );
+        // dialog.setSize( 450, 150 );
+
+        panel.setAlignment( BetterFlowLayout.CENTER_VERTICAL );
+        panel.getButton( "One" ).setEnabled( false );
+
+        dialog.pack();
+        dialog.setVisible( true );
+
+        try
+        {
+            BeanInfo info = Introspector.getBeanInfo( ButtonPanel.class );
+            PropertyDescriptor[] props = info.getPropertyDescriptors();
+            for ( int i = 0; i < props.length; i++ )
+            {
+                System.out.println( props[i].getName() );
+            }
+        }
+        catch (Exception exc)
+        {
+            System.out.println( exc );
+        }
+
+
+
+
+    }
+
+    public void mouseDragged(MouseEvent e)
+    {
+    }
+
+    public void mouseMoved(MouseEvent e)
+    {
+    }
+
+
+
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/CheckButtonPanel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/CheckButtonPanel.java
new file mode 100644
index 0000000..5e847ae
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/CheckButtonPanel.java
@@ -0,0 +1,272 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Component;
+import java.util.List;
+import java.util.Vector;
+
+import javax.swing.AbstractButton;
+import javax.swing.JCheckBox;
+import javax.swing.border.EmptyBorder;
+
+/**
+* CheckButtonPanel is a simple extension of ButtonPanel.
+* Differences are that it uses JCheckBoxes and the
+* default alignment is vertical.  The panel defaults to having
+* no buttons selected.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class CheckButtonPanel extends ButtonPanel
+{
+/**
+* Constructs a CheckButtonPanel.  Three buttons are created
+* so the panel is filled when used in a GUI-builder environment.
+*/
+    public CheckButtonPanel()
+    {
+        super();
+    }
+
+/**
+* Constructs a ButtonPanel using specified buttons.
+* @param buttonList An array containing the strings to be used in labeling the buttons.
+*/
+    public CheckButtonPanel( String[] buttonList )
+    {
+        super( buttonList );
+    }
+
+/**
+* Overridden to set vertical-center alignment and zero vgap.
+*/
+    protected void initLayout()
+    {
+        super.initLayout();
+        buttonPanelLayout.setAlignment( BetterFlowLayout.CENTER_VERTICAL );
+        buttonPanelLayout.setVgap( 0 );
+    }
+
+/**
+* Overridden to return a JRadioButton.
+* @param aLabel The label for the component that will be created.
+* @return The newly created component.
+*/
+    protected Component createComponentWithLabel( String aLabel )
+    {
+        String buttonLabel = aLabel;
+        JCheckBox newButton = new JCheckBox();
+        newButton.setName( aLabel );
+        newButton.setText( buttonLabel );
+        newButton.setActionCommand( aLabel );
+        newButton.addActionListener( this );
+
+        // reduce insets per java l&f guidelines (was 4 on each side)
+        newButton.setBorder( new EmptyBorder( 1, 4, 1, 4 ) );
+
+        return newButton;
+    }
+
+/**
+* Sets the value of the button whose name matches the given text value.
+* @param aName A String matching the name of one of the buttons.
+* If null, empty, or not matching, nothing happens.
+* @param aValue A value to set the button.
+*/
+    public void setValue(String aName, boolean aValue)
+    {
+        if ( aName != null )
+        {
+            Component c = null;
+            int count = buttonContainer.getComponentCount();
+            for ( int i = 0; i < count; i++ )
+            {
+                c = buttonContainer.getComponent( i );
+                if ( c instanceof AbstractButton )
+                {
+                    if ( c.getName().equals( aName ) )
+                    {
+                        ((AbstractButton)c).setSelected( aValue );
+                        c.repaint();
+                        return;
+                    }
+                }
+            }
+        }
+        // null, empty, or not matching - exit.
+        System.out.println( "CheckButtonPanel.setValue: not found: " + aName );
+    }
+
+/**
+* Sets the state of the specified buttons to the specified value.
+* @param aLabelArray An Array of Strings listing the buttons to be set.
+* @param aValue The value to which the specified buttons will be set.
+*/
+    public void setValues(String[] aLabelArray, boolean aValue)
+    {
+        if ( aLabelArray != null )
+        {
+            for ( int i = 0; i < aLabelArray.length; i++ )
+            {
+                setValue( aLabelArray[i], aValue );
+            }
+        }
+    }
+
+/**
+* Convenience method to set all checkboxes on the panel.
+* @param aValue The value to which all checkboxes on the panel will be set.
+*/
+    public void setAllValues(boolean aValue)
+    {
+        setValues( getLabels(), aValue );
+    }
+
+/**
+* Convenience method to check all boxes on the panel.
+*/
+    public void checkAll()
+    {
+        setAllValues( true );
+    }
+
+/**
+* Convenience method to clear all boxes on the panel.
+*/
+    public void clearAll()
+    {
+        setAllValues( false );
+    }
+
+/**
+* A convenience method to set only those buttons on the entire
+* panel that should be checked.  Buttons not in the list are unchecked.
+* @param aLabelArray An Array of Strings listing the buttons to be set.
+*/
+    public void setCheckedValues(String[] aLabelArray)
+    {
+        setAllValues( false );
+        setValues( aLabelArray, true );
+    }
+
+/**
+* Gets the labels of all checkboxes that are checked.
+* @return A List of Strings containing the labels of the boxes that are checked.
+*/
+    public List getCheckedValueList()
+    {
+        Vector v = new Vector();
+        Component c = null;
+        int count = buttonContainer.getComponentCount();
+        for ( int i = 0; i < count; i++ )
+        {
+            c = buttonContainer.getComponent( i );
+            if ( c instanceof AbstractButton )
+            {
+                if ( ((AbstractButton)c).isSelected() )
+                {
+                    v.addElement(c.getName());
+                }
+            }
+        }
+        return v;
+    }
+
+/**
+* Gets the labels of all checkboxes that are checked.
+* @return A String Array containing the labels of the boxes that are checked.
+*/
+    public String[] getCheckedValues()
+    {
+        List v = getCheckedValueList();
+        String[] result = new String[ v.size() ];
+        for ( int i = 0; i < v.size(); i++ )
+        {
+            result[i] = (String) v.get(i);
+        }
+        return result;
+    }
+
+/**
+* Gets the value of the specified button.
+* @param aName A String matching the name of one of the buttons.
+* @return True if the button is checked, False if it is not checked.
+* NOTE: If the button is not found in the list, False is returned.
+*/
+    public boolean getValue( String aName )
+    {
+        Component c = null;
+        int count = buttonContainer.getComponentCount();
+        for ( int i = 0; i < count; i++ )
+        {
+            c = buttonContainer.getComponent( i );
+            if ( ( c instanceof AbstractButton ) && ( ((AbstractButton)c).isSelected() ) )
+            {
+                if ( ((AbstractButton)c).getText().equals( aName ) )
+                {
+                    return ((AbstractButton)c).isSelected();
+                }
+            }
+        }
+        return false;
+    }
+
+    // for testing
+
+    public static void main( String[] argv )
+    {
+        try
+        {
+            javax.swing.UIManager.setLookAndFeel( javax.swing.UIManager.getSystemLookAndFeelClassName() );
+        }
+        catch (Exception exc)
+        {
+
+        }
+
+        javax.swing.JFrame dialog = new javax.swing.JFrame();
+        java.awt.BorderLayout bl = new java.awt.BorderLayout( 20, 20 );
+
+        CheckButtonPanel panel = new CheckButtonPanel( new String[] { "One", "Two", "Three" } );
+
+        dialog.getContentPane().setLayout( bl );
+        dialog.getContentPane().add( panel, java.awt.BorderLayout.CENTER );
+        dialog.setLocation( 50, 50 );
+        // dialog.setSize( 450, 150 );
+
+        panel.setAlignment( BetterFlowLayout.CENTER_VERTICAL );
+        panel.getButton( "One" ).setEnabled( false );
+        panel.setValues( new String[] { "One" }, true );
+        panel.setValue( "Three", true );
+//        panel.setCheckedValues( new String[] { "Two" } );
+        String[] values = panel.getCheckedValues();
+        for ( int i = 0; i < values.length; i++ )
+        {
+            System.out.println( values[i] );
+        }
+
+        dialog.pack();
+        dialog.setVisible( true );
+
+    }
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ColorCellEditor.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ColorCellEditor.java
new file mode 100644
index 0000000..a0a14ac
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ColorCellEditor.java
@@ -0,0 +1,84 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.DefaultCellEditor;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JTable;
+
+/**
+* A TableCellEditor that edits colors - it launches a color dialog when clicked.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+class ColorCellEditor extends DefaultCellEditor {
+    Color currentColor = null;
+
+    public ColorCellEditor(JButton b)
+    {
+        super(new JCheckBox()); // unfortunately, the constructor
+                                // expects a check box, combo box,
+                                // or text field.
+        editorComponent = b;
+        setClickCountToStart(1); // this is usually 1 or 2.
+
+        // must do this so that editing stops when appropriate.
+        b.addActionListener(new ActionListener()
+        {
+            public void actionPerformed(ActionEvent e)
+            {
+                fireEditingStopped();
+            }
+        }
+        );
+    }
+
+    protected void fireEditingStopped()
+    {
+        super.fireEditingStopped();
+    }
+
+    public Object getCellEditorValue()
+    {
+        return currentColor;
+    }
+
+    public Component getTableCellEditorComponent(JTable table,
+                                                 Object value,
+                                                 boolean isSelected,
+                                                 int row,
+                                                 int column)
+    {
+        ((JButton)editorComponent).setText(value.toString());
+        currentColor = (Color)value;
+        return editorComponent;
+    }
+}
+
+
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ColorCellRenderer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ColorCellRenderer.java
new file mode 100644
index 0000000..0552183
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ColorCellRenderer.java
@@ -0,0 +1,81 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+
+import javax.swing.BorderFactory;
+import javax.swing.JLabel;
+import javax.swing.JTable;
+import javax.swing.border.Border;
+import javax.swing.table.TableCellRenderer;
+
+/**
+* A TableCellRenderer that renders colors.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class ColorCellRenderer extends JLabel implements TableCellRenderer {
+    Border unselectedBorder = null;
+    Border selectedBorder = null;
+    boolean isBordered = true;
+
+    public ColorCellRenderer(boolean isBordered)
+    {
+        super();
+        this.isBordered = isBordered;
+        setOpaque(true); // must do this for background to show up.
+    }
+
+    public Component getTableCellRendererComponent(
+                            JTable table, Object color,
+                            boolean isSelected, boolean hasFocus,
+                            int row, int column)
+    {
+        setBackground((Color)color);
+        if (isBordered)
+        {
+            if (isSelected)
+            {
+                if (selectedBorder == null)
+                {
+                    selectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
+                                              table.getSelectionBackground());
+                }
+                setBorder(selectedBorder);
+            }
+            else
+            {
+                if (unselectedBorder == null)
+                {
+                    unselectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
+                                              table.getBackground());
+                }
+                setBorder(unselectedBorder);
+            }
+        }
+        return this;
+    }
+}
+
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ComboBoxCellRenderer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ComboBoxCellRenderer.java
new file mode 100644
index 0000000..2bf8dd6
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ComboBoxCellRenderer.java
@@ -0,0 +1,57 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+
+import javax.swing.JComboBox;
+import javax.swing.JTable;
+import javax.swing.table.TableCellRenderer;
+
+/**
+* A TableCellRenderer that paints a JComboBox.  Useful if
+* you want to visibly display the JComboBox before the
+* user clicks on the cell.
+*
+* @author bsafa@intersectsoft.com
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class ComboBoxCellRenderer extends JComboBox implements TableCellRenderer {
+
+    public ComboBoxCellRenderer()
+    {
+        super();        
+        setOpaque(true); 
+    }
+
+    public Component getTableCellRendererComponent(
+                            JTable table, Object value,
+                            boolean isSelected, boolean hasFocus,
+                            int row, int column)
+    {
+        setBackground(Color.white);              
+        setSelectedItem(value);                
+        return this;
+    }
+}
+
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/DateTextField.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/DateTextField.java
new file mode 100644
index 0000000..18ed035
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/DateTextField.java
@@ -0,0 +1,630 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.awt.event.KeyEvent;
+import java.text.ParsePosition;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Vector;
+
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+
+
+/**
+* DateTextField is a "smart" text field that restricts the user's input.  The
+* input is restructed to a string representing a date format.
+*
+* @author rob@straylight.princeton.com
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class DateTextField extends JTextField
+{
+
+/*******************************
+* CONSTANTS
+*******************************/
+
+/**
+* Use the current date for this text field.
+*/
+   public static final int CURRENT_DATE = 0;
+
+/**
+* Use blanks for this text field.
+*/
+   public static final int BLANKS = 1;
+
+/**
+* Use underscores for this text field.
+*/
+   public static final int UNDERSCORES = 2;
+
+/**
+* Use just a 4-digit year for this text field.
+*/
+   public static final int YEAR = 3;
+
+   private static final int BACKSPACE = 8;
+   private static final int DELETE = 127;
+   private static final int PASTE = 22;  // Ctl-V
+   private static final int CUT = 24;  // Ctl-X
+
+
+/*******************************
+* DATA MEMEBERS
+*******************************/
+   private int defaultType = CURRENT_DATE;
+
+   private boolean warningMessageActive = false;
+
+
+/*******************************
+* PUBLIC METHODS
+*******************************/
+
+/**
+* Default Constructor.
+*/
+   public DateTextField()
+   {
+      this(1, 1, 1999, 0);
+
+      Calendar rightNow = Calendar.getInstance();
+
+      super.setText(createDateString(rightNow.get(Calendar.MONTH) + 1,
+                                     rightNow.get(Calendar.DATE),
+                                     rightNow.get(Calendar.YEAR)));
+   }
+
+/**
+* Constructor.
+* @param month Number of the month, January being 1.
+* @param data The day of the month.
+* @param year The year.
+*/
+   public DateTextField(int month, int date, int year)
+   {
+      this(month, date, year, 0);
+   }
+
+/**
+* Constructor.
+* @param columns Width of the text field (in characters).
+*/
+   public DateTextField(int columns)
+   {
+      this(1, 1, 1998, columns);
+
+      Calendar rightNow = Calendar.getInstance();
+
+      super.setText(createDateString(rightNow.get(Calendar.MONTH) + 1,
+                                     rightNow.get(Calendar.DATE),
+                                     rightNow.get(Calendar.YEAR)));
+   }
+
+/**
+* Constructor.
+* @param month Number of the month, January being 1.
+* @param data The day of the month.
+* @param year The year.
+* @param columns Width of the text field (in characters).
+*/
+   public DateTextField(int month, int date, int year, int columns)
+   {
+      super("", columns);
+
+      super.setText(createDateString(month, date, year));
+
+      this.addFocusListener(new FocusAdapter()
+      {
+         public void focusLost(FocusEvent e)
+         {
+            if (!(e.isTemporary()))
+            {
+               validateDateString(e);
+            }
+         }
+      });
+   }
+
+/**
+* Sets the date type to display when the user has not entered any date yet.
+* Default is the current date.
+* @see #CURRENT_DATE
+* @see #BLANKS
+* @see #UNDERSCORES
+* @param newDefaultType The type of date to display when there is no date data.
+*/
+   public void setDefaultType(int newDefaultType)
+   {
+      if (newDefaultType == BLANKS)
+      {
+         defaultType = BLANKS;
+         super.setText("  /  /    ");
+      }
+      else if (newDefaultType == UNDERSCORES)
+      {
+         defaultType = UNDERSCORES;
+         super.setText("__/__/____");
+      }
+      else if (newDefaultType == YEAR)
+      {
+          defaultType = YEAR;
+          super.setText("0000");
+      }
+      else
+      {
+         defaultType = CURRENT_DATE;
+
+         Calendar rightNow = Calendar.getInstance();
+
+         super.setText(createDateString(rightNow.get(Calendar.MONTH) + 1,
+                                        rightNow.get(Calendar.DATE),
+                                        rightNow.get(Calendar.YEAR)));
+      }
+   }
+
+/**
+* Returns the type of date to display when there is no user input.
+* @see #CURRENT_DATE
+* @see #BLANKS
+* @see #UNDERSCORES
+* @return The type of date to display when there is no date to display.
+*/
+   public int getDefaultType()
+   {
+      return defaultType;
+   }
+
+/**
+* Sets the text field to the string representation of the specified date.
+* @param aDate The date to set the text field to.
+*/
+   public void setDate(Date aDate)
+   {
+       Calendar aCalendar = Calendar.getInstance();
+
+       aCalendar.setTime(aDate);
+
+       super.setText(createDateString(aCalendar.get(Calendar.MONTH) + 1,
+                                      aCalendar.get(Calendar.DATE),
+                                      aCalendar.get(Calendar.YEAR)));
+   }
+
+/**
+* Sets the text field directly from a Date object.
+* @param aDate The date to set the text field to.
+*/
+   public void setText( Date aDate )
+   {
+       setDate( aDate );
+   }
+
+/**
+* Sets the text field to the date specified in the string.  This is overridden
+* from the parent class to insure a valid date is inputted.  The format of the
+* date expected is the type of date format this text field is currently set to.
+* @param aString A string representing a date in this text field current format.
+*/
+   public void setText( String aString )
+   {
+       Date testDate = null;
+
+       if ( aString != null )
+       {
+           ParsePosition position = new ParsePosition( 0 );
+
+           if  ( defaultType == YEAR )
+           {
+               SimpleDateFormat yearFormatter = new SimpleDateFormat( "yyyy" );
+               testDate = yearFormatter.parse( aString, position );
+           }
+           else
+           {
+               SimpleDateFormat fullDateFormatter = new SimpleDateFormat( "MM/dd/yyyy" );
+               testDate = fullDateFormatter.parse( aString, position );
+           }
+       }
+
+       // The string is not a valid date, use default value for date then.
+       if ( testDate == null )
+       {
+           Calendar aCalendar = Calendar.getInstance();
+
+           testDate = aCalendar.getTime();
+       }
+
+       setDate( testDate );
+   }
+
+/**
+* Returns the date as represented by the date string in the text field.
+* @return The date in the text field.
+*/
+   public Date getDate() throws NumberFormatException
+   {
+      Calendar aCalendar = Calendar.getInstance();
+      int year = 1980;
+      int month = 0;
+      int date = 1;
+      int[] tempArray = {1,3,5,7,8,10,12};
+      Vector monthsWith31Days = new Vector(7);
+
+      for (int i = 0; i < tempArray.length; ++i)
+      {
+         monthsWith31Days.addElement(new Integer(tempArray[i]));
+      }
+
+      aCalendar.set(year, month, date, 12, 0, 0);
+
+      try
+      {
+         String dateString = getText();
+         NumberFormatException nfException = new NumberFormatException(new String("Invalid Date String: " + dateString));
+
+         if (defaultType == YEAR)
+         {
+             year = Integer.parseInt(dateString);
+             
+             aCalendar.set(year, 0, 1, 12, 0, 0);
+
+             return aCalendar.getTime();
+         }
+
+         month = Integer.parseInt(dateString.substring(0, 2).trim());
+         date = Integer.parseInt(dateString.substring(3, 5).trim());
+         year = Integer.parseInt(dateString.substring(6).trim());
+
+         if ((month < 1) || (month > 12))
+         {
+            throw nfException;
+         }
+
+         if ((date < 1) || (date > 31))
+         {
+            throw nfException;
+         }
+
+         if ((date == 31) && (!(monthsWith31Days.contains(new Integer(month)))))
+         {
+            throw nfException;
+         }
+
+         if ((date == 30) && (month == 2))
+         {
+            throw nfException;
+         }
+
+         if ((date == 29) && (month == 2))
+         {
+            if ((year % 100) == 0)
+            {
+               if ((year % 400) != 0)
+               {
+                  throw nfException;
+               }
+            }
+            else
+            {
+               if ((year % 4) != 0)
+               {
+                  throw nfException;
+               }
+            }
+         }
+      }
+      catch (IndexOutOfBoundsException ioobe)
+      {
+         NumberFormatException nfException = new NumberFormatException(new String("Invalid Date String: " + getText()));
+         throw nfException;
+      }
+      catch (NumberFormatException nfe)
+      {
+         NumberFormatException nfException = new NumberFormatException(new String("Invalid Date String: " + getText()));
+         throw nfException;
+      }
+
+      aCalendar.set(year, (month - 1), date, 12, 0, 0);
+
+      return aCalendar.getTime();
+   }
+
+   public void processKeyEvent(KeyEvent e)
+   {
+      String currentString = "";
+      String testString = "";
+      char newChar = e.getKeyChar();
+      int currentLength = 0;
+      int currentCaretPosition = 0;
+      int selectionStart = 0;
+      int selectionEnd = 0;
+      int modifierPosition = 0;
+      int modifierDirection = 1;
+      char modifierCharacter;
+      boolean backspace = false;
+      boolean delete = false;
+      boolean paste = false;
+      boolean cut = false;
+      boolean keyPressed = false;
+
+      backspace = (newChar == BACKSPACE);
+      delete = (newChar == DELETE);
+      paste = (newChar == PASTE);
+      cut = (newChar == CUT);
+
+      keyPressed = (e.paramString().startsWith("KEY_PRESSED"));
+
+      if ((e.getKeyCode() == KeyEvent.VK_UNDEFINED) || ((backspace) || (delete) || (paste) || (cut)))  // A "key-typed" event
+      {
+         if (isValidCharacter(newChar))
+         {
+            if ((isPrintableCharacter(newChar)) || (backspace) || (delete))
+            {
+               // Both the key "pressed" and key "released" events get passed
+               // in here for the delete and backspace key.  Only processes
+               // these keys if the event is key "pressed".
+               if (((backspace) || (delete)) && (!(keyPressed)))
+               {
+                  // Don't do anything, pass through to consumption.
+               }
+               else
+               {
+                  // Analyze the current contents of the field
+                  currentString = getText();
+                  currentLength = currentString.length();
+
+                  char[] tempText = new char[currentLength];
+
+                  currentCaretPosition = getCaretPosition();
+
+                  selectionStart = getSelectionStart();
+                  selectionEnd = getSelectionEnd();
+
+                  // if a range is selected, then get rid of it and place the caret
+                  // at the begginning of the range and continue processing.
+                  if (selectionStart != selectionEnd)
+                  {
+                     selectionEnd = selectionStart;
+                     setSelectionEnd(selectionEnd);
+
+                     currentCaretPosition = selectionStart;
+                     setCaretPosition(currentCaretPosition);
+                  }
+
+                  if (currentCaretPosition <= currentLength)
+                  {
+                     // a number of delete or backspace was pressed, delete and
+                     // backspace deletes a number and places a "space" there
+
+                     // if caret at start of string and the backspace pressed OR
+                     // caret at end of string and delete or number pressed THEN
+                     // don't do anything, otherwise process key stroke
+                     if (((currentCaretPosition == 0) && (backspace)) ||
+                         ((currentCaretPosition == currentLength) && (!(backspace))))
+                     {
+                        // Don't do any processing.
+                     }
+                     else
+                     {
+                        modifierPosition = currentCaretPosition;
+                        if (backspace)
+                        {
+                           modifierDirection = -1;
+                           modifierPosition += modifierDirection;
+                        }
+
+                        // Overwrite the current position with the new character
+                        // inputted or overwrite using a space or underscore if
+                        // the backspace or delete key was pressed.
+                        if (defaultType != YEAR)
+                        {
+                            modifierCharacter =
+                                   ((delete)||(backspace)) ?
+                                   ((defaultType == UNDERSCORES) ? '_' : ' ') :
+                                   newChar;
+                        }
+                        else
+                        {
+                            // We are dealing with a 4-digit year.  Overwrite
+                            // with new character or "0" if delete or backspace
+                            // was pressed.
+                            modifierCharacter = ((delete)||(backspace)) ? ('0') : newChar;
+                        }
+
+                        if (currentString.charAt(modifierPosition) == '/')
+                        {
+                           modifierPosition += modifierDirection;
+                        }
+
+                        for (int i = 0; i < currentLength; ++i)
+                        {
+                           if (i == modifierPosition)
+                           {
+                              tempText[i] = modifierCharacter;
+                           }
+                           else
+                           {
+                              tempText[i] = currentString.charAt(i);
+                           }
+                        }
+
+                        testString = new String(tempText);
+                        if (isValidString(testString))
+                        {
+                           super.setText(testString);
+                           if (backspace)
+                           {
+                              setCaretPosition(modifierPosition);
+                           }
+                           else
+                           {
+                              setCaretPosition(modifierPosition + 1);
+                           }
+                        }
+                     }
+                  }
+               }
+
+               e.consume();
+            }
+            else if ((cut) || (paste))
+            {
+               e.consume();
+            }
+            // else its a non-printable character, let it pass through
+         }
+         else
+         {
+            e.consume();
+         }
+      }
+
+      super.processKeyEvent(e);
+   }
+
+   private boolean isValidCharacter(char aChar)
+   {
+      if (((aChar >= '!') && (aChar <= '/')) || ((aChar >= ':') && (aChar <= '~')))
+      {
+         return false;
+      }
+      return true;
+   }
+
+   private boolean isPrintableCharacter(char inputChar)
+   {
+      if ((inputChar >= ' ') && (inputChar <= '~'))
+      {
+         return true;
+      }
+      return false;
+   }
+
+   private boolean isValidDate(int month, int date, int year)
+   {
+      if ((month < 1) || (month > 12))
+      {
+         return false;
+      }
+
+      if ((date < 1) || (date > 31))
+      {
+         return false;
+      }
+
+      if ((year < 0) || (year > 9999))
+      {
+         return false;
+      }
+
+      return true;
+   }
+
+   private boolean isValidString(String aString)
+   {
+      return true;
+   }
+
+   private String createDateString(int month, int date, int year)
+   {
+      String dateString = "";
+
+      if (isValidDate(month, date, year))
+      {
+         if (defaultType != YEAR)
+         {
+             if (month < 10)
+             {
+                dateString = "0";
+             }
+
+             dateString += String.valueOf(month);
+             dateString += "/";
+
+             if (date < 10)
+             {
+                dateString += "0";
+             }
+
+             dateString += String.valueOf(date);
+             dateString += "/";
+         }
+
+         if (year < 1000)
+         {
+            dateString += "0";
+            if (year < 100)
+            {
+               dateString += "0";
+               if (year < 10)
+               {
+                  dateString += "0";
+               }
+            }
+         }
+
+         dateString += String.valueOf(year);
+      }
+      else
+      {
+         if (defaultType == YEAR)
+         {
+             dateString = "1999";
+         }
+         else
+         {
+             dateString = "01/01/1999";
+         }
+      }
+
+      return dateString;
+   }
+
+   private void validateDateString(FocusEvent e)
+   {
+      if (!(warningMessageActive))
+      {
+         try
+         {
+            getDate();
+         }
+         catch (NumberFormatException nfe)
+         {
+            System.out.println("Invalid Date String!!!");
+            warningMessageActive = true;
+            JOptionPane.showMessageDialog(this, "Invald Date: " + getText(), "Warning", JOptionPane.WARNING_MESSAGE);
+            warningMessageActive = false;
+            if (defaultType == YEAR)
+            {
+                super.setText("1999");
+            }
+            else
+            {
+                super.setText("01/01/1999");
+            }
+         }
+      }
+   }
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/FormattedCellRenderer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/FormattedCellRenderer.java
new file mode 100644
index 0000000..b3e2a76
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/FormattedCellRenderer.java
@@ -0,0 +1,284 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Font;
+import java.text.Format;
+
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableCellRenderer;
+
+/**
+* A cell renderer for dealing with formatted content.
+* Subclasses can specify formats or colors or styles for specific values
+* or locations in the table by overridding getFormatForContext(),
+* getForegroundForContext() and/or getBackgroundForContext().
+*
+* @author michael@mpowers.net
+* @version $Revision: 904 $
+* $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+*/
+public class FormattedCellRenderer extends DefaultTableCellRenderer
+{
+    protected Format currentFormat, defaultFormat;
+    protected Color defaultForeground, defaultBackground;
+    protected Font defaultFont;
+
+/**
+* Default constructor with no specified format.
+*/
+    public FormattedCellRenderer()
+    {
+        this( (Format) null );
+    }
+
+/**
+* Constructor specifying a format for renderered content.
+*/
+   public FormattedCellRenderer( Format aFormat )
+    {
+        currentFormat = null;
+        defaultFormat = aFormat;
+        defaultForeground = super.getForeground();
+        defaultBackground = super.getForeground();
+    }
+
+/**
+* Returns the format currently in use to format cell content.
+* @return The Format that is currently being used.
+*/
+    public Format getFormat()
+    {
+        return defaultFormat;
+    }
+
+/**
+* Sets the format to be used to format cell content.
+*/
+    public void setFormat( Format aFormat )
+    {
+        defaultFormat = aFormat;
+    }
+
+/**
+* Overrides to retain the default foreground color,
+* much the same as the DefaultCellRenderer does.
+* We have to do this because DefaultCellRenderer's
+* ivars are private.
+*/
+    public void setForeground(Color c) {
+        super.setForeground(c);
+        defaultForeground = c;
+    }
+
+/**
+* Overrides to retain the default background color,
+* much the same as the DefaultCellRenderer does.
+* We have to do this because DefaultCellRenderer's
+* ivars are private.
+*/
+    public void setBackground(Color c) {
+        super.setBackground(c);
+        defaultBackground = c;
+    }
+
+/**
+* Overrides to retain the default font,
+* much the same as the DefaultCellRenderer does.
+* We have to do this because DefaultCellRenderer's
+* ivars are private.
+*/
+    public void setFont(Font f) {
+        super.setFont(f);
+        defaultFont = f;
+    }
+
+/**
+* Overridden to format the value with the appropriate Format.  If the
+* value cannot be formatted with the Format, the superclass method is called.
+* @param value An Object to be formatted.
+*/
+    protected void setValue(Object value)
+    {
+        if ( currentFormat != null )
+        {
+            try
+            {
+
+// if ( ( value instanceof Number ) && ( value.toString().indexOf( "E" ) != -1 ) )
+// {
+//     System.out.println( "FormattedCellRenderer.setValue: format = '" + currentFormat.getClass() + "'" );
+//     System.out.println( "FormattedCellRenderer.setValue: value = '" + value + "'" );
+//     System.out.println( "FormattedCellRenderer.setValue: double value = '" + ((Number)value).doubleValue() + "'" );
+//     System.out.println( "FormattedCellRenderer.setValue: float value = '" + ((Number)value).floatValue() + "'" );
+//     System.out.println( "FormattedCellRenderer.setValue: converted = '" + currentFormat.format( value ) + "'" );
+// }
+
+                // WORKAROUND: This works around what may be a rounding bug in DecimalFormat. (PR 256/297)
+                currentFormat.format( ZERO );
+
+                // DEBUG: code to test for weird one/zero problem (PR 256/297)
+                String result = currentFormat.format( value );
+/* above workaround seems to be working
+                if ( result.equals( "1" ) )
+                {
+                    System.out.println( "FormattedCellRenderer.setValue: Could be the ONE/ZERO problem!" );
+                    System.out.println( "FormattedCellRenderer.setValue: format = '" + currentFormat.getClass() + "'" );
+                    System.out.println( "FormattedCellRenderer.setValue: original value = '" + value + "'" );
+                    System.out.println( "FormattedCellRenderer.setValue: result = '" + result + "'" );
+                }
+*/
+                setText( result );
+
+
+//                setText( currentFormat.format( value ) );
+                return;
+            }
+            catch ( IllegalArgumentException exc )
+            {
+                // fall back on superclass implementation
+            }
+        }
+        super.setValue( value );
+    }
+    
+    // FIXME: remove this when possible
+    private static Double ZERO = new Double( 0.0 );
+
+/**
+* Overridden to call context delegate methods.
+*/
+    public Component getTableCellRendererComponent(JTable table, Object value,
+                     boolean isSelected, boolean hasFocus, int row, int column)
+    {
+        Format format;
+
+        // allow for context-sensitve formatting
+        format = getFormatForContext( table, value, isSelected, hasFocus, row, column );
+        if ( format != null )
+        {
+            currentFormat = format;
+        }
+        else
+        {
+            currentFormat = defaultFormat;
+        }
+
+        Color color;
+
+        // allow for context-sensitve foreground color
+        color = getForegroundForContext( table, value, isSelected, hasFocus, row, column );
+        if ( color != null )
+        {
+            super.setForeground( color );
+        }
+        else
+        {
+            super.setForeground( defaultForeground );
+        }
+
+        // allow for context-sensitve background color
+        color = getBackgroundForContext( table, value, isSelected, hasFocus, row, column );
+        if ( color != null )
+        {
+            super.setBackground( color );
+        }
+        else
+        {
+            super.setBackground( defaultBackground );
+        }
+
+        // have to call this here because super defaults to table's font
+        Component result =
+            super.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column );
+        // NOTE: DefaultTableCellRenderer returns itself.
+
+        // allow for context-sensitve font
+        Font font = getFontForContext( table, value, isSelected, hasFocus, row, column );
+        if ( font != null )
+        {
+            result.setFont( font );
+        }
+        else
+        {
+            result.setFont( defaultFont );
+        }
+
+        return result;
+
+    }
+
+/**
+* Override this method to provide a specific format for the
+* specific cell to be rendered by this component.  Any format
+* returned by this method will take precedence of the format
+* specified by setFormat(). <br><br>
+* This default implementation returns null.
+* @return A Format for this cell, or null to rely on the the
+* format specified by setFormat().
+*/
+    public Format getFormatForContext(JTable table, Object value,
+                 boolean isSelected, boolean hasFocus, int row, int column)
+    {
+        return null;
+    }
+
+/**
+* Override this method to provide a foreground color for the renderer.
+* Because the table specifies colors for selected cells,
+* these colors will only be used when renderering unselected cells. <br><br>
+* This default implementation returns null.
+* @return A Color for the foreground of the cell, or null to rely on
+* the table's default color scheme.
+*/
+    public Color getForegroundForContext(JTable table, Object value,
+                 boolean isSelected, boolean hasFocus, int row, int column)
+    {
+        return null;
+    }
+
+/**
+* Override this method to provide a background color for the renderer.
+* Because the table specifies colors for selected cells,
+* these colors will only be used when renderering unselected cells. <br><br>
+* This default implementation returns null.
+* @return A Color for the background of the cell, or null to rely on
+* the table's default color scheme.
+*/
+    public Color getBackgroundForContext(JTable table, Object value,
+                 boolean isSelected, boolean hasFocus, int row, int column)
+    {
+        return null;
+    }
+
+/**
+* Override this method to provide a font for the renderer.<br><br>
+* This default implementation returns null.
+* @return A Font for the cell, or null to rely on the table's default font.
+*/
+    public Font getFontForContext(JTable table, Object value,
+                 boolean isSelected, boolean hasFocus, int row, int column)
+    {
+        return null;
+    }
+
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/IconCellRenderer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/IconCellRenderer.java
new file mode 100644
index 0000000..8320d08
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/IconCellRenderer.java
@@ -0,0 +1,845 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.Point;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.util.Enumeration;
+import java.util.EventObject;
+import java.util.Vector;
+
+import javax.swing.Icon;
+import javax.swing.JButton;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JTable;
+import javax.swing.JTree;
+import javax.swing.ListCellRenderer;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+import javax.swing.border.EmptyBorder;
+import javax.swing.border.LineBorder;
+import javax.swing.event.CellEditorListener;
+import javax.swing.event.ChangeEvent;
+import javax.swing.table.TableCellEditor;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.tree.TreeCellEditor;
+import javax.swing.tree.TreeCellRenderer;
+
+/**
+* A cell renderer that displays icons in addition to text,
+* and additionally is an editor in case you want to click
+* the icon to trigger some kind of action.  
+* You probably should override both getStringForContext and
+* getIconForContext to achieve your desired results. 
+* To receive mouse clicks, set the same instance of the
+* renderer as the editor for the same component.<br><br>
+*
+* One notable addition is that this class is an action event
+* broadcaster.  ActionEvents are broadcast when the mouse is
+* clicked on the button with an action event containing a 
+* user-configurable string that defaults to CLICKED. <br><br>
+*
+* The renderer itself can be used as a JComponent if
+* you need something like a JLabel that allows you to click
+* on the icon.  You will want to call setIcon and setText
+* to configure the component since the renderer method would
+* not be called.  (If you add an instance of the renderer
+* to a container, you cannnot use the same instance as an
+* editor in a table, tree, or list.)
+*
+* @author michael@mpowers.net
+* @version $Revision: 904 $
+* $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+*/
+public class IconCellRenderer extends JPanel
+	implements TableCellRenderer, TableCellEditor, 
+        TreeCellRenderer, TreeCellEditor, ListCellRenderer,
+        Runnable, ActionListener, MouseListener 
+{	
+	public static final String CLICKED = "CLICKED";
+	
+	/**
+	* The panel that is re-used to render everything.
+	* This is returned by getRendererForContext.
+	*/
+    protected JPanel rendererPanel;
+	protected JLabel rendererLabel;
+    protected JButton rendererButton;
+
+	/**
+	* The panel that is used to receive mouse clicks.
+	* It must be a different component from rendererPanel.
+	* This is returned by getEditorForContext.
+	*/
+    protected JPanel editorPanel;
+	protected JLabel editorLabel;
+    protected JButton editorButton;
+	
+	private Object lastKnownValue;
+    private JComponent lastKnownComponent;
+		
+	// do as DefaultTableCellRenderer does
+	private Border noFocusBorder;
+	private Border treeFocusBorder;
+	private Color unselectedForeground;
+	private Color unselectedBackground;
+	
+	private Vector actionListeners;
+	private String actionCommand;
+	private Vector cellEditorListeners;
+    
+    private boolean editable;
+    private boolean clickable;
+    				
+    /**
+    * Default constructor.
+    */
+    public IconCellRenderer()
+    {                                                
+        editable = true;
+        clickable = true;
+        
+        noFocusBorder = new EmptyBorder(1, 1, 1, 1);
+        treeFocusBorder = new LineBorder( 
+            UIManager.getColor("Tree.selectionBorderColor") );
+		setActionCommand( CLICKED );
+
+        rendererPanel = new JPanel();
+        rendererPanel.setLayout( new GridBagLayout() );
+
+        editorPanel = this;
+        editorPanel.setLayout( new GridBagLayout() );
+                        
+        // set up constraints
+        GridBagConstraints imageConstraints = new GridBagConstraints();
+        imageConstraints.gridx = 0;
+        GridBagConstraints labelConstraints = new GridBagConstraints();
+        labelConstraints.fill = GridBagConstraints.HORIZONTAL;
+        labelConstraints.gridx = 1;
+        labelConstraints.weightx = 1.0;
+        labelConstraints.ipadx = 1;
+        labelConstraints.insets = new Insets( 0, 1, 0, 0 ); // sweat the pixel
+
+        // make the editor panel go away when not in use
+        // and pass through all mouse events to container        
+        
+        //this is not very useful since editorLabel and editorButton
+        //get all of the events        
+        editorPanel.addMouseListener( this );
+        
+		rendererLabel = new JLabel();
+		rendererLabel.setOpaque( false );
+        rendererPanel.add( rendererLabel, labelConstraints );
+
+		editorLabel = new JLabel();
+        editorLabel.setText( "" ); // default state
+		editorLabel.setOpaque( false );
+        editorPanel.add( editorLabel, labelConstraints );
+
+		unselectedForeground = rendererLabel.getForeground();
+		unselectedBackground = rendererLabel.getBackground();
+        
+        rendererButton = new JButton();
+        rendererButton.setBorder( null );
+        rendererButton.setBorderPainted( false );
+        rendererButton.setContentAreaFilled( false );
+        rendererButton.setFocusPainted( false );
+        rendererButton.setMargin( new Insets( 0, 0, 0, 0 ) );
+        rendererPanel.add( rendererButton, imageConstraints );
+        
+        editorButton = new JButton();
+        editorButton.setEnabled( clickable ); // default state
+        editorButton.setIcon( null ); // default state
+        editorButton.setBorder( null );
+        editorButton.setBorderPainted( false );                                            
+        editorButton.setContentAreaFilled( false );
+        editorButton.setFocusPainted( false );
+        editorButton.setMargin( new Insets( 0, 0, 0, 0 ) );        
+        editorPanel.add( editorButton, imageConstraints );
+
+        editorButton.addActionListener( this );      
+
+        //add these in order to dispatch the MouseEvents
+        //to the lastKnownComponent, and proper management of
+        //DnD operations
+        editorLabel.addMouseListener( this );    
+        editorButton.addMouseListener( this );                    
+    }
+    
+/**
+* Returns the text string currently displayed in the editor component.
+*/    
+    public String getText() 
+    {
+        return editorLabel.getText();
+    }
+    
+/**
+* Sets the text string displayed in the editor component.
+* Default is an empty string.
+*/
+    public void setText( String aString )
+    {
+        editorLabel.setText( aString );
+    }
+
+/**
+* Returns the icon currently displayed in the editor component.
+*/    
+    public Icon getIcon() 
+    {
+        return editorButton.getIcon();
+    }
+    
+/**
+* Sets the icon currently displayed in the editor component.
+* Default is null.
+*/
+    public void setIcon( Icon anIcon )
+    {
+        editorButton.setIcon( anIcon );
+        if ( !isClickable() )
+        {
+            editorButton.setDisabledIcon( anIcon );
+        }
+    }
+
+/**
+* Returns whether the editor component's label text is editable.
+*/    
+    public boolean isEditable() 
+    {
+        return editable;
+    }
+    
+/**
+* Sets whether the editor component's label text is editable.
+* Default is true.  Editable text is not yet implemented.
+*/
+    public void setEditable( boolean isEditable )
+    {
+        editable = isEditable;
+    }
+
+/**
+* Returns whether the editor component's icon is clickable.
+*/    
+    public boolean isClickable() 
+    {
+        return clickable;
+    }
+    
+/**
+* Sets whether the editor component's icon is clickable.
+* Default is true.
+*/
+    public void setClickable( boolean isClickable )
+    {
+        clickable = isClickable;
+        editorButton.setEnabled( clickable );
+    }
+
+/**
+* Returns the component from getRendererForContext.
+*/    
+    public Component getListCellRendererComponent(JList list,
+                                              Object value,
+                                              int index,
+                                              boolean isSelected,
+                                              boolean cellHasFocus)
+    {
+        lastKnownComponent = list;
+        return getRendererForContext(
+            list, value, index, 0, isSelected, cellHasFocus, false, true );
+    }
+
+/**
+* Returns the component from getRendererForContext.
+*/
+    public Component getTableCellRendererComponent(JTable table, Object value,
+                     boolean isSelected, boolean hasFocus, int row, int column)
+    {
+        lastKnownComponent = table;
+		return getRendererForContext( 
+			table, value, row, column, isSelected, hasFocus, false, true );
+    }
+
+/**
+* Returns the component from getRendererForContext.
+*/
+    public Component getTreeCellRendererComponent(JTree tree,
+                                              Object value,
+                                              boolean selected,
+                                              boolean expanded,
+                                              boolean leaf,
+                                              int row,
+                                              boolean hasFocus)
+    {                
+        lastKnownComponent = tree;
+		return getRendererForContext( 
+			tree, value, row, 0, selected, hasFocus, expanded, leaf );
+    }
+	
+/**
+* Returns getEditorForContext with the same parameters with hasFocus true.
+*/
+	public Component getTableCellEditorComponent(JTable table,
+		Object value, boolean isSelected, int row, int column)
+	{
+		lastKnownValue = value;
+        lastKnownComponent = table;
+		return getEditorForContext( 
+			table, value, row, column, isSelected, true, false, true );
+	}
+
+/**
+* Returns the component from getEditorForContext with hasFocus true.
+*/
+    public Component getTreeCellEditorComponent(JTree tree,
+                                                Object value,
+                                                boolean isSelected,
+                                                boolean expanded,
+                                                boolean leaf,
+                                                int row)
+    {
+
+        
+        lastKnownValue = value;
+        lastKnownComponent = tree;
+		
+		return getEditorForContext( 
+			tree, value, row, 0, isSelected, true, expanded, leaf );
+    }                                                
+                                                
+/**
+* This default implementation returns a JPanel that is configured by
+* calling configureComponentForContext.  
+* @return An component that is used to render content.
+*/
+    public Component getRendererForContext(
+        JComponent container, Object value,
+        int row, int column,
+        boolean isSelected, boolean hasFocus, 
+        boolean isExpanded, boolean isLeaf )
+    {
+
+		
+		configureComponentForContext( rendererPanel, rendererButton, rendererLabel, 
+            container, value, row, column,
+			isSelected, hasFocus, isExpanded, isLeaf );
+		return rendererPanel;
+    }
+
+/**
+* This method returns a separate component that should be visually
+* identical to the renderer component.  We can't simply reuse the
+* renderer component because the renderer is still used to paint
+* the table while the editor component is displayed. Clicks are 
+* received on this component.
+* This default implementation returns a JPanel that is configured by
+* calling configureComponentForContext.  
+* @return A component used to receive clicks on the cell.
+*/
+    public Component getEditorForContext(
+        JComponent container, Object value,
+        int row, int column,
+        boolean isSelected, boolean hasFocus, 
+        boolean isExpanded, boolean isLeaf )
+    {
+		configureComponentForContext( editorPanel, editorButton, editorLabel, 
+            container, value, row, column,
+			true, hasFocus, isExpanded, isLeaf ); // editor should always be selected
+
+		return editorPanel;
+    }
+
+/**
+* Called to configure components
+*/ 
+	protected void configureComponentForContext(
+        JPanel component, JButton iconButton, JLabel label, 
+        JComponent container, Object value, 
+        int row, int column,
+        boolean isSelected, boolean hasFocus, 
+        boolean isExpanded, boolean isLeaf )
+	{
+        if (hasFocus) 
+        {
+            if ( container instanceof JTable )
+            {
+                component.setBorder( 
+                    UIManager.getBorder("Table.focusCellHighlightBorder") );
+            }
+            else
+            {
+                component.setBorder( noFocusBorder );   
+            }
+
+            if ( container instanceof JTree ) // was: (false)
+            {   
+                label.setBorder( treeFocusBorder );
+            }
+            else
+            {
+                label.setBorder( noFocusBorder );
+            }
+        } 
+        else 
+        {
+            label.setBorder(noFocusBorder);
+            component.setBorder(noFocusBorder);
+        }
+        
+        if (isSelected) 
+        {
+            if ( container instanceof JTree )
+            {
+                label.setOpaque( true );
+                label.setForeground(UIManager.getColor("Tree.selectionForeground"));
+                label.setBackground(UIManager.getColor("Tree.selectionBackground"));
+                component.setBackground(container.getBackground());
+            }
+            else if ( container instanceof JTable )
+            {
+                label.setOpaque( false );
+                label.setForeground( ((JTable)container).getSelectionForeground() );
+                component.setBackground(((JTable)container).getSelectionBackground());
+            }
+            else
+            {
+                label.setOpaque( false );
+                label.setForeground(UIManager.getColor("Table.selectionForeground"));
+                component.setBackground(UIManager.getColor("Table.selectionBackground"));
+            }
+        }
+        else 
+        {
+            label.setOpaque( false );
+            label.setForeground(container.getForeground());
+            component.setBackground(container.getBackground());
+        }
+
+        label.setFont(container.getFont());
+
+        Icon icon = getIconForContext( 
+			container, value, row, column, isSelected, hasFocus, isExpanded, isLeaf );
+        iconButton.setIcon( icon );
+        if ( !isClickable() )
+        {
+            iconButton.setDisabledIcon( icon );
+        }
+
+        String text = getStringForContext( 
+			container, value, row, column, isSelected, hasFocus, isExpanded, isLeaf );
+            
+		if ( ( text == null ) || ( "".equals( text ) ) )
+		{
+            if ( ! label.getText().equals( "" ) )
+    			label.setText( "" );
+		}
+		else
+		{
+            if ( ! label.getText().equals( text ) )
+    			label.setText( text );
+		}
+	}
+	
+/**
+* Override this method to provide an icon for the renderer.
+* This default implementation returns null.
+* @return An icon to be displayed in the cell, or null to omit the
+* icon from the cell.
+*/
+    public Icon getIconForContext(
+        JComponent container, Object value,
+        int row, int column,
+        boolean isSelected, boolean hasFocus, 
+        boolean isExpanded, boolean isLeaf )
+    {
+        return null;
+    }
+
+/**
+* Override this method to provide a string for the renderer.
+* This default implementation returns toString on the value parameter,
+* or null if the value is null.
+* @return A string to be displayed in the cell.
+*/
+    public String getStringForContext(
+        JComponent container, Object value,
+        int row, int column,
+        boolean isSelected, boolean hasFocus, 
+        boolean isExpanded, boolean isLeaf )
+    {
+		if ( value == null ) return null;
+        return value.toString();
+    }
+	
+	/**
+	* Adds the specified listener to the list of listeners
+	* to be notified when the button receives a click.
+	*/
+	public void addActionListener( ActionListener aListener )
+	{
+		if ( actionListeners == null ) 
+		{
+			actionListeners = new Vector( 2 );	
+		}
+		actionListeners.add( aListener );
+	}
+	
+	/**
+	* Removes the specified listener from the list of listeners
+	* to be notified when the button receives a click.
+	*/
+	public void removeActionListener( ActionListener aListener )
+	{
+		actionListeners.remove( aListener );
+	}
+	
+	/**
+	* Broadcasts the specified action event to all listeners.
+	*/
+	protected void fireActionEvent( ActionEvent anActionEvent )
+	{
+		if ( actionListeners == null ) return;
+		// vector's enumeration is not fail-fast
+		Enumeration e = actionListeners.elements();
+		while ( e.hasMoreElements() )
+		{
+			((ActionListener)e.nextElement()).actionPerformed( anActionEvent );
+		}
+	}
+	
+	/**
+	* Returns the action command broadcast when this icon
+    * receives a click.  Defaults to CLICKED.
+	*/
+	public String getActionCommand()
+	{
+		return actionCommand;
+	}
+
+	/**
+	* Sets the action command broadcast when this table
+	* receives a double click.
+	*/	
+	public void setActionCommand( String anActionCommand )
+	{
+		actionCommand = anActionCommand;	
+	}
+	
+// interface CellEditor
+
+	/**
+	* Returns lastKnownValue, although this should not be called.
+	*/
+	public Object getCellEditorValue()
+	{
+		return lastKnownValue;
+	}
+	
+	/**
+	* Returns true.
+	*/
+	public boolean isCellEditable(EventObject anEvent)
+	{
+        return true;
+	}
+	
+	/**
+	* Returns true.
+	*/
+	public boolean shouldSelectCell(EventObject anEvent)
+	{
+		return true;
+	}
+	
+	/**
+	* Fires an editing stopped event and returns true.
+	*/
+	public boolean stopCellEditing()
+	{
+		ChangeEvent event = new ChangeEvent( this );
+		if ( cellEditorListeners != null )
+		{
+			// vector's enumeration is not fail-fast
+			Enumeration e = cellEditorListeners.elements();
+			while ( e.hasMoreElements() )
+			{
+                // broadcast editing cancelled since no value is edited
+				((CellEditorListener)e.nextElement()).editingCanceled( event );
+			}
+		}
+        lastKnownComponent = null;		
+		return true;
+	}
+	
+	/**
+	* Fires an editing cancelled event and returns true.
+	*/
+	public void cancelCellEditing()
+	{                
+		//HACK: cancelCellEditing() causes for the dragGesture
+		//to be NOT recognized AT ALL since on the next MOUSE_PRESSED
+		//the cell editor first needs to startEditing() [if in the tree
+		//the CellEditorListener is a BasicTreeUI class] 
+		//(before the drag gesture event can be recognized).        
+        //Also the lastKnownComponent should not be set to null, 
+        //none of the mouse events won't dispathced to the lastKnownComponent
+        //in that case.		
+		
+		//Not calling it at all does seem to fix it, but what are the
+		//consequences???
+		//Trying to workaround this might solve it, but it introduces having
+		//an extra listener (a MouseMotionListnener), which might be wasteful
+		//(i.e. only if a Mouse_dragged event has been initiated, but DragGesture
+		//hasn't been recognized, postpone calling this till finish the DnD event)
+		//But what if do DnD and not exited ??? The mouseExited() is not called
+		//anyway until the DnD event is done.				
+				        
+		ChangeEvent event = new ChangeEvent( this );
+		if ( cellEditorListeners == null ) return;
+		// vector's enumeration is not fail-fast
+		Enumeration e = cellEditorListeners.elements();
+		
+		while ( e.hasMoreElements() )
+		{            
+			((CellEditorListener)e.nextElement()).editingCanceled( event );
+		}                
+        
+        //DO not nullify this 
+        lastKnownComponent = null;                       
+	}
+	
+	/**
+	* Adds the specified listener to the list of listeners
+	* to be notified when the table receives a double click.
+	*/
+	public void addCellEditorListener( CellEditorListener aListener )
+	{		
+		if ( cellEditorListeners == null ) 
+		{
+			cellEditorListeners = new Vector( 2 );	
+		}
+		cellEditorListeners.add( aListener );	
+	}
+	
+	/**
+	* Removes the specified listener from the list of listeners
+	* to be notified when the table receives a double click.
+	*/
+	public void removeCellEditorListener( CellEditorListener aListener )
+	{
+		cellEditorListeners.remove( aListener );
+	}
+    
+// interface ActionListener
+    
+    /**
+    * Puts ourself on the end of the event queue for 
+    * firing our action event to all listeners.
+    */
+    public void actionPerformed( ActionEvent evt )
+    {        
+        //commented out in order NOT to set lastKnownComponent to null, since
+        //if this object is inside a table or tree, relying on getCellEditorValue() 
+        //to return the currently edited object
+        //cancelCellEditing();        
+        
+        SwingUtilities.invokeLater( this );
+    }
+	
+// interface Runnable
+	
+	/**
+	* Fires the action event to all listeners.  
+	* This is triggered by a click on the icon.
+	*/
+	public void run()
+	{
+		fireActionEvent( new ActionEvent( this, 0, getActionCommand() ) );	
+	}
+
+// interface MouseListener 
+    
+    /**
+    * Passes through editor mouse clicks to last known component.
+    * (left click only)
+    */
+	public void mouseClicked(MouseEvent e)
+    {                        
+        if(lastKnownComponent != null){
+            Object source = e.getSource();            
+            if(source != null)
+            {
+                if(source == editorPanel)
+                {
+                    lastKnownComponent.dispatchEvent(                 
+                            SwingUtilities.convertMouseEvent(                    
+                                editorPanel, e, lastKnownComponent ) );                     
+
+                }                
+                else if(source == editorLabel)
+                {
+                    lastKnownComponent.dispatchEvent(                 
+                        SwingUtilities.convertMouseEvent(                    
+                            editorLabel, e, lastKnownComponent ) );         
+                }           
+
+                else if(source == editorButton)
+                {
+                    lastKnownComponent.dispatchEvent(                 
+                        SwingUtilities.convertMouseEvent(                    
+                            editorButton, e, lastKnownComponent ) );         
+                }           
+            }                
+        }                
+    }
+
+    /**
+    * Passes through editor right-mouse (popup trigger) mouse events to last known component.
+    * Needed for possible displaying of popup menus on right click 
+    */
+    public void mousePressed(MouseEvent e)
+    {                
+        if ( e.isPopupTrigger() )
+        {
+            if(lastKnownComponent != null)
+            {
+                Object source = e.getSource();            
+                if(source != null)
+                {
+                    if(source == editorPanel)
+                    {                     
+                        lastKnownComponent.dispatchEvent(                 
+                                SwingUtilities.convertMouseEvent(                    
+                                    editorPanel, e, lastKnownComponent ) );                     
+                    }
+                    else if(source == editorLabel)
+                    {
+                        lastKnownComponent.dispatchEvent(                 
+                            SwingUtilities.convertMouseEvent(                    
+                                editorLabel, e, lastKnownComponent ) );         
+                    }           
+    
+                    else if(source == editorButton)
+                    {   
+                        lastKnownComponent.dispatchEvent(                 
+                            SwingUtilities.convertMouseEvent(                    
+                                editorButton, e, lastKnownComponent ) );         
+                    }           
+                }                
+            }
+        }                
+    }
+
+    /**
+    * Does nothing.
+    */
+    public void mouseReleased(MouseEvent e)
+    {                      
+        if ( e.isPopupTrigger() )
+        {
+            if(lastKnownComponent != null){        
+    
+                Object source = e.getSource();            
+                if(source != null)
+                {
+                    if(source == editorPanel) 
+                    {                    
+                        lastKnownComponent.dispatchEvent(                 
+                                SwingUtilities.convertMouseEvent(                    
+                                    editorPanel, e, lastKnownComponent ) );                     
+                    }            
+        
+                    else if(source == editorLabel) 
+                    {
+                        lastKnownComponent.dispatchEvent(                 
+                            SwingUtilities.convertMouseEvent(                    
+                                editorLabel, e, lastKnownComponent ) );         
+                    }           
+    
+                    else if(source == editorButton) 
+                    {
+                        lastKnownComponent.dispatchEvent(                 
+                            SwingUtilities.convertMouseEvent(                    
+                                editorButton, e, lastKnownComponent ) );         
+                    }           
+                }                
+            }
+        }                
+    }
+
+    /**
+    * Does nothing.
+    */
+    public void mouseEntered(MouseEvent e)
+    {
+    }
+    
+    /**
+    * Cancels cell editing.
+    */
+    public void mouseExited(MouseEvent e)
+    {        
+        Object source = e.getSource();
+        if(source != null && source instanceof JComponent){
+            //need to convert the Point from the source's coordinate system to editorPanel's coordinate system.
+            //(note that simple editorPanel.contains(e.getPoint()) fails if source is editorButton)
+            
+            Point convertedPoint = SwingUtilities.convertPoint((JComponent) source, e.getPoint(), editorPanel); 
+            
+            //check if exited from editorButton, but still inside the editorPanel (works for editorLabel as well)            
+            if(!editorPanel.contains(convertedPoint)){
+
+                //This was getting called before, but it interfers with the DnD operation
+                cancelCellEditing();
+            }
+        }      
+    }
+    
+    /* This might be redundant    
+    public void cleanUp(){
+        
+        //since cancelCellEditing() was never called call it now                
+        cancelCellEditing();
+        stopCellEditing();
+        
+        editorButton.removeActionListener( this );      
+        editorPanel.removeMouseListener( this ); 
+        editorLabel.removeMouseListener( this );    
+        editorButton.removeMouseListener( this );                            
+        lastKnownComponent = null;
+        lastKnownValue = null;
+    }        
+    */
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ImagePanel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ImagePanel.java
new file mode 100644
index 0000000..cdaa218
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/ImagePanel.java
@@ -0,0 +1,104 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Image;
+import java.awt.image.ImageObserver;
+
+import javax.swing.JPanel;
+
+/**
+* A JPanel that renders an image, tiling as necessary to
+* fill the panel.
+* The preferred size of the panel is the size of the image
+* and will change until the image is fully loaded, so using
+* a media tracker is recommended.
+*
+* @author michael@mpowers.net
+* @version $Revision: 904 $
+*/
+public class ImagePanel extends JPanel implements ImageObserver
+{    
+	protected Image image;
+	protected int imageWidth, imageHeight;
+	
+    public ImagePanel()
+    {
+		this( null );
+    }
+	
+	public ImagePanel( Image anImage )
+	{
+		image = anImage;	
+		if ( anImage != null )
+		{
+            prepareImage( image, this ); 
+			// these may return -1
+			imageWidth = image.getWidth( this ); 
+			imageHeight = image.getHeight( this );
+		}
+		else
+		{
+			imageWidth = 0;
+			imageHeight = 0;
+		}
+	}
+	
+	protected void paintComponent(Graphics g)
+	{
+		if ( ( image != null ) && ( imageWidth > 0 ) && ( imageHeight > 0 ) )
+		{
+			int width = getWidth();
+			int height = getHeight();
+			
+			for ( int x = 0; x < width; x += imageWidth )
+			{
+				for ( int y = 0; y < height; y += imageHeight )
+				{
+					g.drawImage( image, x, y, 
+						imageWidth, imageHeight, 
+						getBackground(), this );		
+				}
+			}
+		}
+	}
+    
+	public boolean imageUpdate(Image img,
+	   int infoflags,
+	   int x,
+	   int y,
+	   int width,
+	   int height)
+	{
+		imageWidth = width;
+		imageHeight = height;
+		setPreferredSize( new Dimension( width, height ) );
+		revalidate();	
+		repaint();
+	
+		if ( ( infoflags & ImageObserver.ALLBITS ) == ImageObserver.ALLBITS )
+		{
+			return false;	
+		}
+		return true;
+	}
+	
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/InfoPanel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/InfoPanel.java
new file mode 100644
index 0000000..55c1e36
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/InfoPanel.java
@@ -0,0 +1,1693 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.AWTEventMulticaster;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.GridLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.beans.BeanInfo;
+import java.beans.Introspector;
+import java.beans.MethodDescriptor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.Box;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.SwingConstants;
+
+/**
+* InfoPanel uses labels and textfields (or any other component - see below)
+* to display a list of keys and values in a well-aligned and consistent manner,
+* conforming to alignment and pixel spacing in the java look and feel 
+* <a href="http://java.sun.com/products/jlf/dg/higg.htm#55417">design guidelines</a>. 
+* <BR><BR>
+*
+* Each key is displayed in a label to the left of the component that contains
+* the corresponding value.  Each row is displayed starting at the top of the
+* component's available area.  Each row's height is the maximum preferred
+* height of its components and the field itself gets as much of the width as
+* it can, dependent on the length of the longest label. <BR><BR>
+*
+* The values in the fields can be editable, and the
+* current value can be retrieved using the key - for this reason, unique keys
+* are recommended. <BR><BR>
+*
+* As a convenience, push buttons may be placed across the
+* bottom of the panel in a manner similar to ButtonPanel. <BR><BR>
+*
+* The panel forwards any ActionEvents generated by the components and
+* buttons on it to all registered listeners. <BR><BR>
+*
+* Optionally, any component can be used instead of a textfield.
+* However, <code>get/setValueForKey()</code> and <code>get/setEditable()</code>
+* may not work for those components.  Use <code>getComponentForKey()</code> to
+* access them instead.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+* $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+*/
+public class InfoPanel extends JPanel implements ActionListener
+{
+/**
+* Special label for an empty pair - a label and component
+* that take up space but are hidden from view.  This might
+* be useful for achieving certain layouts.
+*/
+    public static final String HIDDEN = "(hidden)";
+
+    /** Cache for the introspectComponent method */
+    private static Map _method_cache =
+      Collections.synchronizedMap( new HashMap(30) );
+
+    protected Container listContainer = null;
+    protected int hgap;    // set in constructor
+    protected int vgap;    // set in constructor
+    protected int margin;  // set in constructor
+    protected int columns; // set in constructor
+    protected List fields = null;
+    protected List labels = null;
+    protected List fieldSpacers = null; 
+    protected ButtonPanel buttonPanel = null;
+    protected boolean isEditable = true;
+    protected String prefix;
+    protected String postfix;
+	protected int labelAnchor;
+	protected int labelAlign;
+//    protected Component marginStrut = null;
+
+    // for action multicasting
+    protected ActionListener actionListener = null;
+    
+/**
+* Constructs an empty InfoPanel.
+*/
+    public InfoPanel()
+    {
+        hgap = 12;   // per java l&f guidelines
+        vgap = 6;    // java l&f says 11
+        columns = 1; // default columns
+        margin = 0;  // default margin: none
+        prefix = ""; // default prefix: none
+        postfix = ":"; // per java l&f guidelines
+        fields = new ArrayList();
+        labels = new ArrayList();
+		labelAnchor = GridBagConstraints.NORTHWEST; 
+			// per java l&f guidelines (CENTER is nicer)
+		labelAlign = SwingConstants.LEFT; 
+			// per java l&f guidelines
+            
+        doInitialLayout();
+    }
+
+/**
+* Constructs an InfoPanel with the specified labels
+* each paired with a blank textfield.
+* @param labelArray An Array containing the labels in the
+* order in which they should appear from top to bottom.
+* A null value produces an empty panel.
+*/
+    public InfoPanel( String[] labelArray )
+    {
+        this();
+        setLabels( labelArray );
+    }
+
+/**
+* Creates a set of labels and empty textfields after first
+* clearing all existing components on the panel.
+* @param labelArray An Array containing the labels in the order
+* in which they should appear from top to bottom.  A null
+* value will clear the panel.
+*/
+    public void setLabels( String[] labelArray )
+    {
+        removeAll();
+        if ( labelArray == null ) return; // null clears panel
+        for ( int i = 0; i < labelArray.length; i++ )
+        {
+            addPair( labelArray[i], new JTextField() );
+        }
+    }
+
+/**
+* Retrieves the labls for the components on the panel
+* in the order in which they are displayed from top WIDTH bottom.
+* These are the keys used to reference values or to reference
+* the components directly.
+* @return An Array of Strings containing the labels.
+*/
+    public String[] getLabels()
+    {
+        int length = fields.size();
+        String[] labelArray = new String[ length ];
+        for ( int i = 0; i < length; i++ )
+        {
+            labelArray[i] = ((Component)fields.get(i)).getName();
+        }
+        return labelArray;
+    }
+	
+/**
+* Retrieves the constant used to anchor the labels in place.
+* The default value is GridBagConstraints.NORTHWEST.
+*/
+	public int getLabelAnchor()
+	{
+		return labelAnchor;
+	}
+
+/**
+* Sets the constant used to anchor the labels in place
+* and reflows the layout.
+* @param anAnchorConstant An anchor constant from
+* GridBagConstraints.
+*/
+	public void setLabelAnchor( int anAnchorConstant )
+	{
+		labelAnchor = anAnchorConstant;	
+		updateLabels();
+	}
+
+/**
+* Retrieves the constant used to align the labels in place.
+* The default value is GridBagConstraints.CENTER.
+*/
+	public int getLabelAlignment()
+	{
+		return labelAlign;
+	}
+
+/**
+* Sets the constant used to align the labels in place
+* and reflows the layout.
+* @param anAlignmentConstant LEFT, CENTER, or RIGHT constants
+* from SwingUtilities.
+*/
+	public void setLabelAlignment( int anAlignmentConstant )
+	{
+		labelAlign = anAlignmentConstant;	
+		updateLabels();
+	}
+    
+/**
+* Factory method for creating panel spacers.
+* This implementation returns a JPanel with
+* opaque set to false.  Override to customize.
+*/    
+    public JPanel createPanel()
+    {
+        JPanel result = new JPanel();
+        result.setOpaque( false );
+        return result;
+    }
+
+/**
+* This method is responsible for the initial layout of the panel.
+* All labels and textfields will later added to listContainer.
+* This method is responsible for initializing listContainer.
+*/
+    protected void doInitialLayout()
+    {
+        listContainer = createPanel();
+        listContainer.setLayout( new BetterGridBagLayout() );
+        this.setLayout( new BorderLayout() ); 
+        this.add( listContainer, BorderLayout.NORTH ); 
+
+        //listContainer.setBackground( Color.blue ); // useful for testing
+        //this.setBackground( Color.red );
+    }
+
+/**
+* Changes the horizontal spacing between the label and the components in the panel.
+* Note: Assumes listContainer uses a GridBagLayout.
+* @param newHgap the new spacing, in pixels.  May not be negative.
+*/
+    public void setHgap( int newHgap )
+    {
+        if ( newHgap < 0 ) return; // may not be negative
+        this.hgap = newHgap;
+        updateGaps();
+        this.revalidate();
+        this.repaint();
+
+    }
+
+/**
+* Gets the current horizontal spacing between components.
+* @return the current horizontal spacing, in pixels.
+*/
+    public int getHgap()
+    {
+        return this.hgap;
+    }
+
+/**
+* Changes the vertical spacing between components in the panel.
+* Note: Assumes listContainer uses a GridBagLayout.
+* @param newVgap the new spacing, in pixels.  May not be negative.
+*/
+    public void setVgap( int newVgap )
+    {
+        if ( newVgap < 0 ) return; // may not be negative
+        this.vgap = newVgap;
+        updateGaps();
+        this.revalidate();
+        this.repaint();
+
+    }
+
+/**
+* Gets the current vertical spacing between components.
+* @return the current vertical spacing, in pixels.
+*/
+    public int getVgap()
+    {
+        return this.vgap;
+    }
+
+/**
+* Sets the minimum width for the labels column.
+* This left margin will grow if one of the labels
+* is wider than this value.
+* Note: assumes GridBagLayout.
+* @param newMargin the new minimum margin in pixels.  May not be negative.
+*/
+    public void setMargin( int newMargin )
+    {
+        if ( newMargin < 0 ) return; // may not be negative
+        this.margin = newMargin;
+
+        if ( listContainer.getLayout() instanceof GridBagLayout )
+        {
+            GridBagLayout gridBag = (GridBagLayout) listContainer.getLayout();
+            GridBagConstraints constraints = null;
+            Component c = null;
+            int count = listContainer.getComponentCount();
+            for ( int i = 0; i < count; i++ )
+            {
+                c = listContainer.getComponent( i );
+                constraints = gridBag.getConstraints( c );
+                if ( constraints.gridy == 0 && constraints.gridx % 2 == 0 )
+                { // if this is a label spacer 
+                    // replace it with an appropriately sized box
+                    listContainer.remove( c );
+                    listContainer.add( Box.createHorizontalStrut( this.margin ), constraints );
+                }
+            }
+        }
+
+        this.revalidate();
+        this.repaint();
+
+    }
+
+/**
+* Gets the current minimum margin for the labels column.
+* @return the current minimum margin in pixels.
+*/
+    public int getMargin()
+    {
+        return this.margin;
+    }
+
+/**
+* Sets the number of columns for the panel.
+* Label/Component pairs will start from the top left
+* and fill in to the right before wrapping to the
+* next row.  The default number of columns is one.
+* Note: assumes GridBagLayout.
+* @param newColumns the new number of columns.  May not be less than one.
+*/
+    public void setColumns( int newColumns )
+    {
+        if ( newColumns < 1 ) return; // may not be less than one.
+        int oldColumns = this.columns;
+        this.columns = newColumns;
+
+        if ( listContainer.getLayout() instanceof GridBagLayout )
+        {
+            GridBagLayout gridBag = (GridBagLayout) listContainer.getLayout();
+            int count = listContainer.getComponentCount();
+            Component[] components = listContainer.getComponents();
+            GridBagConstraints[] constraints = new GridBagConstraints[ components.length ];
+            for ( int i = 0; i < components.length; i++ )
+            {
+                constraints[i] = gridBag.getConstraints( components[i] );
+            }
+            listContainer.removeAll();
+            for ( int i = 0; i < components.length; i++ )
+            {
+                if ( constraints[i].gridy != 0 )
+                { // ignore first row which is reserved for spacers.
+
+                    // translate component to new position
+                    // (columns*2 accounts for two grid columns for one "actual" column)
+                    int index = ( constraints[i].gridy - 1 ) * oldColumns*2 + constraints[i].gridx;
+                    constraints[i].gridy = ( index / (newColumns*2) ) + 1;
+                    constraints[i].gridx = index % (newColumns*2) ;
+                    listContainer.add( components[i], constraints[i] );
+                }
+            }
+            createSpacers(); // replace the spacers
+            updateGaps();
+        }
+
+        this.revalidate();
+        this.repaint();
+
+    }
+
+/**
+* Sets the vertical weight used for determining how to distribute additional
+* vertical space in the component. 
+* @param aComponent Key that exists in the layout.
+* @return weighty The weight of the component, or -1.0 if not found.
+*/
+    public double getVerticalWeightForKey( String key )
+    {
+        Container c = getCompositeComponentForKey( key );
+        if ( c == null ) return -1.0;
+        if ( ! ( listContainer.getLayout() instanceof GridBagLayout ) ) return -1.0;
+        GridBagLayout layout = (GridBagLayout) listContainer.getLayout();
+        GridBagConstraints gbc = layout.getConstraints( c );
+        return gbc.weighty;
+    }
+    
+/**
+* Sets the vertical weight used for determining how to distribute additional
+* vertical space in the component.  By default, all weights are zero, so each
+* component gets its preferred height.  If any weights are specified, then
+* additional space is allocated to those components proportionately.
+* @param aComponent Key that exists in the layout.
+* @param weighty The new weight.
+*/
+    public void setVerticalWeightForKey( String key, double weighty )
+    {
+        Container c = getCompositeComponentForKey( key );
+        if ( c == null ) return;
+        if ( ! ( listContainer.getLayout() instanceof GridBagLayout ) ) return;
+        GridBagLayout layout = (GridBagLayout) listContainer.getLayout();
+        GridBagConstraints gbc = layout.getConstraints( c );
+        gbc.weighty = weighty;
+        layout.setConstraints( c, gbc );
+        // handle adding on-the-fly
+        updateGaps();
+        this.revalidate();
+        this.repaint();
+    }
+    
+/**
+* Gets the current number of columns.
+* @return the current number of columns.
+*/
+    public int getColumns()
+    {
+        return this.columns;
+    }
+
+/**
+* Appends a label containing a key and the specified component
+* to the bottom of the panel.  Any registered action listeners
+* will receive action events from the component - the key corresponding
+* to the component will be used as the action command.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param component A component that will be placed next to the label.
+* If null, a blank JPanel will be used.
+*/
+	public void addPair( String key, Component component )
+	{
+		addRow( key, new Component[] { component } );
+	}
+	
+/**
+* Appends a label containing a key and the specified component
+* to the bottom of the panel.  Any registered action listeners
+* will receive action events from the component - the key corresponding
+* to the component will be used as the action command.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param component A component that will be placed next to the label.
+* If null, a blank JPanel will appear.
+*/
+	public void addRow( String key, Component component )
+	{
+		addRow( key, new Component[] { component } );
+	}
+	
+/**
+* Appends a label containing a key and the specified components
+* to the bottom of the panel.  Any registered action listeners
+* will receive action events from the component - the key corresponding
+* to the component will be used as the action command.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param components An array of components that will be placed next to the label.
+* Any nulls in the list will be replaced with blank JPanels.
+*/
+	public void addRow( 
+		String key, Component[] components )
+	{
+		addCompositeComponent( key, makeCompositeComponent( key, components ) );
+	}
+
+/**
+* Appends a label containing a key and the specified components
+* to the bottom of the panel.  Any registered action listeners
+* will receive action events from the components - the key corresponding
+* to the component will be used as the action command.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param west A component that will appear to the left of the other components,
+* as wide as its preferred width and as tall as the tallest of the other components.
+* A null will be replaced with a blank JPanel.
+* @param center A component that will appear between the other components, 
+* taking up available space.
+* A null will be replaced with a blank JPanel.
+* @param east A component that will appear to the right of the other components,
+* as wide as its preferred width and as tall as the tallest of the other components.
+* A null will be replaced with a blank JPanel.
+*/
+	public void addRow( 
+		String key, Component west, Component center, Component east )
+	{
+		addCompositeComponent( key, 
+            makeCompositeComponent( key, 
+                west, center, east ) );
+	}
+
+/**
+* Appends a label containing a key and the specified components
+* to the bottom of the panel.  Any registered action listeners
+* will receive action events from the components - the key corresponding
+* to the component will be used as the action command.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param west A component that will appear to the left of the other components,
+* as wide as its preferred width and as tall as the tallest of the other components.
+* A null will be replaced with a blank JPanel.
+* @param north A component that will appear above all the other components,
+* as tall as its preferred height and as wide as the info panel itself.
+* @param center A component that will appear between the other components, 
+* taking up available space.  A null will be replaced with a blank JPanel.
+* @param south A component that will appear below all the other components,
+* as tall as its preferred height and as wide as the info panel itself.
+* @param east A component that will appear to the right of the other components,
+* as wide as its preferred width and as tall as the tallest of the other components.
+* A null will be replaced with a blank JPanel.
+*/
+	public void addRow( 
+		String key, Component west, Component north, 
+        Component center, Component south, Component east )
+	{
+		addCompositeComponent( key, 
+            makeCompositeComponent( key, 
+                west, north, center, south, east ) );
+	}
+
+/**
+* Produces a container that contains the specified components,
+* using GridLayout.  Nulls are ignored.
+* This implementation returns a JPanel.
+*/
+	protected Container makeCompositeComponent( 
+		String key, Component[] components )
+	{
+		JPanel panel = createPanel();
+		if ( components.length != 0 ) 
+		{
+			panel.setLayout( new GridLayout( 1, components.length, hgap, vgap ) );			
+
+			Component c;
+			for ( int i = 0; i < components.length; i++ )
+			{		
+				c = components[i];
+				if ( c != null )
+				{
+					introspectComponent( c, key );
+					panel.add( c );
+				}
+			}
+		}
+		return panel;
+	}
+
+/**
+* Produces a container that contains the specified components,
+* using BorderLayout.  Nulls are ignored.
+* This implementation returns a JPanel.
+*/
+	protected Container makeCompositeComponent( 
+		String key, Component west, Component center, Component east )
+	{
+		JPanel panel = createPanel();
+		panel.setLayout( new BorderLayout( hgap, vgap ) );
+
+		if ( west != null )
+		{
+			introspectComponent( west, key );
+			panel.add( west, BorderLayout.WEST );
+		}
+		
+		if ( center != null )
+		{
+			introspectComponent( center, key );
+			panel.add( center, BorderLayout.CENTER );
+		}
+		
+		if ( east != null )
+		{
+			introspectComponent( east, key );
+			panel.add( east, BorderLayout.EAST );
+		}
+		
+		return panel;
+	}
+
+/**
+* Produces a container that contains the specified components,
+* using BorderLayout.  Nulls are ignored.
+* This implementation returns a JPanel.
+*/
+	protected Container makeCompositeComponent( 
+		String key,  Component west, Component north, 
+		Component center, Component south, Component east )
+	{
+		JPanel panel = createPanel();
+		panel.setLayout( new BorderLayout( hgap, vgap ) );
+
+		if ( west != null )
+		{
+			introspectComponent( west, key );
+			panel.add( west, BorderLayout.WEST );
+		}
+		
+		if ( north != null )
+		{
+			introspectComponent( north, key );
+			panel.add( north, BorderLayout.WEST );
+		}
+		
+		if ( center != null )
+		{
+			introspectComponent( center, key );
+			panel.add( center, BorderLayout.CENTER );
+		}
+		
+		if ( south != null )
+		{
+			introspectComponent( south, key );
+			panel.add( south, BorderLayout.CENTER );
+		}
+		
+		if ( east != null )
+		{
+			introspectComponent( east, key );
+			panel.add( east, BorderLayout.EAST );
+		}
+		
+		return panel;
+	}
+
+/**
+* Override to return a specific component to be used
+* as a label.  This implementation calls createLabel().
+*/
+    protected Component createLabelForKey( String aKey )
+	{
+		return createLabel();	
+	}
+
+/**
+* Provided for backwards compatibility, and called by
+* the default implementation of createLabelForKey.
+* This implementation returns a JLabel.
+*/
+    protected JLabel createLabel()
+	{
+		return new JLabel();	
+	}
+
+/**
+* Appends a label containing a key and the specified component
+* to the bottom of the panel.  Any registered action listeners
+* will receive action events from the component - the key corresponding
+* to the component will be used as the action command.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param component A component that will be placed next to the label.
+* If null, a stock JTextField will be used.
+*/
+    protected void addCompositeComponent( String key, Component component )
+    {
+        if ( key == null )
+        {
+            key = "";
+        }
+        Component label = createLabelForKey( key );
+        Component field = component;
+        if ( field == null )
+        {
+            field = new JTextField( 15 ); // default to 15 columns
+        }
+        field.setName( key ); // for association and reference
+        label.setName( key ); // ditto
+        if ( label instanceof JLabel )
+        {
+            ((JLabel)label).setHorizontalAlignment( labelAlign );
+            ((JLabel)label).setLabelFor( field ); // for accessibility
+        }
+        if ( "".equals( key ) )
+        {
+            setText( label, "" );
+        }
+        else
+        {
+            setText( label, prefix + key + postfix );
+        }
+        field.setEnabled( this.isEditable ); // was: setEditable
+
+        GridBagConstraints gbc = new GridBagConstraints();
+
+        if ( listContainer.getComponentCount() == 0 )
+        { // we've just initialized or called removeAll
+            createSpacers();
+        }
+
+        gbc.gridx = ( fields.size() % this.columns ) * 2;
+        gbc.gridy = ( fields.size() / this.columns ) + 1; // spacer is at index zero
+        gbc.weightx = 0.0;
+        gbc.weighty = 0.0;
+        gbc.anchor = this.labelAnchor; 
+        gbc.fill = GridBagConstraints.HORIZONTAL;
+        listContainer.add( label, gbc );
+
+		gbc.fill = GridBagConstraints.BOTH;
+        gbc.gridx = gbc.gridx + 1;
+		//FIXME: components default to the labelAnchor - should be different?
+        gbc.weightx = 1.0;
+        gbc.weighty = 0.0;
+        
+        listContainer.add( field, gbc );
+        
+        if ( key.equals( HIDDEN ) )
+        { // these components are not to be shown
+            setText( label, "     " );
+            field.setVisible( false );
+        }
+
+        fields.add( field ); // using list not map to allow for duplicate keys
+        labels.add( label ); // ditto
+
+        // handle adding on-the-fly
+        updateGaps();
+        this.revalidate();
+        this.repaint();
+    }
+
+/**
+* Introspects a component to set the action command and to add the
+* InfoPanel to its list of ActionListeners.
+* @param aComponent The Component to be introspected.
+* @param aKey The action command to be set.
+*/
+    protected void introspectComponent( Component aComponent, String aKey )
+    {
+        // try to set properties of whatever component this might be
+        try {
+            Method [] methods =
+                (Method []) _method_cache.get( aComponent.getClass() );
+            if (methods == null) {
+                Class componentClass = aComponent.getClass();
+                BeanInfo info =
+                    Introspector.getBeanInfo( componentClass );
+
+                MethodDescriptor[] descriptors =
+                    info.getMethodDescriptors();
+                Method setMethod = null;
+                Method addMethod = null;
+                for ( int i = 0;
+                      ((setMethod == null || addMethod == null) &&
+                       i < descriptors.length);
+                      i++ )
+                {
+                    Method m = descriptors[i].getMethod();
+                    String name = m.getName ();
+                    if ( setMethod == null &&
+                         name.equals( "setActionCommand" ) )
+                    {
+                        setMethod = m;
+                    }
+                    else if ( addMethod == null &&
+                              name.equals( "addActionListener" ) )
+                    {
+                        addMethod = m;
+                    }
+                }
+
+                methods = new Method [] {setMethod, addMethod};
+                _method_cache.put (componentClass, methods);
+            }
+            if (methods [0] != null) {
+              methods [0].invoke( aComponent, new Object[] { aKey } );
+            }
+            if (methods [1] != null) {
+              methods [1].invoke( aComponent, new Object[] { this } );
+              listenedToComponents.add( aComponent );
+            }
+        }
+        catch ( Exception exc )
+        { // error occured while introspecting... move along.
+              System.out.println( "InfoPanel.introspectComponent: " + exc );
+        }
+    }
+    
+/**
+* Called to populate a label component with the specified text.
+* This implementation attempts to call setText(String) on the component.
+* Override to customize.
+*/
+    protected void setText( Component c, String text )
+    {
+        try
+        {
+            Method m = c.getClass().getMethod( "setText", new Class[] { String.class } );
+            if ( m != null )
+            {
+                m.invoke( c, new Object[] { text } );
+            }
+        }
+        catch ( Exception exc )
+        {
+            // no such method: ignore
+        }
+    }
+
+/**
+* Creates spacer components on the reserved first grid row
+* for each column of labels and fields.  
+* This allows us to set the margin for those label columns,
+* and set the preferred width of the field columns.
+* A list containing the field spacers should be assigned to
+* the fieldSpacers instance variable.
+*/
+    private void createSpacers()
+    {
+        if ( listContainer.getLayout() instanceof GridBagLayout )
+        {
+            // insert spacers for labels column
+            GridBagLayout gridBag = (GridBagLayout) listContainer.getLayout();
+            GridBagConstraints constraints = new GridBagConstraints();
+            constraints.gridy = 0;
+            constraints.fill = GridBagConstraints.HORIZONTAL;
+
+            fieldSpacers = new LinkedList();
+            Component fieldSpacer;
+            for ( int i = 0; i < this.columns; i++ )
+            {
+                constraints.gridx = i * 2;
+                listContainer.add( Box.createHorizontalStrut( this.margin ), constraints );
+
+                constraints.gridx = i * 2 + 1;
+                fieldSpacer = Box.createHorizontalStrut( 0 ); 
+                fieldSpacers.add( fieldSpacer );
+                listContainer.add( fieldSpacer, constraints );
+            }
+        }
+    }
+
+/**
+* Updates the insets for all components.
+*/
+    protected void updateGaps()
+    {
+        if ( listContainer.getLayout() instanceof GridBagLayout )
+        {
+            GridBagLayout layout = (GridBagLayout) listContainer.getLayout();
+            Component c = null;
+            GridBagConstraints gbc = null;
+            double totalWeightY = 0.0;
+            int count = listContainer.getComponentCount();
+            int i;
+            for ( i = 0; i < count; i++ )
+            {
+                c = listContainer.getComponent( i );
+                gbc = layout.getConstraints( c );
+                totalWeightY += gbc.weighty;
+                if ( (gbc.gridx + 1) % ( this.columns * 2 ) == 0 )
+                { // if last component in row
+                    gbc.insets = new Insets( 0, 0, this.vgap, 0 );
+                }
+                else
+                {
+                    if ( gbc.gridx % 2 == 0 )
+                    { // is a label column - NOTE: uses eleven pixels before component, per l&f guide
+                        gbc.insets = new Insets( 0, 0, this.vgap, 11 );
+                    }
+                    else
+                    { // is a component column
+                        if ( gbc.gridy != 0 ) 
+                        {
+                            if ( c instanceof JPanel ) ((JPanel)c).setPreferredSize( null );
+                            gbc.insets = new Insets( 0, 0, this.vgap, this.hgap );
+                        }
+                    }
+                }
+                layout.setConstraints( c, gbc );
+            }
+            
+            //hack: gridbag clumps components in center if weighty is zero
+            // if sum of weighty is zero, top-justify the list container
+            this.remove( listContainer );
+            if ( totalWeightY == 0.0 )
+            {
+                this.add( listContainer, BorderLayout.NORTH );
+            } 
+            else // put list container in center so it will grow
+            {
+                this.add( listContainer, BorderLayout.CENTER );
+            }
+        }
+    }
+
+/**
+* Updates the label alignment.
+*/
+    protected void updateLabels()
+    {
+        if ( listContainer.getLayout() instanceof GridBagLayout )
+        {
+            GridBagLayout layout = (GridBagLayout) listContainer.getLayout();
+            Component c = null;
+            GridBagConstraints gbc = null;
+			Iterator it = labels.iterator();
+			while ( it.hasNext() )
+            {
+                c = (Component) it.next();
+                if ( c instanceof JLabel )
+                {
+				    ((JLabel)c).setHorizontalAlignment( labelAlign );
+                }
+                gbc = layout.getConstraints( c );
+                gbc.anchor = this.labelAnchor;
+                layout.setConstraints( c, gbc );
+            }
+        }
+    }
+
+/**
+* Convenience method that uses a stock JTextField.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param value A string that will be displayed in a textfield.
+*/
+    public void addPair( String key, String value )
+    {
+        addPair( key, value, null );
+    }
+
+/**
+* Convenience method that uses the specified JTextField or subclass
+* and sets it to the specified value.
+* @param key A string that will be displayed in a label, preferrably unique.
+* @param value A string that will be displayed in a textfield.
+* @param textField A JTextField or subclass that will be used to display the value.
+* If null, a stock JTextField will be used.
+*/
+    public void addPair( String key, String value, JTextField textField )
+    {
+        if ( value == null )
+        {
+            value = "";
+        }
+        JTextField field = textField;
+        if ( field == null )
+        {
+            field = new JTextField( 15 ); // default to 15 columns
+        }
+        else
+        {
+            field = textField;
+        }
+        field.setText( value );
+
+        addPair( key, (Component) field );
+    }
+
+/**
+* Removes all components from the list.  Buttons, if any,
+* will remain unchanged - use setButtons( null ) to remove 
+* them.  NOTE: does not call super.removeAll().
+*/
+    public void removeAll()
+    {
+        Object component;
+        Method method;
+        Class[] paramClasses = new Class[] { ActionListener.class };
+        Object[] paramObjects = new Object[] { this };
+
+        Iterator iterator = listenedToComponents.iterator();
+        while ( iterator.hasNext() )
+        {
+            component = iterator.next();
+            try
+            {
+                method = component.getClass().getMethod( "removeActionListener", paramClasses );
+                if ( method != null )
+                {
+                    method.invoke( component, paramObjects );
+                }
+            }
+            catch ( Exception exception )
+            {
+                // No removeActionListener() method, move along.
+            }
+        }
+
+        listenedToComponents.clear();
+        
+        listContainer.removeAll();
+        fields.clear();
+        labels.clear();
+        this.revalidate();
+        this.repaint();
+        
+        //FIXME: It is very confusing that this 
+        // implementation does not call super.removeAll().
+    }
+
+/**
+* Adds one or buttons to the bottom of the panel with the specified labels
+* from left to right.  Any action listeners will receive action events
+* from clicks on these buttons - the supplied label will be used as the action command.
+* @param buttons A string array containing the strings to be used for the button labels
+* and action commands.  A null value will remove the button panel.
+* @see ButtonPanel
+*/
+    public void setButtons( String[] buttons )
+    {
+        if ( buttonPanel == null )
+        {
+            buttonPanel = new ButtonPanel();
+            buttonPanel.setInsets( new Insets( 6, 0, 0, 0 ) ); 
+				// button panel has a 11-pixel top inset
+				// and java l&f guide says 17-pixels before command buttons
+            buttonPanel.addActionListener( this );
+            this.add( buttonPanel, BorderLayout.SOUTH );
+        }
+        if ( buttons == null )
+        {
+            this.remove( buttonPanel );
+            buttonPanel = null;
+        }
+        else
+        {
+            buttonPanel.setLabels( buttons );
+        }
+
+        this.revalidate();
+        this.repaint();
+    }
+    protected Collection listenedToComponents = new LinkedList();
+
+/**
+* Retrieves the names of the buttons that are displayed, if any.
+* @return A string array containing the strings used for the button labels
+* and action commands, or null if no buttons have been created.
+* @see ButtonPanel
+*/
+    public String[] getButtons()
+    {
+        if ( buttonPanel == null )
+        {
+            return null; // none created
+        }
+
+        return buttonPanel.getLabels();
+    }
+
+/**
+* Retrieves the actual button panel, if any.
+* @return A button panel, or null if none has been created.
+* @see ButtonPanel
+*/
+    public ButtonPanel getButtonPanel()
+    {
+        return buttonPanel;
+    }
+
+
+/**
+* Sets whether the values displayed in the panel should be editable.  Defaults to true.
+* @param isEditable Whether the values should be editable.
+*/
+    public void setEditable( boolean isEditable )
+    {
+        this.isEditable = isEditable;
+        Iterator enumeration = fields.iterator();
+        while ( enumeration.hasNext() )
+        {
+            ( (Component) enumeration.next() ).setEnabled( isEditable );
+        }
+    }
+
+/**
+* Gets whether the values displayed in the panel are editable.
+* @return Whether the values should be editable.
+*/
+    public boolean isEditable()
+    {
+        return this.isEditable;
+    }
+
+/**
+* Sets the field associated with the key to the specified value.
+* Note: If the component does not respond to setText() or setString()
+* or setValue() the value will not be set.  JTextFields and the like will work.
+* @param key A string representing the key associated with the field.  Nulls are converted to an empty string.
+* @param value A object to be displayed in the specified field.  Nulls are converted to an empty string.
+*/
+    public void setValueForKey( String key, Object value )
+    {
+		setValueForKey( key, value, 0 );	
+	}
+	
+/**
+* Sets the field associated with the key to the specified value.
+* Note: If the component does not respond to setText() or setString()
+* or setValue() the value will not be set.  JTextFields and the like will work.
+* @param key A string representing the key associated with the field.  Nulls are converted to an empty string.
+* @param value A object to be displayed in the specified field.  Nulls are converted to an empty string.
+*/
+    public void setValueForKey( String key, Object value, int index )
+    {
+        if ( key == null )
+        {
+            key = "";
+        }
+
+        Container field = null;
+		for ( int i = 0; i < fields.size(); i++ )
+		{
+            field = (Container) fields.get(i);
+            if ( key.equals( field.getName() ) )
+            {
+				setValueForIndex( index, i, value );
+				return;
+            }
+		}
+        // else not found - ignore
+    }
+	
+/**
+* Sets the first field at the specified row index to the specified value.
+* Note: If the component does not respond to setText() or setString()
+* or setValue() the value will not be set.  JTextFields and the like will work.
+* @param row The row index of the component.
+* @param value A object to be displayed in the specified field.  
+* Nulls are converted to an empty string.
+*/
+    public void setValueForIndex( int row, Object value )
+    {
+		setValueForIndex( row, 0, value );	
+	}
+	
+/**
+* Sets the field at the specified row index and column index to the specified value.
+* Note: If the component does not respond to setText() or setString()
+* or setValue() the value will not be set.  JTextFields and the like will work.
+* @param row The row index of the component.
+* @param index The column index of the component.
+* @param value A object to be displayed in the specified field.  
+* Nulls are converted to an empty string.
+*/
+    public void setValueForIndex( int row, int col, Object value )
+    {
+		Container field = (Container) fields.get( row );
+		Component c = field.getComponent( col );
+		setValueForComponent( c, value );
+	}
+	
+
+
+/**
+* Sets the value in the field at the specified index.
+* Note: If the component does not respond to setText() or setString()
+* or setValue() this method will return null.  JTextFields and the like will work.
+* @param A valid index.
+* @param value A object to be displayed in the specified field.
+*/
+    protected void setValueForComponent( Component aComponent, Object value )
+    {
+        // try to set a text or string property
+        try {
+            BeanInfo info = Introspector.getBeanInfo( aComponent.getClass() );
+            MethodDescriptor[] methods = info.getMethodDescriptors();
+            for ( int i = 0; i < methods.length; i++ )
+            {
+                Method m = methods[i].getMethod();
+                Class[] paramTypes = m.getParameterTypes();
+                if ( paramTypes.length == 1 )
+                {
+                    if ( m.getName().equals( "setText" ) )
+                    {
+                        if ( paramTypes[0].getName().equals( String.class.getName() ) )
+                        {
+                            m.invoke( aComponent, new Object[] { value } );
+                        }
+                    }
+                    if ( m.getName().equals( "setString" ) )
+                    {
+                        if ( paramTypes[0].getName().equals( String.class.getName() ) )
+                        {
+                            m.invoke( aComponent, new Object[] { value } );
+                        }
+                    }
+                    if ( m.getName().equals( "setValue" ) )
+                    {
+                        if ( paramTypes[0].getName().equals( Object.class.getName() ) )
+                        {
+                            m.invoke( aComponent, new Object[] { value } );
+                        }
+                    }
+                }
+            }
+        }
+        catch ( Exception exc )
+        { // error occured while introspecting... move along.
+          // FIXME: should log error in ErrorManager
+          System.out.println( "InfoPanel.setValueForComponent: " + exc );
+        }
+    }
+
+/**
+* Gets the value in the field at the specified index.
+* Note: If the component does not respond to getText() or getString()
+* or getSelectedItem() this method will return null.  JTextFields and the like will work.
+* @param A valid index.
+* @return An object representing the value in the field at the specified index,
+* or null if the component does not have a text property or if the index is out of bounds.
+*/
+    public Object getValueForIndex( int anIndex )
+    {
+        return getValueForIndex( anIndex, 0 );
+    }
+
+/**
+* Gets the value in the field at the specified row and column.
+* Note: If the component does not respond to getText() or getString()
+* or getSelectedItem() this method will return null.  JTextFields and the like will work.
+* @param A valid index.
+* @return An object representing the value in the field at the specified index,
+* or null if the component does not have a text property or if the index is out of bounds.
+*/
+    public Object getValueForIndex( int row, int col )
+    {
+        if ( ( row >= fields.size() ) || ( row < 0 ) )
+        { // out of bounds
+            return null;
+        }
+		
+		Container field = (Container) fields.get( row );
+		Component c = field.getComponent( col );
+        return getValueForComponent( c );
+    }
+
+/**
+* Gets the value in the field associated with the key.
+* Note: If the component does not respond to getText() or getString()
+* or getSelectedItem() this method will return null.  JTextFields and the like will work.
+* @param key An string representing the key associated with the field.  Nulls are converted to an empty string.
+* @return An object representing the value in the field associated with the key,
+* or null if the key does not exist or if the component does not have a text property.
+*/
+    public Object getValueForKey( String key )
+    {
+		return getValueForKey( key, 0 );	
+	}
+
+/**
+* Gets the value in the field associated with the key.
+* Note: If the component does not respond to getText() or getString()
+* or getSelectedItem() this method will return null.  JTextFields and the like will work.
+* @param key An string representing the key associated with the field.  Nulls are converted to an empty string.
+* @return An object representing the value in the field associated with the key,
+* or null if the key does not exist or if the component does not have a text property.
+*/
+    public Object getValueForKey( String key, int index )
+    {
+        if ( key == null )
+        {
+            key = "";
+        }
+
+        Container field = null;
+        Iterator enumeration = fields.iterator();
+        while ( enumeration.hasNext() )
+        { // finds first value in list with specified key
+            field = (Container) enumeration.next();
+            if ( key.equals( field.getName() ) )
+            {
+				Component c = field.getComponent( index );
+				if ( c != null )
+				{
+					return getValueForComponent( c );
+				}
+            }
+        }
+        // else not found
+        return null;
+    }
+
+/**
+* Gets the value in the specified component.
+* Note: If the component does not respond to getText() or getString()
+* or getSelectedItem() this method will return null.  JTextFields and the like will work.
+* @param aComponent The specified component.
+* @return An object representing the value in the component.
+* or null if the component does not have a text property.
+*/
+    protected Object getValueForComponent( Component aComponent )
+    {
+        // try to get a text or string property
+        try
+        {
+            BeanInfo info = Introspector.getBeanInfo( aComponent.getClass() );
+            MethodDescriptor[] methods = info.getMethodDescriptors();
+            for ( int i = 0; i < methods.length; i++ )
+            {
+                Method m = methods[i].getMethod();
+                Class[] paramTypes = m.getParameterTypes();
+                if ( m.getName().equals( "getText" ) )
+                {
+                    if ( paramTypes.length == 0 )
+                    {
+                        return m.invoke( aComponent, new Object[] {} );
+                    }
+                }
+                if ( m.getName().equals( "getString" ) )
+                {
+                    if ( paramTypes.length == 0 )
+                    {
+                        return m.invoke( aComponent, new Object[] {} );
+                    }
+                }
+                if ( m.getName().equals( "getSelectedItem" ) )
+                {
+                    if ( paramTypes.length == 0 )
+                    {
+                        return m.invoke( aComponent, new Object[] {} );
+                    }
+                }
+                // TODO: should also handle variants of setValue()
+            }
+        }
+        catch ( Exception exc )
+        { // error occured while introspecting... move along.
+          System.out.println( "InfoPanel.getValueFromComponent: " + exc );
+        }
+
+        // not found
+        return null;
+    }
+
+/**
+* Gets the component associated with the key as a JTextField, for backwards compatibility.
+* @param key A string representing the key associated with the component.  Nulls are converted to an empty string.
+* @return A JTextField that contains the value associated with the key,
+* or null if the key does not exist or if the component is not a JTextField.
+*/
+    public JTextField getFieldForKey( String key )
+    {
+        Component c = getComponentForKey( key );
+        if ( c instanceof JTextField )
+        {
+            return (JTextField) c;
+        }
+        return null;
+    }
+
+/**
+* Gets the component associated with the key.  If more than one component is associated
+* with the key, returns the first such component.
+* @param key A string representing the key associated with the component.  
+* Nulls are converted to an empty string.
+* @return A component that contains the value associated with the key,
+* or null if the key does not exist.
+*/
+    public Component getComponentForKey( String key )
+    {
+		return getComponentForKey( key, 0 );
+	}
+
+/**
+* Gets the component associated with the key and index.
+* @param key A string representing the key associated with the component.  
+* Nulls are converted to an empty string.
+* @return A component that contains the value associated with the key,
+* or null if the key does not exist.
+*/
+    public Component getComponentForKey( String key, int index )
+    {
+		Container c = getCompositeComponentForKey( key );
+		if ( c == null ) return null;
+		return c.getComponent( index );
+    }
+
+/**
+* Gets the component at the specified row.  If more than one component exists
+* on that row, returns the first such component.
+* @return A component or null if the row does not exist.
+*/
+    public Object getComponentForIndex( int row )
+    {
+        return getComponentForIndex( row, 0 );
+    }
+
+/**
+* Gets the component at the specified row and column.
+* @return A component or null if the index is out of bounds.
+*/
+    public Object getComponentForIndex( int row, int col )
+    {
+        if ( ( row > fields.size() ) || ( row < 0 ) )
+        { // out of bounds
+            return null;
+        }
+		
+		Container field = (Container) fields.get( row );
+		return field.getComponent( col );
+    }
+
+/**
+* Gets the container associated with the key.
+* @param key A string representing the key associated with the component.  
+* Nulls are converted to an empty string.
+* @return A component that contains the value associated with the key,
+* or null if the key does not exist.
+*/
+    protected Container getCompositeComponentForKey( String key )
+    {
+        if ( key == null )
+        {
+            key = "";
+        }
+
+        JPanel field = null;
+        Iterator enumeration = fields.iterator();
+        while ( enumeration.hasNext() )
+        { // finds first value in list with specified key
+            field = (JPanel) enumeration.next();
+            if ( key.equals( field.getName() ) )
+            {
+                return field;
+            }
+        }
+
+        // else not found
+        return null;
+    }
+
+/**
+* Provided for backwards compatibility: calls getLabelComponentForKey.
+* @param key A string representing the key associated with the compoent.
+*            Nulls are converted to an empty string.
+* @return Component label object associated with the key, or null if the key does not exist
+* or if the label component is not an instance of JLabel.
+*/
+    public JLabel getLabelForKey( String key )
+    {
+        Component result = getLabelComponentForKey( key );
+        if ( result instanceof JLabel ) return (JLabel) result;
+        return null;
+    }
+    
+/**
+* Get the label component associated with the key.
+* @param key A string representing the key associated with the compoent.
+*            Nulls are converted to an empty string.
+* @return Component label object associated with the key, or null if the key does not exist.
+*/
+    public Component getLabelComponentForKey( String key )
+    {
+        if ( key == null )
+        {
+            key = "";
+        }
+
+        Component label = null;
+        Iterator enumeration = labels.iterator();
+        while ( enumeration.hasNext() )
+        { // finds first value in list with specified key
+            label = (Component) enumeration.next();
+            if ( key.equals( label.getName() ) )
+            {
+                return label;
+            }
+        }
+
+        // else not found
+        return null;
+    }
+
+/**
+* Replaces the first component associated with the key.  Any value in the existing
+* component will be copied to the new component.
+* @param key A string representing the key to be associated with the component.  
+* Nulls are converted to an empty string.
+* @param c A component to be placed next to the label corresponding to the key.  
+* Nulls are converted to a JTextField.
+*/
+    public void setComponentForKey( String key, Component c )
+    {
+		setComponentForKey( key, c, 0 );	
+	}
+	
+/**
+* Replaces the component associated with the key.  Any value in the existing
+* component will be copied to the new component.
+* @param key A string representing the key to be associated with the component.  
+* Nulls are converted to an empty string.
+* @param c A component to be placed next to the label corresponding to the key.  
+* Nulls are converted to a JTextField.
+*/
+    public void setComponentForKey( String key, Component c, int index )
+    {
+        if ( c == null )
+        {
+            c = new JTextField( 15 );
+        }
+        if ( key == null )
+        {
+            key = "";
+        }
+
+        Container container = this.getCompositeComponentForKey( key );
+		Component field = container.getComponent( index );
+        Object value = this.getValueForKey( key, index );
+        if ( field != null )
+        {
+			container.remove( index );
+			container.add( c, index );
+			c.setEnabled( this.isEditable );
+			introspectComponent( c, key );
+            setValueForComponent( c, value );
+        }
+    }
+
+/**
+* Replaces the first component in the specified row.  Any value in the existing
+* component will be copied to the new component.
+* @param row A valid index.
+* @param c A component to be placed next to the label corresponding to the key.  
+*/
+    public void setComponentForIndex( int row, Component c )
+    {
+		setComponentForIndex( row, 0, c );	
+	}
+	
+/**
+* Replaces the component associated with the key.  Any value in the existing
+* component will be copied to the new component.
+* @param row A valid index.
+* @param c A component to be placed next to the label corresponding to the key.  
+*/
+    public void setComponentForIndex( int row, int col, Component c )
+    {
+		setComponentForKey( getLabels()[row], c, col );
+    }
+
+/**
+* Sets the string that appears before each label's text on the panel.
+* @param aString A String to be used as the label prefix.
+*/
+    public void setLabelPrefix( String aString )
+    {
+        prefix = aString;
+        setLabels( getLabels() ); // force refresh
+    }
+
+/**
+* Gets the string that appears before each label's text on the panel.
+* Defaults to "", an empty string.
+* @return A String that is currently used as the label prefix.
+*/
+    public String getLabelPrefix()
+    {
+        return prefix;
+    }
+
+/**
+* Sets the string that appears after each label's text on the panel.
+* Defaults to ": ", a colon followed by a space.
+* @param aString A String to be used as the label postfix.
+*/
+    public void setLabelPostfix( String aString )
+    {
+        postfix = aString;
+        setLabels( getLabels() ); // force refresh
+    }
+
+/**
+* Gets the string that appears after each label's text on the panel.
+* @return A String that is currently used as the label postfix.
+*/
+    public String getLabelPostfix()
+    {
+        return postfix;
+    }
+
+/**
+* Adds an action listener to the list that will be
+* notified by events occurring in the panel.
+* @param l An action listener to be notified.
+*/
+     public void addActionListener(ActionListener l)
+     {
+           actionListener = AWTEventMulticaster.add(actionListener, l);
+     }
+/**
+* Removes an action listener from the list that will be
+* notified by events occurring in the panel.
+* @param l An action listener to be removed.
+*/
+     public void removeActionListener(ActionListener l)
+     {
+           actionListener = AWTEventMulticaster.remove(actionListener, l);
+     }
+/**
+* Notifies all registered action listeners of a pending Action Event.
+* @param e An action event to be broadcast.
+*/
+     protected void broadcastEvent(ActionEvent e)
+     {
+         if (actionListener != null)
+         {
+             actionListener.actionPerformed(e);
+         }
+     }
+
+    // interface ActionListener
+
+/**
+* Called by buttons on panel and by other components that
+* might be set to broadcast events to this listener.
+* Simply forwards the action event unchanged.
+* @param e An action event to be received.
+*/
+     public void actionPerformed(ActionEvent e)
+     {
+//        if ( e.getSource() instanceof AbstractButton )
+//        {
+            broadcastEvent(e);
+//        }
+     }
+     
+    /**
+    * GridBagLayout allocates weightx only after considering
+    * the preferred width of the components in a column.
+    * We'd prefer that preferred width wasn't considered,
+    * so that the layout worked more like a html-table.
+    * GridBagLayout is poorly factored for subclassing,
+    * so this code is going to get a little bit ugly.
+    * Really, what good is a protected method that returns
+    * a private class?  Would have liked to just override
+    * getLayoutInfo and be done with it.
+    */
+    private class BetterGridBagLayout extends GridBagLayout
+    {
+        public Dimension preferredLayoutSize(Container parent) 
+        {
+            preprocess();
+            return super.preferredLayoutSize( parent );
+        }
+        
+        public Dimension minimumLayoutSize(Container parent) 
+        {
+            preprocess();
+            return super.minimumLayoutSize( parent );
+        }
+
+        
+        public void layoutContainer(Container parent) 
+        {
+            preprocess();
+            super.layoutContainer( parent );
+        }
+
+        protected void preprocess() 
+        {
+            if ( fieldSpacers == null ) return;
+            Iterator i;
+            
+            // find the field with the widest preferred size
+            Component c;
+            int maxWidth = 0;
+            i = fields.iterator();
+            while ( i.hasNext() )
+            {
+                c = (Component) i.next();
+                maxWidth = Math.max( maxWidth, 
+                    Math.max( c.getPreferredSize().width, c.getMinimumSize().width ) );
+            }
+            
+            // set each column's spacers to that preferred size
+            Dimension min = new Dimension( 0, 0 );
+            Dimension pref = new Dimension( maxWidth, 0 );
+            i = fieldSpacers.iterator();
+            while ( i.hasNext() )
+            {
+                ((Box.Filler)i.next()).changeShape( min, pref, pref );
+            }
+        }
+    }
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/KeyDelayTimer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/KeyDelayTimer.java
new file mode 100644
index 0000000..b73c74d
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/KeyDelayTimer.java
@@ -0,0 +1,188 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.AWTEventMulticaster;
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.Timer;
+
+/**
+* KeyDelayTimer is a utility that listens for KeyEvents from one
+* or more components.  After receiving a KeyEvents the timer will
+* broadcast an action event if a specified time interval passes without
+* a subsequent KeyEvent.<BR><BR>
+*
+* This utility is useful for implementing any kind of auto-complete
+* feature in a user interface.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+* $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+*/
+public class KeyDelayTimer implements ActionListener, KeyListener
+{
+    // delay timer for keypress-sensitve events
+    protected Timer keyTimer = null;
+    protected Component lastFieldTouched = null;
+    protected long timeLastFieldTouched = 0;
+    protected int interval = 400; // adjust as needed
+
+    // for action multicasting
+    protected ActionListener actionListener = null;
+
+/**
+*   Default constructor.
+*/
+    public KeyDelayTimer()
+    {
+        keyTimer = new Timer( interval, this );
+    }
+
+/**
+*   Convenience constructor.
+*   @param listener An action listener to be notified of delay events.
+*/
+    public KeyDelayTimer( ActionListener listener )
+    {
+        this();
+        addActionListener( listener );
+    }
+
+/**
+*   Returns the last component that generated a KeyEvent.
+*   @return The component that sent the most recent KeyEvent.
+*/
+    public Component getComponent()
+    {
+        return lastFieldTouched;
+    }
+
+/**
+*   Returns the number of milliseconds before an ActionEvent is generated.
+*   The default is 400.
+*   @return The current delay interval in milliseconds.
+*/
+    public int getInterval()
+    {
+        return interval;
+    }
+
+/**
+*   Sets the number of milliseconds before an ActionEvent will be generated
+*   after a KeyEvent is received.
+*   @param millis The new delay interval in milliseconds.
+*/
+    public void setInterval( int millis )
+    {
+        interval = millis;
+        keyTimer.setDelay( interval / 2 );
+    }
+
+    // interface KeyListener
+
+    public void keyTyped(KeyEvent e)
+    {
+    }
+    public void keyPressed(KeyEvent e)
+    {
+    }
+
+/**
+*   Receives key events from one or more components.
+*   Records the component and the time this event was received,
+*   then starts the timer.
+*   @param e The key event in question.
+*/
+    public void keyReleased(KeyEvent e)
+    { // handles keystrokes in the textfields (except ENTER and ESCAPE)
+        if ( ( Character.isLetterOrDigit( e.getKeyChar() ) )
+        ||   ( e.getKeyCode() == KeyEvent.VK_SPACE )
+        ||   ( e.getKeyCode() == KeyEvent.VK_DELETE )
+        ||   ( e.getKeyCode() == KeyEvent.VK_BACK_SPACE ) )
+        {
+            this.lastFieldTouched = e.getComponent();
+            this.timeLastFieldTouched = System.currentTimeMillis();
+            this.keyTimer.start();
+            return;
+        }
+    }
+
+    // interface ActionListener
+
+/**
+*   Receives ActionEvents from the internal timer.
+*   If the interval has passed without another KeyEvent,
+*   an ActionEvent is broadcast, with the name of this class
+*   as the ActionCommand, and the internal timer is stopped.
+*   @param e The action event in question.
+*/
+     public void actionPerformed(ActionEvent e)
+     {
+        if ( e.getSource() == keyTimer )
+        {
+            if ( System.currentTimeMillis() - this.timeLastFieldTouched > interval )
+            {
+                this.keyTimer.stop();
+                broadcastEvent( new ActionEvent( this, ActionEvent.ACTION_PERFORMED, this.getClass().getName() ) );
+            }
+            return;
+        }
+    }
+
+    // Action Multicast methods
+
+/**
+* Adds an action listener to the list that will be
+* notified by button events and changes in button state.
+* @param l An action listener to be notified.
+*/
+     public void addActionListener(ActionListener l)
+     {
+           actionListener = AWTEventMulticaster.add(actionListener, l);
+     }
+/**
+* Removes an action listener from the list that will be
+* notified by button events and changes in button state.
+* @param l An action listener to be removed.
+*/
+     public void removeActionListener(ActionListener l)
+     {
+           actionListener = AWTEventMulticaster.remove(actionListener, l);
+     }
+/**
+* Notifies all registered action listeners of a pending Action Event.
+* @param e An action event to be broadcast.
+*/
+     protected void broadcastEvent(ActionEvent e)
+     {
+         if (actionListener != null)
+         {
+             actionListener.actionPerformed(e);
+         }
+     }
+
+}
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/KeyableCellEditor.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/KeyableCellEditor.java
new file mode 100644
index 0000000..95b8a19
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/KeyableCellEditor.java
@@ -0,0 +1,350 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.io.Serializable;
+import java.text.Format;
+import java.util.ArrayList;
+import java.util.EventObject;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Vector;
+
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.border.LineBorder;
+import javax.swing.event.CellEditorListener;
+import javax.swing.event.ChangeEvent;
+import javax.swing.table.TableCellEditor;
+
+/**
+* A table cell editor customized for keyboard navigation, much like
+* working with a spreadsheet.  The default cell editor unfortunately
+* does none of these things:
+* <ul>
+*    <li> Selects text on start of editing.
+*    <li> Up and down keys move edit cell up and down.
+*    <li> Right and left keys move cell when selection caret is at end of text.
+*    <li> Escape cancels editing.
+*    <li> Enter commits edit.
+*    <li> Edits are properly committed on lost focus.
+*    <li> Tab and shift-tab work as expected.
+*    <li> Cell selection moves with the edit cell.
+* </ul>
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+* $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+*/
+public class KeyableCellEditor implements TableCellEditor, FocusListener,
+                                        KeyListener, Serializable
+{
+    List listeners;
+    JTextField textField;
+    Object lastValue;
+    Format currentFormat;
+
+    JTable table;
+
+/**
+* Default constructor - a standard JTextField will be used for editing.
+*/
+    public KeyableCellEditor()
+    {
+        this( (JTextField) null );
+    }
+
+/**
+* Constructor specifying a type of JTextField to be used for editing.
+* The JTextField will have its border replaced with a black line border.
+* @param aTextField A JTextField or subclass for editing values.
+*/
+    public KeyableCellEditor( JTextField aTextField )
+    {
+        listeners = new Vector();
+        lastValue = null;
+
+        // default to stock JTextField
+        textField = aTextField;
+        if ( textField == null )
+        {
+            textField = new JTextField();
+        }
+
+        textField.setBorder(new LineBorder(Color.black));
+
+        // handle arrow keys while caret is showing
+        textField.addKeyListener( this );
+
+        // handle lost focus
+        textField.addFocusListener( this );
+    }
+
+    public Component getTableCellEditorComponent(JTable table,
+                                                 Object value,
+                                                 boolean isSelected,
+                                                 int row,
+                                                 int column)
+    {
+        this.table = table;
+        table.removeKeyListener( this ); // if any
+        table.addKeyListener( this );
+        return getEditorComponent( value );
+    }
+
+    protected Component getEditorComponent( Object value )
+    {
+        if ( value != null )
+        {
+            textField.setText( value.toString() );
+        }
+        else
+        {
+            textField.setText( "" );
+        }
+
+        if ( value instanceof Number )
+        {
+            textField.setHorizontalAlignment(JTextField.RIGHT);
+        }
+        else
+        {
+            textField.setHorizontalAlignment(JTextField.LEFT);
+        }
+
+        // remember original value
+        lastValue = value;
+
+        // select all text and get focus
+        textField.selectAll();
+        textField.requestFocus();
+
+        return textField;
+    }
+
+    public Object getCellEditorValue()
+    {
+        return lastValue;
+    }
+
+    public boolean isCellEditable(EventObject anEvent)
+    {
+        // key events should replace the selection
+        // NOTE: For whatever reason, key events trigger result in a null parameter
+        if ( anEvent == null )
+        {
+            textField.setText("");
+            textField.requestFocus();
+            return true;
+        }
+
+        return true;
+    }
+
+    public boolean shouldSelectCell(EventObject anEvent)
+    { // System.out.println( "KeyableCellEditor.shouldSelectCell: " + anEvent );
+
+        // key events should replace the selection
+        // NOTE: For whatever reason, key events are not generated
+        if ( anEvent instanceof KeyEvent )
+        {
+            textField.setText("");
+            textField.requestFocus();
+            return true;
+        }
+
+        // otherwise, select all text and continue
+        textField.selectAll();
+        textField.requestFocus();
+
+        return true;
+    }
+
+    public boolean stopCellEditing()
+    {
+        lastValue = textField.getText();
+        fireEditingStopped();
+        table.removeKeyListener( this ); // if any
+        return true;
+    }
+
+    public void cancelCellEditing()
+    {
+        fireEditingCanceled();
+        table.removeKeyListener( this ); // if any
+    }
+
+    public void addCellEditorListener(CellEditorListener l)
+    {
+        listeners.add( l );
+    }
+
+    public void removeCellEditorListener(CellEditorListener l)
+    {
+        listeners.remove( l );
+    }
+
+    protected void fireEditingCanceled()
+    {
+        ChangeEvent event = new ChangeEvent( this );
+        Iterator it = new ArrayList( listeners ).iterator(); // copy to prevent modification exception
+        while ( it.hasNext() )
+        {
+            ((CellEditorListener)it.next()).editingCanceled( event );
+        }
+    }
+
+    protected void fireEditingStopped()
+    {
+        ChangeEvent event = new ChangeEvent( this );
+        Iterator it = new ArrayList( listeners ).iterator(); // copy to prevent modification exception
+        while ( it.hasNext() )
+        {
+            ((CellEditorListener)it.next()).editingStopped( event );
+        }
+    }
+
+    protected void onEnterKey()
+    {
+        stopCellEditing();
+    }
+
+    protected void onEscapeKey()
+    {
+        cancelCellEditing();
+    }
+
+    protected void moveEditCell( int dRow, int dCol )
+    {
+        if ( table == null ) return;
+        int row = table.getSelectedRow() + dRow;
+        int col = table.getSelectedColumn() + dCol;
+
+        row = Math.max( 0, row );
+        row = Math.min( row, table.getRowCount() - 1 );
+        col = Math.max( 0, col );
+        col = Math.min( col, table.getColumnCount() - 1 );
+
+        stopCellEditing();
+        table.setRowSelectionInterval( row, row );
+        table.setColumnSelectionInterval( col, col );
+        table.editCellAt( row, col );
+        textField.selectAll();
+        textField.requestFocus();
+    }
+
+    // interface KeyListener
+
+    public void keyTyped(KeyEvent e)
+    { // System.out.println( "KeyableCellEditor.keyTyped: " + KeyEvent.getKeyText( e.getKeyCode() ) );
+    }
+
+    public void keyPressed(KeyEvent e)
+    { // System.out.println( "KeyableCellEditor.keyPressed: " + KeyEvent.getKeyText( e.getKeyCode() ) );
+
+        // catch LEFT and RIGHT here before JTextField consumes them
+
+        int keyCode = e.getKeyCode();
+        if ( keyCode == KeyEvent.VK_LEFT )
+        {
+            if ( textField.getSelectionStart() == 0 )
+            {
+                moveEditCell( 0, -1 );
+                e.consume();
+                return;
+            }
+        }
+        if ( keyCode == KeyEvent.VK_RIGHT )
+        {
+            if ( textField.getSelectionEnd() == textField.getText().length() )
+            {
+                moveEditCell( 0, 1 );
+                e.consume();
+                return;
+            }
+        }
+        if ( keyCode == KeyEvent.VK_UP )
+        {
+            moveEditCell( -1, 0 );
+            e.consume();
+            return;
+        }
+        if ( keyCode == KeyEvent.VK_DOWN )
+        {
+            moveEditCell( 1, 0 );
+            e.consume();
+            return;
+        }
+    }
+
+    public void keyReleased(KeyEvent e)
+    { // System.out.println( "KeyableCellEditor.keyReleased: " + KeyEvent.getKeyText( e.getKeyCode() ) );
+
+        // catch ENTER here to allow JTextField to process it as well
+
+        int keyCode = e.getKeyCode();
+        if ( keyCode == KeyEvent.VK_ENTER )
+        {
+            onEnterKey();
+            return;
+        }
+        if ( keyCode == KeyEvent.VK_ESCAPE )
+        {
+            onEscapeKey();
+            return;
+        }
+
+        // tabs are apparently only received on key release
+        if ( keyCode == KeyEvent.VK_TAB )
+        {
+            if ( e.isShiftDown() )
+            {
+                moveEditCell( 0, -1 );
+            }
+            else
+            {
+                moveEditCell( 0, 1 );
+            }
+            e.consume();
+            return;
+        }
+
+    }
+
+    // interface FocusListener
+
+    public void focusGained(FocusEvent e)
+    { // System.out.println( "focusGained: " );        
+    }
+
+    public void focusLost(FocusEvent e)
+    { // System.out.println( "focusLost: " );        
+        stopCellEditing();
+    }
+
+}
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/LineWrappingRenderer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/LineWrappingRenderer.java
new file mode 100644
index 0000000..4a7f07e
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/LineWrappingRenderer.java
@@ -0,0 +1,154 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Component;
+import java.awt.Dimension;
+
+import javax.swing.JList;
+import javax.swing.JViewport;
+import javax.swing.ListCellRenderer;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+import javax.swing.border.EmptyBorder;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+/**
+* A list cell renderer that wraps its text to subsequent lines
+* depending on the length of text string and the width of the
+* parent list. 
+*
+* This renderer depends on listening to the parent list's viewport
+* and fixing the list's width to match the viewport's size.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @date $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+* @revision $Revision: 904 $
+*/
+public class LineWrappingRenderer extends MultiLineLabel
+    implements ListCellRenderer, ChangeListener
+{
+    protected static Border noFocusBorder;
+
+    protected JList list;
+    protected JViewport viewport;
+    protected int preferredWidth;
+
+/**
+* Required constructor.  The renderer keeps a reference to
+* the list in which it is used and its viewport.  This list
+* is the only list that may use this renderer.  The renderer
+* will use the current size of the list to determine where
+* lines will initially break.
+* @param containerList The list that will be using this renderer.
+*/
+    public LineWrappingRenderer( JList containerList )
+    {
+	    super();
+        setLineWrap(true);
+       	noFocusBorder = new EmptyBorder(1, 1, 1, 1);
+
+        list = containerList;
+        preferredWidth = 400;
+        if ( list.getParent() instanceof JViewport )
+        {
+            viewport = (JViewport) list.getParent();
+            viewport.addChangeListener( this );
+            int newWidth = viewport.getExtentSize().width;
+            if ( newWidth > 0 ) preferredWidth = newWidth;
+        }
+        else
+        {
+            // should function adequately in absence of a viewport
+            // System.err.println( "LineWrappingRenderer.init: list.getParent = " + list.getParent() );
+        }
+    }
+
+/**
+* Returns the preferred size of the label, with width
+* constrained to the current width.
+* @return the size
+*/
+    public Dimension getPreferredSize()
+    {
+        int width = getWidth();
+        if ( width != preferredWidth )
+        {
+            // if component has not yet been placed within the list
+            if ( width < list.getWidth() / 2 ) width = list.getWidth();
+            preferredWidth = width;
+        } 
+        return new Dimension( preferredWidth, super.getPreferredSize().height );
+    }
+
+/**
+* Returns this component with the width set to the
+* width of the specified JList.
+* @return this component.
+*/
+    public Component getListCellRendererComponent (
+        JList list,
+    	Object value,
+        int index,
+        boolean isSelected,
+        boolean cellHasFocus )
+    { // System.out.println( "LineWrappingRenderer.getListCellRendererComponent:" );
+
+        if ( list != this.list )
+        {
+            System.err.println( "LineWrappingRenderer.getListCellRendererComponent: " +
+                "warning: the list using the renderer is not the list specified in the constructor." );
+        }
+
+        if (isSelected)
+        {
+            setBackground(this.list.getSelectionBackground());
+            setForeground(this.list.getSelectionForeground());
+        }
+        else
+        {
+            setBackground(this.list.getBackground());
+            setForeground(this.list.getForeground());
+        }
+
+        setText((value == null) ? "" : value.toString());
+
+        setEnabled(this.list.isEnabled());
+        setFont(this.list.getFont());
+        setBorder( (cellHasFocus) ? UIManager.getBorder("List.focusCellHighlightBorder") : noFocusBorder );
+
+        return this;
+    }
+
+/**
+* Overridden to respond to viewport changes.
+*/
+    public void stateChanged(ChangeEvent e)
+    {
+        int newWidth = viewport.getExtentSize().width;
+        if ( newWidth > 0 ) preferredWidth = newWidth;
+
+        // set fixed width on list
+        list.setFixedCellWidth( preferredWidth );
+        setSize( preferredWidth, super.getSize().height );
+    }
+
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/MultiLineLabel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/MultiLineLabel.java
new file mode 100644
index 0000000..b5f8a9b
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/MultiLineLabel.java
@@ -0,0 +1,135 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import javax.swing.JTextArea;
+import javax.swing.LookAndFeel;
+import javax.swing.text.Highlighter;
+
+/**
+* A custom JTextArea that looks and feels like a JLabel, but supports
+* line wrapping.  This works a lot more like the IFC label component.
+* NOTE: doesn't support icons (yet).
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @date $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+* @revision $Revision: 904 $
+*/
+public class MultiLineLabel extends JTextArea
+{
+	/**
+	* Saves a reference to the original highlighter
+	* to enable/disable text selection. 
+	*/
+	protected Highlighter originalHighlighter;
+	
+/*
+* Creates a MultiLineLabel instance with an empty string for the title.
+*/
+    public MultiLineLabel()
+    {
+        super();
+
+        // turn on wrapping and disable editing and highlighting
+
+        setLineWrap(true);
+        setWrapStyleWord(true);
+        setEditable(false);
+		setSelectable( false );
+    }
+
+/*
+* Creates a MultiLineLabel instance with the specified text.
+* @param text The specified text.
+*/
+    public MultiLineLabel( String text )
+    {
+        super( text );
+
+        // turn on wrapping and disable editing and highlighting
+
+        setLineWrap(true);
+        setWrapStyleWord(true);
+        setEditable(false);
+		setSelectable( false );
+    }
+
+/*
+* Overridden to look like a label.
+* @param text The specified text.
+*/
+    public void updateUI()
+    {
+        // got the implementation idea from usenet
+
+        super.updateUI();
+
+        // turn on wrapping and disable editing and highlighting
+
+        setLineWrap(true);
+        setWrapStyleWord(true);
+        setEditable(false);
+		setSelectable( false );
+
+        // Set the text area's border, colors and font to
+        // that of a label
+
+        LookAndFeel.installBorder(this, "Label.border");
+
+        LookAndFeel.installColorsAndFont(this,
+            "Label.background",
+            "Label.foreground",
+            "Label.font");
+    }
+
+/**
+* Sets whether text is selectable.
+* Default is non-selectable text.
+*/
+	public void setSelectable( boolean selectable )
+	{
+		if ( selectable )
+		{
+			setHighlighter( originalHighlighter );
+		}
+		else
+		{
+			originalHighlighter = getHighlighter();
+			setHighlighter( null );
+		}
+	}
+	
+/**
+* Gets whether text is selectable.
+* Default is non-selectable text.
+*/
+	public boolean isSelectable()
+	{
+		return ( getHighlighter() != null );	
+	}
+
+/**
+* Overridden to return false.
+*/
+	public boolean isFocusTraversable()
+	{
+		return false;
+	}	
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/NumericTextField.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/NumericTextField.java
new file mode 100644
index 0000000..b3d2d03
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/NumericTextField.java
@@ -0,0 +1,434 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+/**
+* NumericTextField is a "smart" text field that restricts the user's input.  The
+* input is restructed to numeric only wich can be of two types: integer and real
+* numbers.  A range can also be placed on the text field.  The default type is
+* integer, with the being (Integer.MIN_VALUE, Integer.MAX_VALUE).
+*
+* @author rob@straylight.princeton.com
+* @author $Author: cgruber $
+* @version $Revision: 893 $
+*/
+public class NumericTextField extends SmartTextField
+{
+
+/*******************************
+* CONSTANTS
+*******************************/
+
+/**
+* Restrict the text input to integers (whole numbers) only.
+*/
+   public final static int INTEGER = 0;
+
+/**
+* Restrict the text input to floating-point numbers only.
+*/
+   public final static int FLOAT = 1;
+
+   private Number maximumValue = null;
+   private Number minimumValue = null;
+
+   private boolean sign = false;
+   private int newCaretPosition = 0;
+   private int valueType = INTEGER;
+
+
+/*******************************
+* PUBLIC METHODS
+*******************************/
+
+/**
+* Default constructor.
+*/
+   public NumericTextField()
+   {
+      this("", 0);
+   }
+
+/**
+* Constructor.
+* @param text The initial string the text field is set to.
+*/
+   public NumericTextField(String text)
+   {
+      this(text, 0);
+   }
+
+/**
+* Constructor.
+* @param columns Width of the text field (in characters).
+*/
+   public NumericTextField(int columns)
+   {
+      this("", columns);
+   }
+
+/**
+* Constructor.
+* @param text The initial string the text field is set to.
+* @param columns Width of the text field (in characters).
+*/
+   public NumericTextField(String text, int columns)
+   {
+      super(text, columns);
+   }
+
+/**
+* Sets the upper limit of the range of numbers to accept.
+* @param newMaximumValue The maximum number accepted by the text field.
+*/
+   public void setMaximumValue(double newMaximumValue)
+   {
+      if (newMaximumValue >= 0)
+      {
+         maximumValue = new Double( newMaximumValue );
+      }
+      else
+      {
+         maximumValue = null;
+      }
+   }
+
+/**
+* Returns the upper limit of the range of numbers to accept.
+* @return The maximum number accepted by this text field.
+*/
+   public double getMaximumValue()
+   {
+      if ( valueType == INTEGER )
+      {
+        return (maximumValue == null) ? (double) Integer.MAX_VALUE : maximumValue.doubleValue();
+      }
+      else
+      {
+        return (maximumValue == null) ? Double.MAX_VALUE : maximumValue.doubleValue();
+      }
+   }
+
+/**
+* Sets the lower limit of the range of numbers to accept.
+* @param newMinimumValue The minimum number accepted by the text field.
+*/
+   public void setMinimumValue(double newMinimumValue)
+   {
+      if (newMinimumValue <= 0)
+      {
+         minimumValue  = new Double( newMinimumValue );
+      }
+      else
+      {
+         minimumValue = null;
+      }
+   }
+
+/**
+* Returns the lower limit of the range of numbers to accept.
+* @return The minimum number accepted by this text field.
+*/
+   public double getMinimumValue()
+   {
+      if ( valueType == INTEGER )
+      {
+        return (minimumValue == null) ? (double) Integer.MIN_VALUE : minimumValue.doubleValue();
+      }
+      else
+      {
+        return (minimumValue == null) ? -1.0*Double.MAX_VALUE : minimumValue.doubleValue();
+        // NOTE: Double.MIN_VALUE returns the smallest positive value - oooops.
+      }
+   }
+
+/**
+* Sets which type of number this text field can accept.
+* @see #INTEGER
+* @see #FLOAT
+* @param newValueType The type of number to accept.
+*/
+   public void setValueType(int newValueType)
+   {
+      if ((newValueType != INTEGER) && (newValueType != FLOAT))
+      {
+         valueType = INTEGER;
+      }
+      else
+      {
+         valueType = newValueType;
+      }
+   }
+
+/**
+* Returns which type of number this text field accepts.  The default is
+* integer.
+* @see #INTEGER
+* @see #FLOAT
+* @return The type of number to accept.
+*/
+   public int getValueType()
+   {
+      return valueType;
+   }
+
+/**
+* Returns the integer numeric value of the string in the text field.  The type
+* can be either integer of float.
+* @return The current value in the text field.
+*/
+   public int getIntValue()
+   {
+      int value = 0;
+
+      try
+      {
+         value = Integer.parseInt(getText());
+      }
+      catch (NumberFormatException e)
+      {
+         try
+         {
+            Double dValue = Double.valueOf(getText());
+            value = dValue.intValue();
+         }
+         catch (NumberFormatException ignored) {}
+      }
+
+      return value;
+   }
+
+/**
+* Sets the text field to integer value specified.
+* @param aValue An integer value to display in the text field.
+*/
+   public void setIntValue(int aValue)
+   {
+      setText(Integer.toString(aValue));
+   }
+
+/**
+* Returns the real number numeric value of the string in the text field.  The type
+* can be either integer of float.
+* @return The current value in the text field.
+*/
+   public double getDoubleValue()
+   {
+      Double value = new Double(0);
+
+      try
+      {
+         value = Double.valueOf(getText());
+      }
+      catch (NumberFormatException ignored) {}
+
+      return value.doubleValue();
+   }
+
+/**
+* Sets the text field to the double value specified.  If the text field type is
+* FLOAT then the the number is display as a real number.  If the text field
+* type is INTEGER then the number is converted to a whole number for displaying.
+* @param aValue A double value to display in the text field.
+*/
+   public void setDoubleValue(double aValue)
+   {
+       Double temp = new Double(aValue);
+
+       if (valueType == FLOAT)
+       {
+          setText(temp.toString());
+       }
+       else
+       {
+          setText(Integer.toString(temp.intValue()));
+       }
+   }
+
+/*******************************
+* PROTECTED METHODS
+*******************************/
+
+   protected boolean isValidCharacter(char aChar)
+   {
+      if (((aChar >= ' ') && (aChar <= '/')) || ((aChar >= ':') && (aChar <= '~')))
+      {
+         if (aChar == '.')
+         {
+             if ( valueType == FLOAT )
+             {
+                 return true;
+             }
+             else
+             {
+                 return false;
+             }
+         }
+         else if (aChar == '-')
+         {
+             if ( getMinimumValue() < 0 )
+             {
+                 return true;
+             }
+             else
+             {
+                 return false;
+             }
+         }
+         else if (aChar == '+')
+         {
+             if ( getMaximumValue() >= 0 )
+             {
+                 return true;
+             }
+             else
+             {
+                 return false;
+             }
+         }
+         return false;
+      }
+      return true;
+   }
+
+   protected boolean isValidString(String aString)
+   {
+      int iValue = 0;
+      double dValue = 0.0;
+
+      String tempString = new String(scanForSignChar(aString));
+
+      if ( valueType == INTEGER )
+      {
+          try
+          {
+             iValue = Integer.parseInt(tempString);
+          }
+          catch (NumberFormatException e1)
+          {
+             if ((tempString.compareTo("-") == 0) && (getMinimumValue() < 0.0))
+             {
+                iValue = 0;
+             }
+             else
+             {
+                return false;
+             }
+          }
+          if ((((double)iValue) < getMinimumValue()) || (((double)iValue) > getMaximumValue()))
+          {
+             return false;
+          }
+      }
+      else
+      {
+          // Double.valueOf requires a zero before the decimal point
+          if ( tempString.startsWith( "." ) )
+          {
+              tempString = "0" + tempString;
+          }
+          try
+          {
+             dValue = Double.valueOf(tempString).doubleValue();
+          }
+          catch (NumberFormatException e2)
+          {
+             if ((tempString.compareTo("-") == 0) && (getMinimumValue() < 0.0))
+             {
+                dValue = 0.0;
+             }
+             else
+             {
+                return false;
+             }
+          }
+
+          if ((dValue < getMinimumValue()) || (dValue > getMaximumValue()))
+          {
+             return false;
+          }
+      }
+
+      return true;
+   }
+
+   protected void postProcessing()
+   {
+      if (sign)
+      {
+         setText(scanForSignChar(getText()));
+         setCaretPosition(newCaretPosition);
+      }
+      sign = false;
+   }
+
+
+/*******************************
+* PRIVATE METHODS
+*******************************/
+
+   private String scanForSignChar(String aString)
+   {
+      String newString = "";
+      boolean positive = false;
+      boolean negative = false;
+      int oldCaretPosition = getCaretPosition();
+      int charactersAdded = 0;
+
+      newCaretPosition = 0;
+
+      if (aString.length() <= 0)
+      {
+         return aString;
+      }
+
+      for (int i = 0; i < aString.length(); ++i)
+      {
+         switch (aString.charAt(i))
+         {
+            case '+': positive = true;
+                      break;
+            case '-': negative = true;
+                      break;
+            default:  newString += aString.charAt(i);
+                      charactersAdded++;
+                      break;
+         }
+
+         if ((i + 1) == oldCaretPosition)
+         {
+            newCaretPosition = charactersAdded;
+         }
+      }
+
+      if ((!(positive)) && (negative))
+      {
+         newString = "-" + newString;
+         newCaretPosition++;
+      }
+
+      if (positive || negative)
+      {
+         sign = true;
+      }
+
+      return newString;
+   }
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/PropertyEditorTable.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/PropertyEditorTable.java
new file mode 100644
index 0000000..9db2834
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/PropertyEditorTable.java
@@ -0,0 +1,572 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.Font;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.lang.reflect.Method;
+import java.util.Vector;
+
+import javax.swing.BorderFactory;
+import javax.swing.DefaultCellEditor;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JColorChooser;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JTable;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingUtilities;
+import javax.swing.border.Border;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.TableCellEditor;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+
+/**
+* PropertyEditorTable is a table designed to display and edit the properties
+* of an object.  Because JTable assumes all cells in a column display
+* the same data type, we have to subclass to determine the class
+* based on the cell contents.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class PropertyEditorTable extends JTable {
+
+//
+// Constructors
+//
+
+    /**
+     * Constructs a default JTable which is initialized with a default
+     * data model, a default column model, and a default selection
+     * model.
+     *
+     * @see #createDefaultDataModel
+     * @see #createDefaultColumnModel
+     * @see #createDefaultSelectionModel
+     */
+    public PropertyEditorTable() {
+        super(null, null, null);
+    }
+
+    /**
+     * Constructs a JTable which is initialized with <i>dm</i> as the
+     * data model, a default column model, and a default selection
+     * model.
+     *
+     * @param dm        The data model for the table
+     * @see #createDefaultColumnModel
+     * @see #createDefaultSelectionModel
+     */
+    public PropertyEditorTable(TableModel dm) {
+        super(dm, null, null);
+    }
+
+    /**
+     * Constructs a JTable which is initialized with <i>dm</i> as the
+     * data model, <i>cm</i> as the column model, and a default selection
+     * model.
+     *
+     * @param dm        The data model for the table
+     * @param cm        The column model for the table
+     * @see #createDefaultSelectionModel
+     */
+    public PropertyEditorTable(TableModel dm, TableColumnModel cm) {
+        super(dm, cm, null);
+    }
+
+    /**
+     * Constructs a JTable which is initialized with <i>dm</i> as the
+     * data model, <i>cm</i> as the column model, and <i>sm</i> as the
+     * selection model.  If any of the parameters are <b>null</b> this
+     * method will initialize the table with the corresponding
+     * default model. The <i>autoCreateColumnsFromModel</i> flag is set
+     * to false if <i>cm</i> is non-null, otherwise it is set to true
+     * and the column model is populated with suitable TableColumns
+     * for the columns in <i>dm</i>.
+     *
+     * @param dm        The data model for the table
+     * @param cm        The column model for the table
+     * @param sm        The row selection model for the table
+     * @see #createDefaultDataModel
+     * @see #createDefaultColumnModel
+     * @see #createDefaultSelectionModel
+     */
+    public PropertyEditorTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm) {
+		super( dm, cm, sm );
+	}
+
+    /**
+     * Constructs a JTable with <i>numRows</i> and <i>numColumns</i> of
+     * empty cells using the DefaultTableModel.  The columns will have
+     * names of the form "A", "B", "C", etc.
+     *
+     * @param numRows           The number of rows the table holds
+     * @param numColumns        The number of columns the table holds
+     */
+    public PropertyEditorTable(int numRows, int numColumns) {
+		super( numRows, numColumns );
+    }
+
+    /**
+     * Constructs a JTable to display the values in the Vector of Vectors,
+     * <i>rowData</i>, with column names, <i>columnNames</i>.
+     * The Vectors contained in <i>rowData</i> should contain the values
+     * for that row. In other words, the value of the cell at row 1,
+     * column 5 can be obtained with the following code:
+     * <p>
+     * <pre>((Vector)rowData.elementAt(1)).elementAt(5);</pre>
+     * <p>
+     * All rows must be of the same length as <i>columnNames</i>.
+     * <p>
+     * @param rowData           The data for the new table
+     * @param columnNames       Names of each column
+     */
+    public PropertyEditorTable(final Vector rowData, final Vector columnNames) {
+		super( rowData, columnNames );
+	}	
+
+    /**
+     * Constructs a JTable to display the values in the two dimensional array,
+     * <i>rowData</i>, with column names, <i>columnNames</i>.
+     * <i>rowData</i> is an Array of rows, so the value of the cell at row 1,
+     * column 5 can be obtained with the following code:
+     * <p>
+     * <pre> rowData[1][5]; </pre>
+     * <p>
+     * All rows must be of the same length as <i>columnNames</i>.
+     * <p>
+     * @param rowData           The data for the new table
+     * @param columnNames       Names of each column
+     */
+    public PropertyEditorTable(final Object[][] rowData, final Object[] columnNames) {
+		super( rowData, columnNames );
+	}
+
+    /**
+     * Returns the type of the column at the specified view position.
+     *
+     * @return the type of the column at position <I>column</I> in the view
+     *         where the first column is column 0.
+	 *
+	 * Modified mln: now a wrapper for getCellClass()
+	 *
+     */
+    public Class getColumnClass(int column) {
+		return getCellClass( 0, column );
+    }
+
+    /**
+     * Returns the type of the cell at the specified view position.
+     *
+     * @return the type of the cell at position <I>row</I>, <I>column</I> in the view
+     *         where the first column is column 0.
+	 *
+	 * Modified mln: new methods
+	 *
+     */
+    public Class getCellClass(int row, int column) {
+		TableModel model = getModel();
+		if ( model instanceof PropertyEditorTableModel )
+			return ((PropertyEditorTableModel)model).getCellClass( row, column );
+		else 
+			return model.getColumnClass(convertColumnIndexToModel(column));
+    }
+
+    /**
+     * Return an appropriate renderer for the cell specified by this this row and
+     * column. If the TableColumn for this column has a non-null renderer, return that.
+     * If not, find the class of the data in this column (using getColumnClass())
+     * and return the default renderer for this type of data.
+     *
+     * @param row       the row of the cell to render, where 0 is the first
+     * @param column    the column of the cell to render, where 0 is the first
+	 *
+	 * Modified mln: calls getCellClass if there's no column model
+	 *
+     */
+    public TableCellRenderer getCellRenderer(int row, int column) {
+        TableColumn tableColumn = getColumnModel().getColumn(column);
+        TableCellRenderer renderer = tableColumn.getCellRenderer();
+        if (renderer == null) {
+            renderer = getDefaultRenderer(getCellClass(row, column));
+        }
+        return renderer;
+    }
+
+
+    /**
+     * Return an appropriate editor for the cell specified by this this row and
+     * column. If the TableColumn for this column has a non-null editor, return that.
+     * If not, find the class of the data in this column (using getColumnClass())
+     * and return the default editor for this type of data.
+     *
+     * @param row       the row of the cell to edit, where 0 is the first
+     * @param column    the column of the cell to edit, where 0 is the first
+	 *
+	 * Modified mp: calls getCellClass if there's no column model
+	 *
+     */
+    public TableCellEditor getCellEditor(int row, int column) {
+        TableColumn tableColumn = getColumnModel().getColumn(column);
+        TableCellEditor editor = tableColumn.getCellEditor();
+        if (editor == null) {
+            editor = getDefaultEditor(getCellClass(row, column));
+        }
+        return editor;
+    }
+
+	protected void createDefaultRenderers() {
+		super.createDefaultRenderers();
+
+/*  // copying this code here as a sample of creating a renderer
+	// Dates
+        DefaultTableCellRenderer dateRenderer = new DefaultTableCellRenderer() {
+	    DateFormat formatter = DateFormat.getDateInstance(); 
+            public void setValue(Object value) { 
+	        setText((value == null) ? "" : formatter.format(value)); }
+        };
+        dateRenderer.setHorizontalAlignment(JLabel.RIGHT);
+		setDefaultRenderer(Date.class, dateRenderer); 
+*/
+		
+        DefaultTableCellRenderer fontRenderer = new DefaultTableCellRenderer() {
+            public void setValue(Object value) { 
+				setText( getFontDescription( (Font) value ) );
+			}
+		};
+        fontRenderer.setHorizontalAlignment(JLabel.RIGHT);
+		setDefaultRenderer(Font.class, fontRenderer); 
+
+		setUpColorRenderer( this );
+		setUpMethodRenderer( this );
+    }
+
+	protected String getFontDescription( Font f ) {
+		String s;
+		if ( f != null ) {
+			s = f.getName();
+			if ( f.isBold() ) s += " Bold";
+			if ( f.isItalic() ) s += " Italic";
+			s += " " + f.getSize();
+		} else {
+			s = "";
+		}
+		return s;
+	}
+
+    protected void createDefaultEditors() {
+		super.createDefaultEditors();
+
+/*  // copying this code here as a sample of creating an editor
+        // Numbers
+        JTextField rightAlignedTextField = new JTextField();
+        rightAlignedTextField.setHorizontalAlignment(JTextField.RIGHT);
+        rightAlignedTextField.setBorder(new LineBorder(Color.black));
+        setDefaultEditor(Number.class, new DefaultCellEditor(rightAlignedTextField));
+
+        // Booleans
+        JCheckBox centeredCheckBox = new JCheckBox();
+        centeredCheckBox.setHorizontalAlignment(JCheckBox.CENTER);
+        setDefaultEditor(Boolean.class, new DefaultCellEditor(centeredCheckBox));
+*/
+		setUpColorEditor( this );
+        setUpMethodEditor( this );
+	}
+
+
+	// following code lifted from: 
+	// http://java.sun.com/docs/books/tutorial/ui/swing/example-swing/TableDialogEditDemo.java
+
+    class ColorRenderer extends JLabel
+                        implements TableCellRenderer {
+        Border unselectedBorder = null;
+        Border selectedBorder = null;
+        boolean isBordered = true;
+
+        public ColorRenderer(boolean isBordered) {
+            super();
+            this.isBordered = isBordered;
+            this.setOpaque(true); //MUST do this for background to show up.
+        }
+        
+        public Component getTableCellRendererComponent(
+                                JTable table, Object color, 
+                                boolean isSelected, boolean hasFocus,
+                                int row, int column) {
+            this.setBackground((Color)color);
+            if (isBordered) {
+                if (isSelected) {
+                    if (selectedBorder == null) {
+                        selectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
+                                                  table.getSelectionBackground());
+                    }
+                    this.setBorder(selectedBorder);
+                } else {
+                    if (unselectedBorder == null) {
+                        unselectedBorder = BorderFactory.createMatteBorder(2,5,2,5,
+                                                  table.getBackground());
+                    }
+                    this.setBorder(unselectedBorder);
+                }
+            }
+            return this;
+        }
+    }
+
+    private void setUpColorRenderer(JTable table) {
+        table.setDefaultRenderer(Color.class,
+                                 new ColorRenderer(true));
+    }
+
+    //Set up the editor for the Color cells.
+    private void setUpColorEditor(JTable table) {
+        //First, set up the button that brings up the dialog.
+        final JButton button = new JButton("") {
+            public void setText(String s) {
+                //Button never shows text -- only color.
+            }
+        };
+        button.setBackground(Color.white);
+        button.setBorderPainted(false);
+        button.setMargin(new Insets(0,0,0,0));
+
+        //Now create an editor to encapsulate the button, and
+        //set it up as the editor for all Color cells.
+        final ColorEditor colorEditor = new ColorEditor(button);
+        table.setDefaultEditor(Color.class, colorEditor);
+
+        //Set up the dialog that the button brings up.
+        final JColorChooser colorChooser = new JColorChooser();
+        //XXX: PENDING: add the following when setPreviewPanel
+        //XXX: starts working.
+        //JComponent preview = new ColorRenderer(false);
+        //preview.setPreferredSize(new Dimension(50, 10));
+        //colorChooser.setPreviewPanel(preview);
+        ActionListener okListener = new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                colorEditor.currentColor = colorChooser.getColor();
+            }
+        };
+        final JDialog dialog = JColorChooser.createDialog(button,
+                                        "Pick a Color",
+                                        true,
+                                        colorChooser,
+                                        okListener,
+                                        null); //XXXDoublecheck this is OK
+
+        //Here's the code that brings up the dialog.
+        button.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                button.setBackground(colorEditor.currentColor);
+                colorChooser.setColor(colorEditor.currentColor);
+                //Without the following line, the dialog comes up
+                //in the middle of the screen.
+                //dialog.setLocationRelativeTo(button);
+                dialog.show();
+            }
+        });
+    }
+
+    /*
+     * The editor button that brings up the dialog.
+     * We extend DefaultCellEditor for convenience,
+     * even though it mean we have to create a dummy
+     * check box.  Another approach would be to copy
+     * the implementation of TableCellEditor methods
+     * from the source code for DefaultCellEditor.
+     */
+    class ColorEditor extends DefaultCellEditor {
+        Color currentColor = null;
+
+        public ColorEditor(JButton b) {
+                super(new JCheckBox()); //Unfortunately, the constructor
+                                        //expects a check box, combo box,
+                                        //or text field.
+            editorComponent = b;
+            setClickCountToStart(1); //This is usually 1 or 2.
+
+            //Must do this so that editing stops when appropriate.
+            b.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    fireEditingStopped();
+                }
+            });
+        }
+
+        protected void fireEditingStopped() {
+            super.fireEditingStopped();
+        }
+
+        public Object getCellEditorValue() {
+            return currentColor;
+        }
+
+        public Component getTableCellEditorComponent(JTable table, 
+                                                     Object value,
+                                                     boolean isSelected,
+                                                     int row,
+                                                     int column) {
+            ((JButton)editorComponent).setText(value.toString());
+            currentColor = (Color)value;
+            return editorComponent;
+        }
+    }
+
+    class MethodRenderer extends JLabel
+                        implements TableCellRenderer {
+
+        Method theMethod = null;
+        JTable theTable = null;
+
+        public MethodRenderer() {
+            super();
+        }
+
+        public Component getTableCellRendererComponent(
+                                JTable table, Object method,
+                                boolean isSelected, boolean hasFocus,
+                                int row, int column) {
+            theMethod = (Method) method;
+            theTable = table;
+            setText( "  " + theMethod.getReturnType().getName() );
+            return this;
+        }
+    }
+
+    private void setUpMethodRenderer(JTable table) {
+        table.setDefaultRenderer(Method.class,
+                                 new MethodRenderer());
+    }
+
+    /*
+     * We extend DefaultCellEditor for convenience,
+     * as with ColorEditor.
+     */
+    class MethodEditor extends DefaultCellEditor {
+        Method theMethod = null;
+        JTable theTable = null;
+
+        public MethodEditor(JButton b) {
+                super(new JCheckBox()); //Unfortunately, the constructor
+                                        //expects a check box, combo box,
+                                        //or text field.
+            editorComponent = b;
+            setClickCountToStart(1); //This is usually 1 or 2.
+
+            //Must do this so that editing stops when appropriate.
+            b.addActionListener(new ActionListener() {
+                public void actionPerformed(ActionEvent e) {
+                    fireEditingStopped();
+                }
+            });
+        }
+
+        protected void fireEditingStopped() {
+            super.fireEditingStopped();
+        }
+
+        public Object getCellEditorValue() {
+            return theMethod;
+        }
+
+        public Component getTableCellEditorComponent(JTable table,
+                                                     Object value,
+                                                     boolean isSelected,
+                                                     int row,
+                                                     int column) {
+            ((JButton)editorComponent).setText(value.toString());
+            theMethod = (Method)value;
+            theTable = table;
+            return editorComponent;
+        }
+    }
+
+    //Set up the editor for the Method cells.
+    private void setUpMethodEditor(PropertyEditorTable table) {
+        //First, set up the button that brings up the dialog.
+        final JButton button = new JButton("invoking method") {
+            public void setText(String s) {
+                //Button never shows text -- only color.
+            }
+        };
+        button.setBackground(Color.white);
+        button.setBorderPainted(false);
+        button.setMargin(new Insets(0,0,0,0));
+
+        //Now create an editor to encapsulate the button, and
+        //set it up as the editor for all Color cells.
+        final MethodEditor methodEditor = new MethodEditor(button);
+        table.setDefaultEditor(Method.class, methodEditor);
+
+        // handle the button-click
+        final PropertyEditorTable theTable = table;
+        button.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+
+                Component parent = SwingUtilities.getRoot( theTable );
+                if ( parent == null ) parent = theTable;
+
+                Cursor oldCursor = parent.getCursor();
+                parent.setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR ) );
+
+                Object result = null;
+                Object inspectedObject = ((PropertyEditorTableModel)
+                          methodEditor.theTable.getModel()).inspectedObject;
+                try
+                {
+                    methodEditor.theMethod.setAccessible( true );
+                    result = methodEditor.theMethod.invoke(
+                        inspectedObject, (Object[])null );
+                }
+                catch ( Exception exc )
+                {
+                    System.err.println( "PropertyEditorTable.MethodRenderer.actionPerformed: " +
+                        "Error occurred: " + exc );
+                }
+                theTable.methodInvoked( inspectedObject, methodEditor.theMethod, result );
+
+                parent.setCursor( oldCursor );
+            }
+        });
+    }
+
+/**
+* Called by the method cell editor when a method is invoked.
+* @param anObject The object upon which the method was invoked.
+* @param aMethod The method that was invoked.
+* @param aResult The result of the method invocation; may be null.
+*/
+    public void methodInvoked( Object anObject, Method aMethod, Object aResult )
+    {
+        System.out.println( aMethod.getName() + ": " + aResult );
+    }
+}
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/PropertyEditorTableModel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/PropertyEditorTableModel.java
new file mode 100644
index 0000000..f6a2a8d
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/PropertyEditorTableModel.java
@@ -0,0 +1,418 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.lang.reflect.Method;
+import java.util.Hashtable;
+import java.util.Vector;
+
+import javax.swing.Timer;
+import javax.swing.table.AbstractTableModel;
+
+/**
+* PropertyEditorTableModel introspects an object to facilitate
+* editing it in a PropertyTable.
+*
+* Because the model always reflects the current state of the
+* inspected object, it is useful to have a table update at
+* automated intervals.  By default, this feature is turned off.
+* If you turn it on, you'll want to remember to turn it off
+* when you're done with the table model.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class PropertyEditorTableModel extends AbstractTableModel implements ActionListener
+{
+	protected Object inspectedObject = null;
+
+	final String[] columnNames = { "Property", "Value" };
+    static final String METHOD_TAG = " ";
+
+	Vector properties = new Vector();
+	Hashtable methods = new Hashtable(0);
+
+	public void setObject( Object o ) {
+		inspectedObject = o;
+		Class c = o.getClass();
+		Method[] m = c.getMethods();
+
+		properties = new Vector();
+		methods = new Hashtable(m.length, 1F);
+		String name, propertyName;
+		for ( int i = 0; i < m.length; i++ ) {
+//				if ( m[i].getName().startsWith( "get" ) )
+//					System.out.println( m[i].getName() + ": " + m[i].getReturnType().getName() );
+
+			// get methods
+			if (
+				 ( ( m[i].getName().startsWith( "get" ) ) || ( m[i].getName().startsWith( "is" ) ) )
+				&& ( m[i].getParameterTypes().length == 0 )
+			) {
+                name = m[i].getName();
+                if ( m[i].getName().startsWith( "is" ) ) {
+                    propertyName = name.substring( 2, name.length() );
+                    // probably should only add "is" methods if accompanied by "set" method
+                } else { // "get"
+                    propertyName = name.substring( 3, name.length() );
+                }
+				if (
+					( m[i].getReturnType().getName().equals( String.class.getName() ) )
+				||  ( m[i].getReturnType().getName().equals( "boolean" ) )
+				||  ( m[i].getReturnType().getName().equals( "int" ) )
+				||  ( m[i].getReturnType().getName().equals( "float" ) )
+				||  ( m[i].getReturnType().getName().equals( "char" ) )
+				||  ( m[i].getReturnType().getName().equals( Color.class.getName() ) )
+				||  ( m[i].getReturnType().getName().equals( Font.class.getName() ) )
+				) {
+					properties.addElement( propertyName ); // put property
+					methods.put( name, m[i] ); // put method
+				}
+                else
+                {
+                    // handle unknown types as invokable methods:
+                    properties.addElement( propertyName + METHOD_TAG );
+                    methods.put( propertyName + METHOD_TAG, m[i] );
+                }
+			}
+            else
+			// set methods
+			if ( ( m[i].getName().startsWith( "set" ) ) &&
+				( m[i].getParameterTypes().length == 1 ) ) {
+				name = m[i].getName();
+				if (
+					( m[i].getParameterTypes()[0].getName().equals( String.class.getName() ) )
+				||  ( m[i].getParameterTypes()[0].getName().equals( "boolean" ) )
+				||  ( m[i].getParameterTypes()[0].getName().equals( "int" ) )
+				||  ( m[i].getParameterTypes()[0].getName().equals( "float" ) )
+				||  ( m[i].getParameterTypes()[0].getName().equals( Color.class.getName() ) )
+//				||  ( m[i].getParameterTypes()[0].getName().equals( Font.class.getName() ) )
+				) {
+//					System.out.println( "Accepted: " + name + ": " + m[i].getParameterTypes()[0].getName() );
+					methods.put( name, m[i] ); // set method
+				} else {
+//					System.out.println( "Rejected: " + name + ": " + m[i].getParameterTypes()[0].getName() );
+				}
+			}
+            else
+            // zero-parameter methods to be invoked on click
+			if ( m[i].getParameterTypes().length == 0 )
+            {
+                properties.addElement( m[i].getName() + METHOD_TAG );
+                methods.put( m[i].getName() + METHOD_TAG, m[i] );
+            }
+
+		}
+
+		sort(properties);
+		fireTableDataChanged();
+	}
+
+	public int getColumnCount() {
+	  return columnNames.length;
+	}
+
+	public int getRowCount() {
+	  return properties.size();
+	}
+
+	public String getColumnName(int col) {
+	  return columnNames[col];
+	}
+
+	public Object getValueAt(int row, int col) {
+		if ( col == 0 )
+			return properties.elementAt( row );
+		else
+		{
+			Method m = null;
+				m = (Method) methods.get( "get" + ( (String) properties.elementAt( row ) ) ) ;
+			if ( m == null ) // try "is"
+				m = (Method) methods.get( "is" + ( (String) properties.elementAt( row ) ) ) ;
+            if ( m == null ) { // try entire method name
+				m = (Method) methods.get( (String) properties.elementAt( row ) ) ;
+                if ( m != null ) return m;
+            }
+			try {
+				return m.invoke( inspectedObject, (Object[])null );
+			} catch ( Exception exc ) {
+				System.out.println( "InspectorFrame.tableModel.getValueAt: error occured while reflecting: " );
+				System.out.println( exc );
+			}
+			return null;
+		}
+	}
+
+	public Class getColumnClass( int col ) {
+//		System.out.println( "getColumnClass" );
+/*		try {
+			throw new Exception();
+		} catch ( Exception exc ) {
+			exc.printStackTrace( System.out );
+		}
+*/		return new String().getClass();
+	}
+
+	public Class getCellClass(int row, int col) {
+//		System.out.println( "getCellClass" );
+/*
+
+		Class c;
+		Method m = (Method) methods.get( "set" + ( (String) properties.elementAt( row ) ) ) ;
+		if ( m == null )
+			c = new Object().getClass();
+		else {
+			c = m.getParameterTypes()[0];
+
+			// special case for boolean
+			if ( c.getName().equals( "boolean" ) )
+				c = new Boolean(true).getClass();
+
+			// special case for int
+			if ( c.getName().equals( "int" ) )
+				c = new Integer(0).getClass();
+		}
+		System.out.println( row + ": " + c.getName() );
+		return c;
+*/
+
+//		return new String().getClass();
+
+		Object o = getValueAt( row, col );
+		if ( o == null ) o = "null";
+		return o.getClass();
+	}
+
+	/*
+	* Don't need to implement this method unless your table's
+	* editable.
+	*/
+	public boolean isCellEditable(int row, int col) {
+	  //Note that the data/cell address is constant,
+	  //no matter where the cell appears onscreen.
+	  if (col < 1) {
+		  return false;
+	  } else {
+        // handle method invocation
+        if ( ((String)properties.elementAt(row)).endsWith(METHOD_TAG) ) return true;
+        // handle read-only properties
+		Method m = (Method) methods.get( "set" + ( (String) properties.elementAt( row ) ) ) ;
+		if ( m == null )
+			return false;
+		else
+			return true;
+	  }
+	}
+
+	/*
+	* Don't need to implement this method unless your table's
+	* data can change.
+	*/
+	public void setValueAt(Object value, int row, int col) {
+        // test for inspected object
+		if ( inspectedObject == null ) return;
+        // handle method invocation - no need to update values
+        if ( ((String)properties.elementAt(row)).endsWith( METHOD_TAG ) )
+        {
+            fireTableDataChanged();
+            return;
+        };
+
+        // handle writable properties
+		Method m = (Method) methods.get( "set" + ( (String) properties.elementAt( row ) ) ) ;
+		String parameterType = m.getParameterTypes()[0].getName();
+
+		// ugly cast code
+		if (
+			( parameterType.equals( "int" ) )
+		||	( parameterType.equals( "java.lang.Integer" ) )
+		)
+		{
+            try {
+                value = new Integer((String)value);
+            } catch (NumberFormatException e) {
+                 System.out.println("PropertyEditorTableModel.setValueAt: User attempted to enter non-integer"
+                               + " value (" + value
+                               + ") into an integer-only column.");
+            }
+		}
+		Object[] parameters = { value };
+		try {
+			m.invoke( inspectedObject, parameters );
+			if ( inspectedObject instanceof Component ) {
+				Component c = (Component)inspectedObject;
+				if ( c.getParent() != null )
+					c.getParent().repaint();
+			}
+		} catch ( Exception exc ) {
+			System.out.println( "PropertyEditorTableModel.setValueAt: error occured while reflecting: " );
+			System.out.println( exc );
+		}
+
+		fireTableDataChanged();
+	}
+
+
+    protected void sort(Vector v){
+	quickSort(v, 0, v.size()-1);
+    }
+
+
+    // Liberated from the BasicDirectoryModel which was...
+    // Liberated from the 1.1 SortDemo
+
+    // This is a generic version of C.A.R Hoare's Quick Sort
+    // algorithm.  This will handle arrays that are already
+    // sorted, and arrays with duplicate keys.<BR>
+    //
+    // If you think of a one dimensional array as going from
+    // the lowest index on the left to the highest index on the right
+    // then the parameters to this function are lowest index or
+    // left and highest index or right.  The first time you call
+    // this function it will be with the parameters 0, a.length - 1.
+    //
+    // @param a       an integer array
+    // @param lo0     left boundary of array partition
+    // @param hi0     right boundary of array partition
+    private void quickSort(Vector v, int lo0, int hi0) {
+	int lo = lo0;
+	int hi = hi0;
+	String mid;
+
+	if (hi0 > lo0) {
+	    // Arbitrarily establishing partition element as the midpoint of
+	    // the array.
+	    mid = (String) v.elementAt((lo0 + hi0) / 2);
+
+	    // loop through the array until indices cross
+	    while(lo <= hi) {
+		// find the first element that is greater than or equal to
+		// the partition element starting from the left Index.
+		//
+		// Nasty to have to cast here. Would it be quicker
+		// to copy the vectors into arrays and sort the arrays?
+		while((lo < hi0) && lt((String)v.elementAt(lo), mid)) {
+		    ++lo;
+		}
+
+		// find an element that is smaller than or equal to
+		// the partition element starting from the right Index.
+		while((hi > lo0) && lt(mid, (String)v.elementAt(hi))) {
+		    --hi;
+		}
+
+		// if the indexes have not crossed, swap
+		if(lo <= hi) {
+		    swap(v, lo, hi);
+		    ++lo;
+		    --hi;
+		}
+	    }
+
+
+	    // If the right index has not reached the left side of array
+	    // must now sort the left partition.
+	    if(lo0 < hi) {
+		quickSort(v, lo0, hi);
+	    }
+
+	    // If the left index has not reached the right side of array
+	    // must now sort the right partition.
+	    if(lo < hi0) {
+		quickSort(v, lo, hi0);
+	    }
+
+	}
+    }
+
+    private void swap(Vector a, int i, int j) {
+	Object T = a.elementAt(i);
+	a.setElementAt(a.elementAt(j), i);
+	a.setElementAt(T, j);
+    }
+
+    protected boolean lt(String a, String b) {
+	return a.compareTo(b) < 0;
+    }
+
+    // automated updates
+
+    private boolean autoUpdating = false;
+    private int updateInterval = 2000; // one-second delay on average
+    protected Timer timer = null;
+
+    public boolean isAutoUpdating()
+    {
+        return autoUpdating;
+    }
+
+    public void setAutoUpdating( boolean shouldAutoUpdate )
+    {
+        if ( shouldAutoUpdate )
+        {
+            if ( timer == null )
+            {
+                timer = new Timer( updateInterval, this );
+                timer.setRepeats( true );
+                timer.start();
+            }
+        }
+        else
+        {
+            if ( timer != null )
+            {
+                timer.stop();
+                timer = null;
+            }
+        }
+
+        autoUpdating = shouldAutoUpdate;
+    }
+
+    public int getUpdateInterval()
+    {
+        return updateInterval;
+    }
+
+    public void setUpdateInterval( int anInterval )
+    {
+        if ( timer != null )
+        {
+            timer.setDelay( anInterval );
+        }
+
+        updateInterval = anInterval;
+    }
+
+    public void actionPerformed( ActionEvent evt )
+    {
+        if ( evt.getSource() == timer )
+        {
+            fireTableDataChanged();
+        }
+    }
+
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/RadioButtonPanel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/RadioButtonPanel.java
new file mode 100644
index 0000000..2956c71
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/RadioButtonPanel.java
@@ -0,0 +1,174 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Component;
+
+import javax.swing.AbstractButton;
+import javax.swing.ButtonGroup;
+import javax.swing.JRadioButton;
+import javax.swing.border.EmptyBorder;
+
+/**
+* RadioButtonPanel is a simple extension of ButtonPanel.
+* Differences are that it uses radio buttons and the
+* default alignment is vertical.  The radio buttons are
+* placed in a ButtonGroup and the panel defaults to having
+* no buttons selected.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+* $Date: 2006-02-18 18:19:05 -0500 (Sat, 18 Feb 2006) $
+*/
+public class RadioButtonPanel extends ButtonPanel
+{
+/**
+* A ButtonGroup to help manage button state.
+*/
+    protected ButtonGroup buttonGroup;
+
+/**
+* ButtonGroup does not make it easy to unselect all buttons.
+* The preferred way to do it is actually to create a hidden button.
+*/
+    protected JRadioButton hiddenButton;
+
+/**
+* Constructs a RadioButtonPanel.  Three buttons are created
+* so the panel is filled when used in a GUI-builder environment.
+*/
+    public RadioButtonPanel()
+    {
+        super();
+    }
+
+/**
+* Constructs a ButtonPanel using specified buttons.
+* @param buttonList An array containing the strings to be used in labeling the buttons.
+*/
+    public RadioButtonPanel( String[] buttonList )
+    {
+        super( buttonList );
+    }
+
+/**
+* Overridden to set vertical-center alignment and 2-pixel vgap.
+*/
+    protected void initLayout()
+    {
+        super.initLayout();
+        buttonPanelLayout.setAlignment( BetterFlowLayout.CENTER_VERTICAL );
+        buttonPanelLayout.setVgap( 2 ); // looks nicer than java l&f recommendation (imho)
+    }
+
+/**
+* Overridden to return a JRadioButton.
+* @param aLabel The label for the component that will be created.
+* @return The newly created component.
+*/
+    protected Component createComponentWithLabel( String aLabel )
+    {
+        String buttonLabel = aLabel;
+        JRadioButton newButton = new JRadioButton();
+        newButton.setName( aLabel );
+        newButton.setText( buttonLabel );
+        newButton.setActionCommand( aLabel );
+        newButton.addActionListener( this );
+
+        // reduce insets per java l&f guidelines (was 4 on each side)
+        newButton.setBorder( new EmptyBorder( 0, 4, 0, 4 ) );
+
+        if ( buttonGroup == null )
+        {
+            buttonGroup = new ButtonGroup();
+
+            // cheesy hack to allow a buttongroup to have no items selected.
+            //   note that the button is not added to container or buttonList.
+            hiddenButton = new JRadioButton( "Hidden Button" );
+            buttonGroup.add( hiddenButton );
+        }
+        buttonGroup.add( newButton );
+
+        return newButton;
+    }
+
+/**
+* Selects the button whose name matches the given text value.
+* @param newText A String matching the name of one of the buttons.
+* If null, empty, or not matching, all buttons are deselected.
+*/
+    public void setValue(String aName)
+    {
+        if ( aName != null )
+        {
+            Component c = null;
+            int count = buttonContainer.getComponentCount();
+            for ( int i = 0; i < count; i++ )
+            {
+                c = buttonContainer.getComponent( i );
+                if ( c instanceof AbstractButton )
+                {
+                    if ( c.getName().equals( aName ) )
+                    {
+                        ((AbstractButton)c).setSelected( true );
+                        return;
+                    }
+                }
+            }
+        }
+
+        // null, empty, or not matching - deselect all
+        hiddenButton.setSelected( true );
+    }
+
+/**
+* Gets the name of the currently selected button.
+* @return A string matching the name of the currently selected button,
+* or null of no button is selected.
+*/
+    public String getValue()
+    {
+        String result = null;
+        Component c = null;
+        int count = buttonContainer.getComponentCount();
+        for ( int i = 0; i < count; i++ )
+        {
+            c = buttonContainer.getComponent( i );
+            if ( ( c instanceof AbstractButton ) && ( ((AbstractButton)c).isSelected() ) )
+            {
+                return c.getName();
+            }
+        }
+        return result;
+    }
+
+/**
+* Tests whether the specified value is checked.
+* @param aValue A value to be tested.
+* @return True if the specified value is checked, otherwise false.
+*/
+    public boolean getValue( String aValue )
+    {
+        if ( aValue == null ) return false;
+        return aValue.equals( getValue() );
+    }
+
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/SmartPasswordField.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/SmartPasswordField.java
new file mode 100644
index 0000000..6914cf6
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/SmartPasswordField.java
@@ -0,0 +1,274 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.event.KeyEvent;
+
+import javax.swing.JPasswordField;
+
+/**
+ * SmartPasswordField is an extention of JPasswordField.  It does everything
+ * a JPassword does, as well as limit the number of characters.  The user
+ * of this class can specify that a password can only have a maximum of
+ * 10 characters for instance.
+ *
+ * @author rob@straylight.princeton.com
+ * @author $Author: cgruber $
+ * @version $Revision: 904 $
+ */
+public class SmartPasswordField extends JPasswordField
+{
+
+/*******************************
+* CONSTANTS
+*******************************/
+   private static final int BACKSPACE = 8;
+   private static final int DELETE = 127;
+   private static final int SPACE = 32;
+   private static final int DASH = 45;
+   private static final int UNDERSCORE = 95;
+   private static final int PERIOD = 46;
+   private static final int PASTE = 22;  // Ctl-V
+
+   private int passwordLength = Integer.MAX_VALUE;
+
+/*******************************
+* PUBLIC METHODS
+*******************************/
+
+/**
+* Default constructor.
+*/
+   public SmartPasswordField()
+   {
+       super();
+   }
+
+/**
+* This constructor allows the user to set the maximum length of the password.
+* @param aLength The maximum length of the password.
+*/
+   public SmartPasswordField( int aLength )
+   {
+       this();
+       setPasswordLength( aLength );
+   }
+
+/**
+* Sets the maximum lenght of the password.  The value must be 0 or greater.
+* If the length specified is less than 0, then no action occurs.
+* @param aLength The maximum lenght of the password.
+*/
+    public void setPasswordLength( int aLength )
+    {
+        if ( aLength >= 0 )
+        {
+            passwordLength = aLength;
+        }
+    }
+
+/**
+* Returns the current maximum length of the password.
+* @return The current maximum length of the password.
+*/
+    public int getPasswordLength()
+    {
+        return passwordLength;
+    }
+
+/**
+* This method processes a key event.  This event is generated by input from the
+* keyboard when this text field has the focus.  This method is called for every
+* key that is pressed and released on the keyboard.  This includes modifier
+* keys like the shift and alt keys.  This class looks at the key and determines
+* if the key is valid input given the restrictions of this class. <BR> <BR>
+* @param e A key event generated by a keyboard action.
+*/
+   public void processKeyEvent(KeyEvent e)
+   {
+      String currentText = "";
+      String testString = "";
+      char newChar = e.getKeyChar();
+      int currentLength = 0;
+      int selectionStart = 0;
+      int selectionEnd = 0;
+      int endOfHead = 0;
+      int startOfTail = 0;
+      boolean backspace = false;
+      boolean delete = false;
+      boolean paste = false;
+      boolean insertionPoint = false;
+      boolean selectionAtStart = false;
+      boolean selectionAtEnd = false;
+
+      backspace = (newChar == BACKSPACE);
+      delete = (newChar == DELETE);
+      paste = (newChar == PASTE);
+
+      if ((e.getKeyCode() == KeyEvent.VK_UNDEFINED) || ((backspace) || (delete) || (paste)))  // A "key-typed" event
+      {
+         if (isValidCharacter(newChar))
+         {
+
+            if ((isPrintableCharacter(newChar)) || (backspace) || (delete) || (paste))
+            {
+               // Analyze the current contents of the field
+               currentText = new String( getPassword() );
+               currentLength = currentText.length();
+
+               selectionStart = getSelectionStart();
+               selectionEnd = getSelectionEnd();
+
+               insertionPoint = (selectionStart == selectionEnd);
+               selectionAtStart = (selectionStart == 0);
+               selectionAtEnd = (selectionEnd >= currentLength);
+               if (selectionEnd > currentLength)
+               {
+                  setSelectionEnd(currentLength);
+               }
+
+               // Generate new string
+               if (selectionStart > 0) // Create head of test string
+               {
+                  endOfHead = selectionStart;
+                  if (insertionPoint && backspace)
+                  {
+                     endOfHead -= 1;
+                  }
+                  testString += currentText.substring(0, endOfHead);
+               }
+
+               if (!(backspace || delete || paste))  // Add the new character
+               {
+                  testString += newChar;
+               }
+
+               if (paste)  // Add the string from the clipboard
+               {
+                  Transferable data = getToolkit().getSystemClipboard().getContents(this);
+                  if (data != null)
+                  {
+                     try
+                     {
+                        String clipString = (String)data.getTransferData(DataFlavor.stringFlavor);
+                        testString += clipString;
+                     }
+                     catch (java.io.IOException ioe)
+                     {
+                        // Do nothing
+                     }
+                     catch (UnsupportedFlavorException ufe)
+                     {
+                        // Do nothing
+                     }
+                  }
+               }
+
+               if (selectionEnd < currentLength) // Add the tail of the string
+               {
+                  startOfTail = selectionEnd;
+                  if (insertionPoint && delete)
+                  {
+                     startOfTail += 1;
+                  }
+                  testString += currentText.substring(startOfTail);
+               }
+
+            }
+
+            if (testString.compareTo("") != 0)  // Null string is OK
+            {
+               if (!(isValidString(testString)))
+               {
+                  e.consume();
+               }
+            }
+         }
+         else
+         {
+            e.consume();
+         }
+      }
+      super.processKeyEvent(e);
+
+      postProcessing();
+   }
+
+
+/*******************************
+* PROTECTED METHODS
+*******************************/
+
+/**
+* Returns whether the inputted character is valid or not.  In this case all
+* characters are valid input.
+* @param aChar A character to perform the validity test with.
+* @return True if the character is valid for this subclassed text field. <BR>
+*         False is the character is not valid.
+*/
+   protected boolean isValidCharacter(char aChar)
+   {
+       return true;
+   }
+
+/**
+* Returns whether a string is valid for this text field.  As the user types from
+* the keyboard, this method is called to determine if the new string in the text
+* field is valid based upon the restriction of this class.  The length of the
+* new string is checked against the maximum password length.
+* @param aString The string to perform the validity check with.
+* @return True if the length of the string is less than or equal to the maximum length.
+*         False if the character is not valud.
+*/
+   protected boolean isValidString(String aString)
+   {
+       if ( aString.length() > passwordLength )
+       {
+           return false;
+       }
+
+       return true;
+   }
+
+/**
+* This class does not need any post processing.
+*/
+   protected void postProcessing()
+   {
+       /* Do Nothing */
+   }
+
+
+/*******************************
+* PRIVATE METHODS
+*******************************/
+
+   private boolean isPrintableCharacter(char inputChar)
+   {
+      if ((inputChar >= ' ') && (inputChar <= '~'))
+      {
+         return true;
+      }
+      return false;
+   }
+
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/SmartTextField.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/SmartTextField.java
new file mode 100644
index 0000000..cee37e1
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/SmartTextField.java
@@ -0,0 +1,244 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.event.KeyEvent;
+
+import javax.swing.JTextField;
+
+/**
+ * SmartTextField is an abstract class for that allows the text field to
+ * intelligently analyze the user's input in real-time.  As the user enters
+ * keystrokes, the generated string is analyzed to determine if the new string
+ * is valid based on the criteria of the concrete classes that extend this
+ * class.  An invalid keystroke is rejected and not displayed in the text
+ * field.  This class can be extended to to create smart text fields that only
+ * accept integers or floating points number or alphabetic strings of maximum
+ * length.  These are several examples.
+ *
+ * @author rob@straylight.princeton.com
+ * @author $Author: cgruber $
+ * @version $Revision: 904 $
+ */
+public abstract class SmartTextField extends JTextField
+{
+
+/*******************************
+* CONSTANTS
+*******************************/
+   private static final int BACKSPACE = 8;
+   private static final int DELETE = 127;
+   private static final int SPACE = 32;
+   private static final int DASH = 45;
+   private static final int UNDERSCORE = 95;
+   private static final int PERIOD = 46;
+   private static final int PASTE = 22;  // Ctl-V
+
+   
+/*******************************
+* PUBLIC METHODS
+*******************************/
+
+/**
+* This method processes a key event.  This event is generated by input from the
+* keyboard when this text field has the focus.  This method is called for every
+* key that is pressed and released on the keyboard.  This includes modifier
+* keys like the shift and alt keys.  This class looks at the key and determines
+* if the key is valid input given the restrictions of the concrete sub-classes. <BR> <BR>
+* Example - A smart text field only allows alphabetic characters.  If the key
+* pressed is a "2" then this method will determine that the key is invalid and
+* "consume" the key event. <BR> <BR>
+* Note - Every printable character has a "TYPED" key event.  Currentlt under
+* Java 1.2.1 this does not happen.  Bug 4186905 relating this bug has been
+* fixed and is awaiting release.
+* @param e A key event generated by a keyboard action.
+*/
+   public void processKeyEvent(KeyEvent e)
+   {
+      String currentText = "";
+      String testString = "";
+      char newChar = e.getKeyChar();
+      int currentLength = 0;
+      int selectionStart = 0;
+      int selectionEnd = 0;
+      int endOfHead = 0;
+      int startOfTail = 0;
+      boolean backspace = false;
+      boolean delete = false;
+      boolean paste = false;
+      boolean insertionPoint = false;
+      boolean selectionAtStart = false;
+      boolean selectionAtEnd = false;
+
+      backspace = (newChar == BACKSPACE);
+      delete = (newChar == DELETE);
+      paste = (newChar == PASTE);
+
+      if ((e.getKeyCode() == KeyEvent.VK_UNDEFINED) || ((backspace) || (delete) || (paste)))  // A "key-typed" event
+      {
+         if (isValidCharacter(newChar))
+         {
+
+            if ((isPrintableCharacter(newChar)) || (backspace) || (delete) || (paste))
+            {
+               // Analyze the current contents of the field
+               currentText = getText();
+               currentLength = currentText.length();
+
+               selectionStart = getSelectionStart();
+               selectionEnd = getSelectionEnd();
+
+               insertionPoint = (selectionStart == selectionEnd);
+               selectionAtStart = (selectionStart == 0);
+               selectionAtEnd = (selectionEnd >= currentLength);
+               if (selectionEnd > currentLength)
+               {
+                  setSelectionEnd(currentLength);
+               }
+
+               // Generate new string
+               if (selectionStart > 0) // Create head of test string
+               {
+                  endOfHead = selectionStart;
+                  if (insertionPoint && backspace)
+                  {
+                     endOfHead -= 1;
+                  }
+                  testString += currentText.substring(0, endOfHead);
+               }
+
+               if (!(backspace || delete || paste))  // Add the new character
+               {
+                  testString += newChar;
+               }
+
+               if (paste)  // Add the string from the clipboard
+               {
+                  Transferable data = getToolkit().getSystemClipboard().getContents(this);
+                  if (data != null)
+                  {
+                     try
+                     {
+                        String clipString = (String)data.getTransferData(DataFlavor.stringFlavor);
+                        testString += clipString;
+                     }
+                     catch (java.io.IOException ioe)
+                     {
+                        // Do nothing
+                     }
+                     catch (UnsupportedFlavorException ufe)
+                     {
+                        // Do nothing
+                     }
+                  }
+               }
+
+               if (selectionEnd < currentLength) // Add the tail of the string
+               {
+                  startOfTail = selectionEnd;
+                  if (insertionPoint && delete)
+                  {
+                     startOfTail += 1;
+                  }
+                  testString += currentText.substring(startOfTail);
+               }
+
+            }
+
+            if (testString.compareTo("") != 0)  // Null string is OK
+            {
+               if (!(isValidString(testString)))
+               {
+                  e.consume();
+               }
+            }
+         }
+         else
+         {
+            e.consume();
+         }
+      }
+      super.processKeyEvent(e);
+
+      postProcessing();
+   }
+
+
+/*******************************
+* PROTECTED METHODS
+*******************************/
+
+/**
+* Default constructor for this class.  The initial text of the smart text field
+* can be specified as well as the size (in characters) of the text field.
+* @param text The initial string that is displayed in the text field.
+* @param columns THe width of the text field in characters.
+*/
+   protected SmartTextField(String text, int columns)
+   {
+      super(text, columns);
+   }
+
+/**
+* Returns whether a character is valid for this text field.  As the user types
+* from the keyboard, this method is called to determine if the character is a
+* valid character based in the restrictions of the subclass.
+* @param aChar A character to perform the validity test with.
+* @return True if the character is valid for this subclassed text field. <BR>
+*         False is the character is not valid.
+*/
+   abstract protected boolean isValidCharacter(char aChar);
+
+/**
+* Returns whether a string is valid for this text field.  As the user types from
+* the keyboard, this method is called to determine if the new string in the text
+* field is valid based upon the restriction of the subclass.  This is done after
+* the character has been determined to be valid since there can be restrictions
+* placed on the text string as a whole, such a maximum length or date format.
+* @param aString The string to perform the validity check with.
+* @return True if the string is valid for this subclassed text field. <BR>
+*         False if the character is not valud.
+*/
+   abstract protected boolean isValidString(String aString);
+
+/**
+* This method is used by the any subclass that need to complete any processing
+* of the text string in the text field after all the requirement checks have
+* been performed.
+*/
+   abstract protected void postProcessing();
+
+
+/*******************************
+* PRIVATE METHODS
+*******************************/
+
+   private boolean isPrintableCharacter(char inputChar)
+   {
+      if ((inputChar >= ' ') && (inputChar <= '~'))
+      {
+         return true;
+      }
+      return false;
+   }
+
+}
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/StatusButtonPanel.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/StatusButtonPanel.java
new file mode 100644
index 0000000..3d9a85b
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/StatusButtonPanel.java
@@ -0,0 +1,276 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Blacksmith, Inc.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.lang.reflect.Method;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.Timer;
+import javax.swing.UIManager;
+import javax.swing.border.EmptyBorder;
+
+/**
+* StatusButtonPanel extends ButtonPanel to provide a space
+* to display status messages in a consistent manner.<BR><BR>
+* Messages are erased after a certain predefined interval,
+* defaulting to 10 seconds.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class StatusButtonPanel extends ButtonPanel
+{
+/**
+*   This is the action command to all listeners when the status text is changed.
+*/
+    public static final String STATUS_CHANGED = "STATUS_CHANGED";
+
+    // note: weirdness happens if you initialize
+    //  this variable.  Because it is set by initLayout
+    //  and initLayout is called by the superclass constructor,
+    //  this variable would get initialized after initLayout
+    //  is called...
+    protected Component statusComponent; // = null;
+
+    protected Timer timer = null;
+    protected int interval = 10000; // adjust as needed
+
+/**
+* Constructs a StatusButtonPanel.  Three buttons are created
+* so the panel is filled when used in a GUI-builder environment.
+*/
+    public StatusButtonPanel()
+    {
+        super();
+        setupTimer();
+    }
+
+/**
+* Constructs a StatusButtonPanel using specified buttons.
+* @param buttonList An array containing the strings to be used in labeling the buttons.
+*/
+    public StatusButtonPanel( String[] buttonList )
+    {
+        super( buttonList );
+        setupTimer();
+    }
+
+/**
+* Initializes the timer instance variable.
+*/
+    protected void setupTimer()
+    {
+        timer = new Timer( interval, this );
+        timer.addActionListener( this );
+        timer.setRepeats( false );
+        timer.start();
+    }
+
+/**
+* Returns the number of milliseconds before the status message is cleared.
+* The default is 10000.
+* @return The current delay interval in milliseconds.
+*/
+    public int getDelayInterval()
+    {
+        return interval;
+    }
+
+/**
+* Sets the number of milliseconds before the status message is cleared.
+* @param millis The new delay interval in milliseconds.
+*/
+    public void setDelayInterval( int millis )
+    {
+        interval = millis;
+        timer.setDelay( interval );
+    }
+
+/**
+* Returns the visual component used to display the status.
+* @return A component used for displaying status.
+*/
+    public Component getStatusComponent()
+    {
+        return statusComponent;
+
+    }
+/**
+* Receives ActionEvents from the internal timer.
+* @param e The action event in question.
+*/
+     public void actionPerformed(ActionEvent e)
+     {
+        if ( e.getSource() == timer )
+        {
+            setText( "" );
+            return;
+        }
+
+        // otherwise continue with superclass implementation
+        super.actionPerformed( e );
+    }
+
+/**
+* This method is responsible for the initial layout of the panel.
+* Subclasses can implement different layouts, but this method
+* is responsible for initializing buttonPanelLayout to a valid
+* layout manager and setting this panel to use it.  This method
+* must should initialize statusComponent to a component that ideally
+* has get/setText methods, although this is not required.
+*/
+    protected void initLayout()
+    {
+
+        statusComponent = new JTextField();
+        JTextField textField = (JTextField) statusComponent;
+        textField.setColumns( 20 );
+        textField.setBackground( getBackground() );
+        textField.setEditable( false );
+
+//        statusComponent = new PickListPanel(); // for testing
+
+        this.setLayout( new GridBagLayout() );
+
+        GridBagConstraints gbc =
+		new GridBagConstraints();
+	gbc.gridx = GridBagConstraints.RELATIVE;
+	gbc.gridy = GridBagConstraints.RELATIVE;
+	gbc.gridwidth = 1;
+	gbc.gridheight = 1;
+	gbc.weightx = 1.0;
+	gbc.weighty = 0.0;
+	gbc.anchor = GridBagConstraints.CENTER;
+	gbc.fill = GridBagConstraints.HORIZONTAL;
+	gbc.insets = new Insets(0, 5, 0, 10);
+	gbc.ipadx = 0;
+	gbc.ipady = 0;
+
+//1.2        new GridBagConstraints(GridBagConstraints.RELATIVE, GridBagConstraints.RELATIVE, 1, 1, 1.0, 0.0,
+//1.2            GridBagConstraints.CENTER, GridBagConstraints.HORIZONTAL, new Insets(0, 5, 0, 10), 0, 0 );
+
+        this.add( statusComponent, gbc );
+
+        buttonContainer = new JPanel();
+        buttonPanelLayout = new BetterFlowLayout();
+        buttonContainer.setLayout(buttonPanelLayout);
+        buttonPanelLayout.setAlignment( BetterFlowLayout.RIGHT );
+        ((BetterFlowLayout)buttonPanelLayout).setWidthUniform( true );
+        gbc.weightx = 0.0;
+        gbc.insets = new Insets( 0, 0, 0, 0 );
+        this.add( buttonContainer, gbc );
+    }
+
+/**
+*   Sets the text to appear in the status area.
+*   @param newText A string to appear in the status area.  Nulls are allowed.
+*/
+    public void setText(String newText)
+    {
+        // TODO: should use property introspection instead
+
+        // use reflection to call the "setText" method, if any.
+        try
+        {
+            Class c = statusComponent.getClass();
+            Method m = c.getMethod( "setText", new Class[] { new String().getClass() } );
+            m.invoke( statusComponent, new Object[] { newText } );
+            broadcastEvent( new ActionEvent( this, ActionEvent.ACTION_PERFORMED, STATUS_CHANGED ) );
+            statusComponent.paint( statusComponent.getGraphics() );
+        }
+        catch ( Exception exc )
+        {
+            // "setText" method does not exist; do nothing.
+        }
+
+        // if non-empty string, start the timer
+        if ( ! "".equals( newText ) )
+        {
+            timer.restart();
+        }
+    }
+
+/**
+*   Gets the text in the status area.
+*   @return The string being displayed in the status area.
+*/
+    public String getText()
+    {
+        // TODO: should use property introspection instead
+
+        String value = "";
+        // use reflection to call the "setText" method, if any.
+        try
+        {
+            Class c = statusComponent.getClass();
+            Method m = c.getMethod( "getText", (Class[])null );
+            value = (String) m.invoke( statusComponent, (Object[])null );
+        }
+        catch ( Exception exc )
+        {
+            // "getText" method does not exist; do nothing.
+        }
+        return value;
+    }
+
+    // for testing
+
+    public static void main( String[] argv )
+    {
+        try
+        {
+            UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );
+        }
+        catch (Exception exc)
+        {
+
+        }
+
+        JFrame dialog = new JFrame();
+        BorderLayout bl = new BorderLayout( 20, 20 );
+
+//        StatusButtonPanel panel = new StatusButtonPanel();
+//        System.out.println( panel.statusComponent );
+        StatusButtonPanel panel = new StatusButtonPanel( new String[] { "Okay", "Cancel" } );
+
+        dialog.getContentPane().setLayout( bl );
+        dialog.getContentPane().add( panel, BorderLayout.SOUTH );
+        dialog.setLocation( 50, 50 );
+        // dialog.setSize( 450, 150 );
+        dialog.pack();
+        dialog.setVisible( true );
+
+        panel.setBorder( new EmptyBorder( 5, 5, 5, 5 ) );
+        panel.setAlignment( BetterFlowLayout.RIGHT );
+//        panel.getButton( "One" ).setEnabled( false );
+        panel.setText( "File saved." );
+        System.out.println( panel.getText() );
+    }
+
+}
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TintedImageFilter.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TintedImageFilter.java
new file mode 100644
index 0000000..a51ed16
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TintedImageFilter.java
@@ -0,0 +1,100 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2001 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Color;
+import java.awt.image.RGBImageFilter;
+
+/**
+ * TintedImageFilter tints all gray pixels half-way towards
+ * the value passed into the constructor.  This "tints" a
+ * mostly grayscale image.  This has proven useful for tinting
+ * user interface decorative images towards one of the SystemColor 
+ * constants to better mesh with a platform look and feel.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 893 $
+ */
+    public class TintedImageFilter extends RGBImageFilter
+    {
+        double redOffset, greenOffset, blueOffset;
+        
+	    public TintedImageFilter( Color aColor ) 
+        {
+    		canFilterIndexColorModel = true;
+            redOffset = getOffset( aColor.getRed() );
+            greenOffset = getOffset( aColor.getGreen() );
+            blueOffset = getOffset( aColor.getBlue() );
+	    }
+        
+        /**
+        * Calculates the offset used to modify color 
+        * values.  This method returns half the difference
+        * between the specified color level and 192.
+        */
+        protected double getOffset( int colorValue )
+        {
+            return ( colorValue - 192 ) / 2;   
+        }
+
+	    public int filterRGB(int x, int y, int rgb) 
+        {
+
+            int red   = ( rgb & 0xff0000 ) >> 16;
+            int green = ( rgb & 0x00ff00 ) >> 8;
+            int blue  = ( rgb & 0x0000ff );
+            
+            // if roughly black
+            if ( red + green + blue < 30 ) return rgb;
+            
+            // if roughly gray
+            if ( ( Math.abs( red - green ) < 10 ) 
+            && ( Math.abs( red - blue ) < 10 ) )
+            {
+                red += redOffset;
+                if ( red < 0 ) red = 0; 
+                if ( red > 255 ) red = 255;
+                green += greenOffset;
+                if ( green < 0 ) green = 0; 
+                if ( green > 255 ) green = 255;
+                blue += blueOffset;
+                if ( blue < 0 ) blue = 0; 
+                if ( blue > 255 ) blue = 255;
+                
+                return new Color( red, green, blue ).getRGB();                
+            }
+            
+            return rgb;
+        }            
+    }
+    
+/*
+ * $Log$
+ * Revision 1.1  2006/02/16 13:22:22  cgruber
+ * Check in all sources in eclipse-friendly maven-enabled packages.
+ *
+ * Revision 1.2  2001/01/18 21:27:04  mpowers
+ * Made the tinting a little darker.
+ *
+ * Revision 1.1  2001/01/12 17:36:27  mpowers
+ * Contributing TintedImageFilter.
+ *
+ *
+ */
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TreeChooser.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TreeChooser.java
new file mode 100644
index 0000000..f0bb6c2
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TreeChooser.java
@@ -0,0 +1,727 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.Enumeration;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+import java.util.Vector;
+
+import javax.swing.ComboBoxModel;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JToolBar;
+import javax.swing.JTree;
+import javax.swing.ListCellRenderer;
+import javax.swing.ListSelectionModel;
+import javax.swing.UIManager;
+import javax.swing.event.ListDataEvent;
+import javax.swing.event.ListDataListener;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.event.TreeModelEvent;
+import javax.swing.event.TreeModelListener;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.DefaultTreeSelectionModel;
+import javax.swing.tree.TreeCellRenderer;
+import javax.swing.tree.TreeModel;
+import javax.swing.tree.TreePath;
+import javax.swing.tree.TreeSelectionModel;
+
+import net.wotonomy.foundation.internal.WotonomyException;
+
+/**
+* TreeChooser is a FileChooser-like panel that
+* uses a TreeModel as a data source.  It basically
+* provides an alternative to JTree for rendering 
+* and manipulating tree-like data.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class TreeChooser extends JPanel 
+    implements ActionListener, ListSelectionListener, 
+        TreeSelectionListener, TreeModelListener, ListCellRenderer
+{   
+    /**
+    * The TreeChooser responds to this action command
+    * by calling displayPrevious().
+    */
+	public static final String BACK = "Back";
+
+    /**
+    * The TreeChooser responds to this action command
+    * by calling displayHome().
+    */
+	public static final String HOME = "Home";
+
+    /**
+    * The TreeChooser responds to this action command
+    * by calling displayParent().
+    */
+	public static final String UP = "Up";
+
+    /**
+    * The TreeChooser responds to this action command
+    * by attempting to navigate to the first node in
+    * the current selection and display that node's children.
+    */
+	public static final String SELECT = "Select";
+
+	protected JList contents;
+	protected JComboBox pathCombo; 
+	protected JToolBar toolBar;
+	
+	protected TreeModel model;
+	protected TreeSelectionModel selectionModel;
+    protected TreeCellRenderer renderer;
+    protected TreePath displayPath;
+    protected Stack pathStack;
+    protected int pathIndent;	
+    
+    private ChooserComboBoxModel comboBoxModel;
+    private JTree bogusJTree; // needed for tree cell renderer
+    private Dimension preferredSize;
+	
+    public TreeChooser()
+    {
+        preferredSize = new Dimension( 300, 200 );
+        model = new DefaultTreeModel( new DefaultMutableTreeNode( "Root" ) );
+        displayPath = new TreePath( model.getRoot() );
+        selectionModel = new DefaultTreeSelectionModel();
+        renderer = new DefaultTreeCellRenderer();
+        pathStack = new Stack();
+        pathIndent = 0; // 16;
+        comboBoxModel = new ChooserComboBoxModel( this );
+        
+        bogusJTree = new JTree();
+        bogusJTree.setModel( model );
+
+		init();
+        displayHome();
+        
+        stopListening(); // clear existing listeners
+        startListening();
+	}
+    
+    public Dimension getPreferredSize()
+    {
+        return preferredSize;
+    }
+    
+	protected void init()
+	{
+		this.setLayout( new BorderLayout( 10, 10 ) );	
+		
+		contents = initList();
+        contents.getSelectionModel().setSelectionMode( 
+                ListSelectionModel.MULTIPLE_INTERVAL_SELECTION );
+                // synchs with DefaultTreeSelectionModel
+
+		JScrollPane scrollPane = new JScrollPane( contents );
+		scrollPane.setPreferredSize( new Dimension( 200, 150 ) );
+		this.add( scrollPane, BorderLayout.CENTER );
+
+        Component previewPane = initPreviewPane();
+        if ( previewPane != null )
+        {
+            this.add( previewPane, BorderLayout.EAST );
+        }
+		
+		JPanel navigationPanel = new JPanel();
+		navigationPanel.setLayout( new BorderLayout( 10, 10 ) );
+		this.add( navigationPanel, BorderLayout.NORTH );
+        
+		pathCombo = initComboBox();
+        if ( pathCombo != null )
+        {
+            pathCombo.setModel( comboBoxModel );
+
+			// put combo in a grid bag to handle varying
+			//  heights of JToolBars across platforms
+			JPanel panel = new JPanel();
+			panel.setLayout( new GridBagLayout() );
+			GridBagConstraints gbc = new GridBagConstraints();
+			gbc.fill = GridBagConstraints.HORIZONTAL;
+			gbc.weightx = 1.0;
+			panel.add( pathCombo, gbc );
+            navigationPanel.add( panel, BorderLayout.CENTER );
+        }
+		
+		Component toolBar = initToolBar();
+        if ( toolBar != null )
+        {
+            navigationPanel.add( toolBar, BorderLayout.EAST );
+        }
+		
+	}
+    
+    /**
+    * Creates tool bar or return null if no tool bar is desired.
+    * This implementation returns a JToolBar containing buttons
+    * for BACK, UP, and HOME.
+    */ 
+    protected Component initToolBar()
+    {
+		JToolBar toolBar = new JToolBar();
+		toolBar.setFloatable( false );
+        JButton button;
+		button = new JButton( UIManager.getIcon("FileChooser.upFolderIcon") );
+        button.setActionCommand( UP );
+        button.addActionListener( this );
+        toolBar.add( button );
+		button = new JButton( UIManager.getIcon("FileChooser.homeFolderIcon") );
+        button.setActionCommand( HOME );
+        button.addActionListener( this );
+        toolBar.add( button );
+/*        
+		button = new JButton( UIManager.getIcon("FileChooser.newFolderIcon") );
+        button.setActionCommand( BACK );
+        button.addActionListener( this );
+        toolBar.add( button );
+*/        
+        return toolBar;
+    }
+    
+    /**
+    * Creates the component that is used to display a preview of the
+    * selected item(s) in the content area.  This component would listen
+    * to the selection model to update itself when the selected items change.
+    * Return null to omit this component.
+    * This implementation returns null.
+    */ 
+    protected Component initPreviewPane()
+    {
+        return null;
+    }
+    
+    /**
+    * Creates the JComboBox that is used to render the path leading to
+    * the displayed contents.  Return null to omit this combo box.
+    * This implementation returns a stock JComboBox that uses this
+    * class as its cell renderer.
+    */ 
+    protected JComboBox initComboBox()
+    {
+        JComboBox comboBox = new JComboBox();
+        comboBox.setRenderer( this );
+        return comboBox;
+    }
+    
+    /**
+    * Creates the JList that is used to render the path leading to
+    * the displayed contents.  This method may not return null.
+    * This implementation returns a stock JList that uses this
+    * class as its cell renderer and fires a SELECT action event
+    * on double click.
+    */ 
+    protected JList initList()
+    {
+        JList list = new JList();
+        list.setCellRenderer( this );
+        list.addMouseListener( new MouseAdapter() 
+        {
+            public void mouseClicked( MouseEvent evt )
+            {
+                if ( evt.getClickCount() > 1 )
+                {   
+                    actionPerformed( new ActionEvent( this, 0, SELECT ) );
+                }
+            }
+        });
+        return list;
+    }
+    
+    /**
+    * Begins listening to the specified tree model 
+    * and tree selection model.
+    */
+    protected void startListening()
+    {
+        model.addTreeModelListener( this );
+        selectionModel.addTreeSelectionListener( this );
+        contents.addListSelectionListener( this );
+    }
+    
+    /**
+    * Stops listening to the specified tree model 
+    * and tree selection model.
+    */
+    protected void stopListening()
+    {
+        model.removeTreeModelListener( this );
+        selectionModel.removeTreeSelectionListener( this );
+        contents.removeListSelectionListener( this );
+    }
+    
+    /**
+    * Returns the TreeModel used by the TreeChooser.
+    */ 
+    public TreeModel getModel()
+    {
+        return model;
+    }
+    
+    /**
+    * Sets the TreeModel used by the TreeChooser.
+    */ 
+    public void setModel( TreeModel aTreeModel )
+    {
+        stopListening();
+        model = aTreeModel;
+        bogusJTree.setModel( aTreeModel );
+        pathStack.removeAllElements();
+        startListening();
+        displayHome();
+    }
+    
+    /**
+    * Returns the TreeSelectionModel used by the TreeChooser.
+    */ 
+    public TreeSelectionModel getSelectionModel()
+    {
+        return selectionModel;
+    }
+    
+    /**
+    * Sets the TreeSelectionModel used by the TreeChooser.
+    */ 
+    public void setSelectionModel( TreeSelectionModel aSelectionModel )
+    {
+        selectionModel = aSelectionModel;
+        if ( aSelectionModel.getSelectionMode() == 
+            TreeSelectionModel.SINGLE_TREE_SELECTION )
+        {
+            contents.getSelectionModel().setSelectionMode( 
+                ListSelectionModel.SINGLE_SELECTION );
+        }
+        else
+        {
+            contents.getSelectionModel().setSelectionMode( 
+                ListSelectionModel.MULTIPLE_INTERVAL_SELECTION );
+        }
+        updateSelection();
+    }
+    
+    /**
+    * Returns the TreeCellRenderer used by the TreeChooser.
+    */ 
+    public TreeCellRenderer getRenderer()
+    {
+        return renderer;
+    }
+    
+    /**
+    * Sets the TreeCellRenderer used by the TreeChooser.
+    */ 
+    public void setRenderer( TreeCellRenderer aRenderer )
+    {
+        renderer = aRenderer;
+        updateContents();
+    }
+	
+    /**
+    * Displays the "home" directory.
+    * This implementation displays the root node's children.
+    */
+    public void displayHome()
+    {
+        setDisplayPath( null );        
+    }
+    
+    /**
+    * Displays the parent path of the currently displayed path.
+    */
+    public void displayParent()
+    {
+        setDisplayPath( displayPath.getParentPath() );    
+    }
+    
+    /**
+    * Displays the last displayed path before the current one,
+    * emulating the behavior of a "back" button.
+    */
+    public void displayPrevious()
+    {
+        if ( pathStack.empty() )
+        {
+            displayHome();   
+        }
+        else
+        {
+            setDisplayPathDirect( (TreePath) pathStack.pop() );
+            updateContents();
+        }
+    }
+    
+    /**
+    * Pushes the previous item onto the stack, sets
+    * the display path, and then updates the contents.
+    * If aPath is null, the root node's children are displayed.
+    */
+    public void setDisplayPath( TreePath aPath )
+    {
+        if ( aPath == null )
+        {
+            aPath = new TreePath( getModel().getRoot() );
+        }
+        if ( ! displayPath.equals ( aPath ) )
+        {
+            pathStack.push( displayPath );
+            setDisplayPathDirect( aPath );
+        }
+        updateContents();
+    }
+    
+    /**
+    * Sets the displayPath field and does not
+    * update the stack nor update the contents.
+    */
+    protected void setDisplayPathDirect( TreePath aPath )
+    {
+        displayPath = aPath;   
+    }
+    
+    /**
+    * Gets the currently displayed path.
+    */
+    public TreePath getDisplayPath()
+    {
+        return displayPath;   
+    }
+
+    /**
+    * Called when selected path changes or when model indicates
+    * that the displayed path has changed.
+    */
+    protected void updateContents()
+    {
+        stopListening();
+
+        // update combo box        
+        comboBoxModel.fireContentsChanged();
+        
+        // update list contents
+        Object displayedObject = displayPath.getLastPathComponent();
+/*
+//FIXME: this display group doesn't seem to be getting the sort orderings from parent        
+if ( displayedObject instanceof net.wotonomy.ui.EODisplayGroup )        
+System.out.println( ((net.wotonomy.ui.EODisplayGroup)displayedObject).displayedObjects() );            
+*/
+        int count = model.getChildCount( displayedObject );
+        Object[] children = new Object[ count ];
+        for ( int i = 0; i < count; i++ )
+        {
+            children[i] = model.getChild( displayedObject, i );
+        }
+        contents.setListData( children );
+        
+        startListening();
+
+        // synchronize the selection        
+        updateSelection();
+    }
+    
+    /**
+    * Updates the selection in the list to reflect the
+    * selection in the tree selection model.
+    */
+    public void updateSelection()
+    {
+        int index;
+        Object last = displayPath.getLastPathComponent();
+        TreePath[] selectionPaths = selectionModel.getSelectionPaths();
+        if ( selectionPaths != null )
+        {
+            List selectedIndices = new LinkedList();
+            for ( int i = 0; i < selectionPaths.length; i++ )
+            {
+                if ( displayPath.equals( selectionPaths[i].getParentPath() ) )
+                {
+                    index = getModel().getIndexOfChild( 
+                        last, selectionPaths[i].getLastPathComponent() );
+                    if ( index != -1 ) 
+                    {
+                        selectedIndices.add( new Integer( index ) );
+                    }
+                    else // should never happen
+                    {
+                        throw new WotonomyException( 
+                            "Could not find child of displayed node." );
+                    }
+                }
+            }
+            int[] selected = new int[ selectedIndices.size() ];
+            for ( int i = 0; i < selected.length; i++ )
+            {
+                selected[i] = ((Integer)selectedIndices.get(i)).intValue();   
+            }
+            stopListening();
+            contents.setSelectedIndices( selected );
+            startListening();
+        }
+    }
+    
+    // interface TreeModelListener
+    
+    public void treeNodesChanged( TreeModelEvent evt )
+    { 
+/*            
+        if ( displayPath.getLastPathComponent().toString().equals( 
+            evt.getTreePath().getLastPathComponent().toString() ) )
+        {
+System.out.println( "TreeChooser.treeNodesChanged: " + count++ );  
+*/
+            updateContents();
+/*            
+        }
+        else
+        {
+            System.out.println( evt.getTreePath() + " != " + displayPath );
+        }
+*/        
+    }
+    
+    public void treeNodesInserted( TreeModelEvent evt )
+    { 
+//            updateContents();
+    }
+    
+    public void treeNodesRemoved( TreeModelEvent evt )
+    { 
+//            updateContents();
+    }
+    
+    public void treeStructureChanged( TreeModelEvent evt )
+    {  
+        if ( ( evt.getTreePath().equals( displayPath ) )
+        || ( evt.getTreePath().isDescendant( displayPath ) ) )
+        {
+//            setDisplayPath( evt.getTreePath() );
+        }
+        
+        displayHome();
+    }
+    
+    // interface TreeSelectionListener
+    
+    /**
+    * Called when the tree selection model's value changes.
+    * This is presumably an external change, so this calls
+    * updateSelection.
+    */
+    public void valueChanged( TreeSelectionEvent evt )
+    {
+        updateSelection();   
+    }
+
+    // interface ListSelectionListener
+    
+    /**
+    * Called when user changes the selection in the list.
+    * This implementation updates the tree selection model
+    * with the corresponding selection.
+    */
+    public void valueChanged( ListSelectionEvent evt )
+    {
+        if ( ! evt.getValueIsAdjusting() )
+        {
+            Object last = displayPath.getLastPathComponent();
+            int[] selection = contents.getSelectedIndices();
+            TreePath[] selectionPaths = new TreePath[ selection.length ];
+            for ( int i = 0; i < selection.length; i++ )
+            {
+                selectionPaths[i] = displayPath.pathByAddingChild(
+                    getModel().getChild( last, selection[i] ) );
+            }
+            selectionModel.setSelectionPaths( selectionPaths );
+        }
+              
+    }
+    
+    // interface ListCellRenderer
+
+    /**
+    * This method returns the component returned by the tree cell renderer.
+    */
+    public Component getListCellRendererComponent(
+        JList list,
+        Object value,
+        int index,
+        boolean isSelected,
+        boolean cellHasFocus )
+    {
+        boolean isLeaf = ( model.isLeaf( value ) );
+        
+        bogusJTree.setForeground( list.getForeground() );
+        bogusJTree.setBackground( list.getBackground() );
+        
+        JComponent result = (JComponent) renderer.getTreeCellRendererComponent(
+            bogusJTree, value, isSelected, (list != contents), 
+                isLeaf, index, cellHasFocus );
+/*
+        if ( ( list != contents ) && ( index > -1 ) )
+        {
+            result.setBorder( 
+                BorderFactory.createEmptyBorder( 0, index*pathIndent, 0, 0 ) );
+        }
+        else
+        {
+            result.setBorder( 
+                BorderFactory.createEmptyBorder() );
+        }
+*/        
+        return result;
+    }
+    
+    // interface ActionListener
+	
+    public void actionPerformed( ActionEvent evt )
+    {
+        String command = evt.getActionCommand();
+        
+        if ( HOME.equals( command ) )
+        {
+            displayHome();
+        }
+        else
+        if ( UP.equals( command ) )
+        {
+            displayParent();
+        }
+        else
+        if ( BACK.equals( command ) )
+        {
+            displayPrevious();
+        }
+        else
+        if ( SELECT.equals( command ) )
+        {
+            Cursor oldCursor = getCursor();
+            setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR ) );
+            
+            int index = contents.getSelectedIndex();
+            // if selection 
+            if ( index != -1 )
+            {
+                Object parent = displayPath.getLastPathComponent();
+                Object child = getModel().getChild( parent, index );
+                // if selected item is not a leaf
+                if ( getModel().getChildCount( child ) > 0 )
+                {
+                    // navigate to selected item
+                    setDisplayPath( displayPath.pathByAddingChild( child ) );
+                }
+            }
+            
+            setCursor( oldCursor );
+        }
+    
+    }
+    
+    private class ChooserComboBoxModel implements ComboBoxModel
+    {
+        TreeChooser treeChooser;
+        Vector listeners;
+        
+        ChooserComboBoxModel( TreeChooser aTreeChooser )
+        {
+            treeChooser = aTreeChooser; 
+            listeners = new Vector();
+        }
+        
+        public int getSize()
+        {
+            return treeChooser.displayPath.getPathCount(); 
+        }
+        
+        public Object getElementAt(int index)
+        {
+            return treeChooser.displayPath.getPathComponent( index );    
+        }
+        
+        public Object getSelectedItem()
+        {
+            return treeChooser.displayPath.getLastPathComponent();
+        }
+        
+        public void setSelectedItem(Object anItem)
+        {
+            if ( ! ( 
+                treeChooser.displayPath.getLastPathComponent().equals( anItem ) ) )
+            {
+                Object[] items = treeChooser.displayPath.getPath();
+                TreePath path = new TreePath( getModel().getRoot() );
+                for ( int i = 1; i < items.length; i++ )
+                {
+                    if ( path.getLastPathComponent() == anItem )
+                    {
+                        treeChooser.setDisplayPath( path );
+                        return;
+                    }
+                    path = path.pathByAddingChild( items[i] );
+                }
+            }
+        }
+        
+        public void addListDataListener(ListDataListener l) 
+        {
+            listeners.add( l );
+        }
+        
+        public void removeListDataListener(ListDataListener l) 
+        {
+            listeners.remove( l );
+        }
+        
+        public void fireContentsChanged()
+        {
+            Enumeration e = listeners.elements();
+            while ( e.hasMoreElements() )
+            {
+                ((ListDataListener)e.nextElement()).contentsChanged( 
+                    new ListDataEvent( 
+                    this, ListDataEvent.CONTENTS_CHANGED, 0, getSize() ) );
+            }
+        }   
+    }
+    
+}
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TreeTableCellRenderer.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TreeTableCellRenderer.java
new file mode 100644
index 0000000..fbf3791
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/TreeTableCellRenderer.java
@@ -0,0 +1,224 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2002 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing.components;
+
+import java.awt.Component;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JTable;
+import javax.swing.JTree;
+import javax.swing.JViewport;
+import javax.swing.table.TableCellRenderer;
+
+/**
+* A TableCellRenderer that paints a portion of a JTree. 
+* Extends JViewport to take advantage of buffering and
+* fast blitting (avoids repeated clipping and repainting).
+* Defaults opaque to false: to see selection background 
+* painted, call setOpaque( true ).
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class TreeTableCellRenderer extends JViewport implements TableCellRenderer, MouseListener {
+
+    JTree tree;
+    Component emptyComponent;
+    JTable delegateTable;
+    int lastKnownColumn;
+
+    /**
+    * Constructor takes a JTree and modifies it by setting 
+    * rootVisible to false, showsRootHandles to true,
+    * opaque to false, and border to null.
+    */
+    public TreeTableCellRenderer( JTree aTree )
+    {
+        setView( aTree );
+        setBorder( null );
+        tree = aTree;
+        tree.setRootVisible( false );
+        tree.setShowsRootHandles( true );
+        tree.setBorder( null );
+        tree.setOpaque( false );
+        
+        Object renderer = tree.getCellRenderer();
+        if ( renderer instanceof JComponent )
+        {
+            ((JComponent)renderer).setOpaque( false );
+        }
+        Object editor = tree.getCellEditor();
+        if ( editor instanceof JComponent )
+        {
+            ((JComponent)editor).setOpaque( false );
+        }
+        
+        this.setOpaque( false );
+        emptyComponent = new JLabel();
+    }
+
+    public Component getTableCellRendererComponent(
+                            JTable table, Object value,
+                            boolean isSelected, boolean hasFocus,
+                            int row, int column)
+    {
+        if ( isSelected )
+        {
+            setForeground( table.getSelectionForeground() );
+            setBackground( table.getSelectionBackground() );
+        }
+        else
+        {
+            setForeground( table.getForeground() );
+            setBackground( table.getBackground() );
+        }
+
+        lastKnownColumn = column;
+        if ( delegateTable != table )
+        {
+            if ( delegateTable != null )
+            {
+                delegateTable.removeMouseListener( this );
+            }
+            table.addMouseListener( this );
+            delegateTable = table;
+        }
+        
+        Rectangle rect = tree.getRowBounds( row );
+        if ( rect != null ) 
+        {
+            setViewPosition( new Point( 0 /*rect.x*/, rect.y ) );
+            
+            //FIXME: this causes problems for some LAFs (like Metal):
+            // in particular, the table height seems to get stuck.
+            //if ( table.getRowHeight( row ) != rect.height )
+            //{
+            //    table.setRowHeight( row, rect.height );
+            //}
+            return this;
+        }
+        else
+        {
+            return emptyComponent;
+        }
+    }
+    
+    public void mouseClicked(MouseEvent e)
+    {
+        delegateToTree( e );
+    }
+
+    public void mousePressed(MouseEvent e)
+    {
+        delegateToTree( e );
+    }
+
+    public void mouseReleased(MouseEvent e)
+    {
+        delegateToTree( e );
+    }
+
+    public void mouseEntered(MouseEvent e)
+    {
+        delegateToTree( e );
+    }
+
+    public void mouseExited(MouseEvent e)
+    {
+        delegateToTree( e );
+    }
+
+    protected void delegateToTree(MouseEvent e)
+    {
+        int col = delegateTable.getColumnModel().getColumnIndexAtX( e.getX() );
+        if ( col == lastKnownColumn )
+        {
+            Rectangle nodeRect = tree.getRowBounds( 0 );
+            Rectangle cellRect = delegateTable.getCellRect( -1, col, false );
+            if ( nodeRect != null )
+            {
+                e.translatePoint( -cellRect.x, nodeRect.y );
+                tree.dispatchEvent( // e );
+                    new MouseEvent( tree, e.getID(), e.getWhen(), e.getModifiers(), 
+                        e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger() ) );
+            }
+        }
+    }
+
+    public void repaint()
+    {
+        //if ( delegateTable != null ) delegateTable.repaint();
+
+        // not calling super.repaint() does not seem to cause 
+        //   any problems so we're not doing it.
+    }
+
+}
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:19:05  cgruber
+ * Update imports and maven dependencies.
+ *
+ * Revision 1.1  2006/02/16 13:22:22  cgruber
+ * Check in all sources in eclipse-friendly maven-enabled packages.
+ *
+ * Revision 1.11  2003/08/06 23:07:53  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.10  2002/04/12 20:07:35  mpowers
+ * Fixed cool/annoying view position.
+ *
+ * Revision 1.9  2002/04/09 18:12:21  mpowers
+ * Fixes for 1.4.
+ *
+ * Revision 1.8  2002/03/22 22:39:24  mpowers
+ * Can now move column to any position in the table.
+ *
+ * Revision 1.7  2002/03/11 03:13:22  mpowers
+ * Adjusting for viewport position; no longer responding to repaint().
+ *
+ * Revision 1.6  2002/03/07 23:04:36  mpowers
+ * Refining TreeColumnAssociation.
+ *
+ * Revision 1.5  2002/03/05 23:18:28  mpowers
+ * Added documentation.
+ * Added isSelectionPaintedImmediate and isSelectionTracking attributes
+ * to TableAssociation.
+ * Added getTableAssociation to TableColumnAssociation.
+ *
+ * Revision 1.3  2002/02/27 23:19:17  mpowers
+ * Refactoring of TreeAssociation to create TreeModelAssociation parent.
+ *
+ * Revision 1.2  2002/02/18 23:13:55  mpowers
+ * Only setting row height when needed.
+ *
+ * Revision 1.1  2002/02/18 03:46:08  mpowers
+ * Implemented TreeTableCellRenderer.
+ *
+ *
+ */
+
+
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/package.html b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/package.html
new file mode 100644
index 0000000..618651b
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/components/package.html
@@ -0,0 +1,26 @@
+<body>
+<p>
+Contains various and useful Swing components.
+These can be used in conjunction with
+the ui framework, however, there are no 
+dependencies and all of these components can be used
+independently of the rest of the framework.  
+</p>
+<p>
+Of note are the ButtonPanel classes, which 
+automate the placement and layout of buttons
+in a manner consistent with the Java Look and Feel
+guidelines.  This uses the BetterFlowLayout which
+is another useful class.
+</p>
+<p>
+Also of note is the InfoPanel, which automates 
+the placement and layout of labeled fields on
+a panel.
+</p>
+<p>
+And the
+various cell renderer and editor components can 
+be useful as well.
+</p>
+</body>