Source code: echopoint/WizardPane.java

   package echopoint;
   
   /* 
    * This file is part of the Echo Point Project.  This project is a collection
    * of Components that have extended the Echo Web Application Framework.
    *
    * EchoPoint 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 of the License, or
   * (at your option) any later version.
   *
   * EchoPoint 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 Echo Point; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  import java.io.Serializable;
  
  import nextapp.echo.Button;
  import nextapp.echo.Color;
  import nextapp.echo.Component;
  import nextapp.echo.Container;
  import nextapp.echo.EchoConstants;
  import nextapp.echo.Insets;
  import nextapp.echo.Style;
  import nextapp.echo.event.ActionEvent;
  import nextapp.echo.event.ActionListener;
  import nextapp.echo.event.ChangeListener;
  import echopoint.model.DefaultSingleSelectionModel;
  import echopoint.model.SingleSelectionModel;
  import echopoint.positionable.Scrollable;
  import echopoint.stylesheet.StyleAttrDescriptor;
  import echopoint.stylesheet.StyleInfo;
  import echopoint.wizard.WizardNavigationEvent;
  import echopoint.wizard.WizardNavigationListener;
  import echopoint.wizard.WizardNavigationVetoException;
  
  /**
   * The <code>WizardPane</code> class provides a component to the Echo Web Framework that
   * allows the user to navigate through a series of logical steps.
   * <p>
   * Any Component object can be used as the interior of a given pane, however in 
   * general you would use a Panel object as the contents, and then fill that
   * Panel with other components.
   * <p>
   * The <code>WizardPane</code> uses a <code>SingleSelectionModel</code> to represent the set of tab 
   * indices and the currently selected index. 
   * <p>
   * If the count is greater than 0, then there will always be a selected index, 
   * which by default will be initialized to the first component. If the count is 0,
   * then the selected index will be -1.
   * <p>
   * <code>WizardPane</code> has an optimisation in place that means that only the
   * currently selected component is given a rendering peer.  This ensures that the
   * smallest amount of memory is sxued to render the contents.  
   * <p>
   * The <code>WizardPane</code> will call any <code>WizardNavigationListener's</code> 
   * that are registered when the user wants to navigate to another component.
   * <p>
   * If any listeners are provided, then they can throw a <code>WizardNavigationVetoException</code> 
   * to stop the user from navigating way from the current pane.  You might do this to implement
   * validation of the pane.
   * <p>
   * The WizardPane stores the selected index before invoking the WizardNavigationListener
   * interface.  If, after completion of the call, the model's selected index is different
   * to the saved index, the selected index will not be decremented or incremented.  This allows
   * you to "jump" the WizardPane to a specific index via the WizardNavigationListener processing.
   * <p>
   * The WizardPane can contain a <code>TitleBar</code> object as its title and footer.  
   * Every time the pane changes, the text of the title and footer will change.
   * <p>
   * The width and height of the <code>WizardPane</code> can be set.  This sets the dimensions
   * of the interior of the contents area.  If the width is not set, ie it is set to Integer.MAX_VALUE or
   * Integer.MIN_VALUE, then the <code>WizardPane</code> will fill its containing component.  
   * <p>
   * Scrollbars can also be used within the <code>WizardPane</code>.
   * <p>
   * @see echopoint.positionable.Scrollable for more information.
   *
   * @author Brad Baker 
   */
  
  public class WizardPane extends EchoPointComponent implements ActionListener, Scrollable {
  
    /** 
     * Nested public static StyleInfo class.  For more info:
     * @see echopoint.stylesheet.StyleInfo 
     */
    public static class NestedStyleInfo implements StyleInfo {
      private static StyleAttrDescriptor[] styleDescriptors = { 
        new StyleAttrDescriptor(STYLE_BORDER_COLOR,Color.class,"borderColor"),
        new StyleAttrDescriptor(STYLE_BORDER_SIZE,Integer.class,"borderSize"),
        new StyleAttrDescriptor(STYLE_INSETS,Insets.class,"insets"),
        new StyleAttrDescriptor(STYLE_FINISH_ONLY_ON_LAST,Boolean.class,"finishButtonOnLastOnly"),
     };
     /**
      * @see echopoint.stylesheet.StyleInfo#getStyleDescriptors()
      */
     public StyleAttrDescriptor[] getStyleDescriptors() {
       return styleDescriptors;
     }
   }
 
   private class WizardEntry implements Serializable {
     Component component;
     String footer;
     String title;
   }
   public static final String BORDER_COLOR_CHANGED_PROPERTY = "borderColor";
   public static final String BORDER_SIZE_CHANGED_PROPERTY = "borderSize";
   public static final String BUTTONS_CHANGED_PROPERTY = "buttons";
   public static final String COMPONENT_CHANGED_PROPERTY = "component";
 
   //
   // defaults colors and insets
   //
   public static final Insets DEFAULT_INSETS = new Insets(0);
 
   public static final String ENTRY_CHANGED_PROPERTY = "entry";
   public static final String FINISH_LAST_ONLY_CHANGED_PROPERTY = "finishLastOnly";
   public static final String FOOTER_CHANGED_PROPERTY = "footer";
   public static final String FOOTERBAR_CHANGED_PROPERTY = "footerBar";
   public static final String HEIGHT_CHANGED_PROPERTY = "height";
 
   public static final String INSETS_CHANGED_PROPERTY = "insets";
   public static final String MODEL_CHANGED_PROPERTY = "model";
 
   public static final String PLACEMENT_CHANGED_PROPERTY = "placement";
 
   public static final String RENDERING_CHANGED_PROPERTY = "rendering";
   /**
     * This property name is fired when the scolling bar X value changes
     */
   public static final String SCROLL_BAR_X_CHANGED_PROPERTY = "scrollbarX";
   /**
     * This property name is fired when the scolling bar Y value changes
     */
   public static final String SCROLL_BAR_Y_CHANGED_PROPERTY = "scrollbarX";
 
   public static final String SCROLLBAR_POLICY_CHANGED_PROPERTY = "scrollbarsPolicy";
 
   /* Property Change Names */
   public static final String SELECTED_INDEX_CHANGED_PROPERTY = "selindex";
 
   /** 
    * A style constant for the Border Color property. 
    * Values of this key must be of type <code>nextapp.echo.Color.</code>
    */
   public static final String STYLE_BORDER_COLOR = "borderColor";
   /** 
    * A style constant for the Border Size property. 
    * Values of this key must be of type <code>Integer.</code>
    */
   public static final String STYLE_BORDER_SIZE = "borderSize";
 
   /** 
    * A style constant for the FinishOnlyOnLast property. 
    * Values of this key must be of type <code>boolean </code>
    */
   public static final String STYLE_FINISH_ONLY_ON_LAST = "finishButtonOnLastOnly";
   /** 
    * A style constant for the Insets property. 
    * Values of this key must be of type <code>nextapp.echo.Insets.</code>
    */
   public static final String STYLE_INSETS = "insets";
 
   public static final String TITLE_CHANGED_PROPERTY = "title";
   public static final String TITLEBAR_CHANGED_PROPERTY = "titleBar";
   public static final String WIDTH_CHANGED_PROPERTY = "width";
 
   //
   // we always have a border for tabs
   private  Color borderColor = Color.BLACK;
   private  int borderSize = 1;
 
   private  boolean finishButtonOnLastOnly = false;
   private  TitleBar footerBar;
   private  Insets insets = DEFAULT_INSETS;
   //
   // our width and height
   private  int width = Integer.MAX_VALUE;
   private  int scrollBarX = 0;
   private  int scrollBarY = 0;
   private  int height = Integer.MAX_VALUE;
   //
   // the invisible component container
   private DevNull invisibleContainer;
   // 
   // the visible component container
   private Container visibleContainer;
   
   //
   // our selection model
   private  SingleSelectionModel model = null;
   
   //
   // the buttons
   private  Button nextButton;
   private  Button prevButton;
   private  Button cancelButton;
   private  Button finishButton;
 
   //
   // contain where the buttons are placed
   private  int placement = EchoConstants.BOTTOM;
   private  int scrollBarPolicy = SCROLLBARS_NEVER;
   //
   // our title and footer
   private  TitleBar titleBar;
   //
   // contains our list of components
   private  java.util.ArrayList wizardList = new java.util.ArrayList();
 
   /**
    * Constructs a WizardPane with the button placement as <code>EchoConstants.BOTTOM</code>
    */
   public WizardPane() {
     this(EchoConstants.BOTTOM);
   }
   /**
    * Constructs a new WizardPane
    * <br>
    * @param buttonPlacement  the button placement of the WizardPane,
    *        can be one of the following values.
    *        <ul>
    *        <li>EchoConstants.BOTTOM (the default)</li>
    *        <li>EchoConstants.TOP</li>
    *        </ul>
    */
   public WizardPane(int buttonPlacement) {
     super();
     setScrollBarPolicy(SCROLLBARS_NEVER);
     
     invisibleContainer = new DevNull();
     super.add(invisibleContainer,-1);
     
     visibleContainer = new Container();
     super.add(visibleContainer,-1);
     
     //
     // by default we dont have a cancel of finish button.  They must be added
     setNextButton(new Button("Next >"));
     setPreviousButton(new Button("< Previous"));
 
     //
     // we start with some default title bars
     setTitle(new TitleBar(null, TitleBar.TB_CLOSE));
     setFooter(new TitleBar(null));
 
     setModel(new DefaultSingleSelectionModel());
   }
   /**
    * Called when one of the buttons has been pressed and navigation 
    * should be done.  Each of the WizardNavigationListners will be called
    * to determine if navigation should take place.
    */
   public void actionPerformed(ActionEvent actionEvent) {
     int index = getSelectedIndex();
     if (index == -1)
       return; //?? how did they press anything
 
     int fromIndex = index;
     int toIndex = -1;
     try {
       if (actionEvent.getSource() == getNextButton()) {
         toIndex = Math.min(fromIndex + 1, wizardList.size());
         fireOnNavigation(WizardNavigationEvent.NEXT, getComponentAt(fromIndex), getComponentAt(toIndex), fromIndex, toIndex);
         checkAndSetSelectedIndex(fromIndex, toIndex);
         return;
       }
 
       if (actionEvent.getSource() == getPreviousButton()) {
         toIndex = Math.max(fromIndex - 1, 0);
         fireOnNavigation(WizardNavigationEvent.PREVIOUS, getComponentAt(fromIndex), getComponentAt(toIndex), fromIndex, toIndex);
         checkAndSetSelectedIndex(fromIndex, toIndex);
         return;
       }
 
       if (actionEvent.getSource() == getCancelButton() || (actionEvent.getSource() instanceof TitleBar && TitleBar.ACTION_CLOSE.equals(actionEvent.getActionCommand()))) {
 
         fireOnNavigation(WizardNavigationEvent.CANCEL, getComponentAt(fromIndex), getComponentAt(fromIndex), fromIndex, fromIndex);
         return;
       }
 
       if (actionEvent.getSource() == getFinishButton()) {
         fireOnNavigation(WizardNavigationEvent.FINISH, getComponentAt(fromIndex), getComponentAt(fromIndex), fromIndex, fromIndex);
         return;
       }
 
     } catch (WizardNavigationVetoException we) {
       //
       // they have veto'ed the navigation.  We should go back to where we started
       // however we need to be careful about this since they may have changed the
       // model underneath us.
       index = Math.min(fromIndex, wizardList.size());
       if (wizardList.size() == 0)
         setSelectedIndex(-1);
       else
         setSelectedIndex(index);
       return;
     }
   }
   /**
    * Adds a component to the <code>WizardPane</code>
    * <p>
    * Cover method for insert()
    *
    * @param component
    */
   public void add(Component component) {
     insert(null, null, component, wizardList.size());
   }
   /**
    * Adds a component to the <code>WizardPane</code> at the specified index
    * <p>
    * Cover method for insert()
    * <p>
    * @param component
    */
   public void add(Component component, int index) {
     insert(null, null, component, index);
   }
   /**
    * Adds a component to the <code>WizardPane</code>
    *
    */
   public void add(String title, Component component) {
     insert(title, null, component, wizardList.size());
   }
   /**
    * Adds a component to the <code>WizardPane</code>
    *
    */
   public void add(String title, String footer, Component component) {
     insert(title, footer, component, wizardList.size());
   }
   /**
    * Adds a <code>ChangeListener</code> to the WizardPane.
    *
    * @param l The <code>ChangeListener</code> to be added.
    */
   public void addChangeListener(ChangeListener l) {
     model.addChangeListener(l);
   }
   /**
    * Adds a <code>WizardNavigationListener</code> to the WizardPane.
    *
    * @param l The <code>ChangeListener</code> to be added.
    */
   public void addWizardNavigationListener(WizardNavigationListener l) {
     listenerList.addListener(WizardNavigationListener.class, l);
   }
   /**
    * Applies the provided style to the component.  The base <code>nextapp.echo.Component</code>
    * style names can be used as well.
    */
   public void applyStyle(Style style) {
     super.applyStyle(style);
 
     if (style.hasAttribute(STYLE_BORDER_COLOR)) {
       setBorderColor((Color) style.getAttribute(STYLE_BORDER_COLOR));
     }
     if (style.hasAttribute(STYLE_BORDER_SIZE)) {
       setBorderSize(style.getIntegerAttribute(STYLE_BORDER_SIZE));
     }
     if (style.hasAttribute(STYLE_INSETS)) {
       setInsets((Insets) style.getAttribute(STYLE_INSETS));
     }
     if (style.hasAttribute(STYLE_FINISH_ONLY_ON_LAST)) {
       setFinishButtonOnLastOnly(style.getBooleanAttribute(STYLE_FINISH_ONLY_ON_LAST));
     }
 
     if (style.hasAttribute(STYLE_SCROLL_BAR_POLICY))
       setScrollBarPolicy(style.getIntegerAttribute(STYLE_SCROLL_BAR_POLICY));
 
     if (style.hasAttribute(STYLE_HEIGHT))
       setHeight(style.getIntegerAttribute(STYLE_HEIGHT));
 
     if (style.hasAttribute(STYLE_WIDTH))
       setWidth(style.getIntegerAttribute(STYLE_WIDTH));
 
   }
   /**
    * This method will check that the currently selected index of the
    * the WizardPane is still the same as a saved value.  If not then it 
    * will NOT set the selected index.
    *
    * This is used during the WizardNavigationListener events to allow the listener
    * a chance to set the selected index during the event processing, reagrdless of what 
    * is logically next.  we * dont want to blat that away by blindly 
    * settting it to index+1 or index -1
    */
   private void checkAndSetSelectedIndex(int savedSelectedIndex, int toIndex) {
     int currentIndex = getSelectedIndex();
     if (currentIndex == savedSelectedIndex) {
       setSelectedIndex(toIndex);
     }
   }
   /**
    * Called to notify all WizardNavigationListener's of a navigation event.
    */
   private void fireOnNavigation(int type, Component fromComponent, Component toComponent, int fromIndex, int toIndex) throws WizardNavigationVetoException {
     Object[] listeners = listenerList.getListeners(WizardNavigationListener.class);
     WizardNavigationEvent e = null;
 
     for (int index = 0; index < listeners.length; ++index) {
       if (e == null)
         e = new WizardNavigationEvent(this, type, fromComponent, toComponent, fromIndex, toIndex);
 
       ((WizardNavigationListener) listeners[index]).onNavigation(e);
     }
   }
   /**
    * @return The <code>Color</code> of the <code>WizardPane's</code> border.
    */
   public Color getBorderColor() {
     return borderColor;
   }
   /**
    * @return The size of the <code>WizardPane's</code> border.
    */
   public int getBorderSize() {
     return borderSize;
   }
   /**
    * Returns the button that acts as the "Cancel" button in the <code>WizardPane</code>.
    */
   public Button getCancelButton() {
     return cancelButton;
   }
   /**
    * @return The <code>Component</code> at the specified index.
    */
   public Component getComponentAt(int index) {
     WizardEntry te = getWizardEntryAt(index);
     return (te != null) ? te.component : null;
   }
   /**
    * Returns the number of entries within the <code>WizardPane</code>.
    */
   public int getCount() {
     return wizardList.size();
   }
   /**
    * Returns the button that acts as the "Finish" button in the <code>WizardPane</code>.
    */
   public Button getFinishButton() {
     return finishButton;
   }
   /**
    * @return The footer TitleBar of the <code>WizardPane</code>
    */
   public TitleBar getFooter() {
     return footerBar;
   }
   /**
    * @return The footer of the Component at the specified index.
    */
   public String getFooterAt(int index) {
     WizardEntry te = getWizardEntryAt(index);
     return (te != null) ? te.footer : null;
   }
   /**
    * Returns the height of the <code>WizardPane</code>.  If this value
    * is -1, then no height will be used.
    */
   public int getHeight() {
     return height;
   }
   /** 
   * Returns the insets (margins) of the tabbed pane contents.
   *
   * @return The insets of the tabbed pane.
   */
   public Insets getInsets() {
     return insets;
   }
   /**
    * Returns the model associated with this <code>WizardPane</code>.
    *
    */
   public SingleSelectionModel getModel() {
     return model;
   }
   /**
    * Returns the button that acts as the "Next" button in the <code>WizardPane</code>.
    */
   public Button getNextButton() {
     return nextButton;
   }
   /**
    * @return The placement of buttons wihtin the <code>WizardPane</code>
    *
    */
   public int getPlacement() {
     return placement;
   }
   /**
    * Returns the button that acts as the "Previous" button in the <code>WizardPane</code>.
    */
   public Button getPreviousButton() {
     return prevButton;
   }
   /**
    * Returns the ScrollBarPolicy in place
    * 
    * This can be one of :
    * <ul>
    * <li>SCOLLBARS_NONE</li>
    * <li>SCOLLBARS_ALWAYS</li>
    * <li>SCOLLBARS_AUTO</li>
    * </ul>
    */
   public int getScrollBarPolicy() {
     return scrollBarPolicy;
   }
   /**
    * Returns the position of the horizontal scroll bar, in pixels offset from 
    * the left of the component.
    *
    * @return The position of the horizontal scroll bar.
    */
   public int getScrollBarX() {
     return scrollBarX;
   }
   /**
    * Returns the position of the vertical scroll bar, in pixels offset from 
    * the top the component.
    *
    * @return The position of the vertical scroll bar.
    */
   public int getScrollBarY() {
     return scrollBarY;
   }
   /**
    * @return the <code>Component</code> at the currently selected index or null if
    * none is currently selected.
    */
   public Component getSelectedComponent() {
     int index = model.getSelectedIndex();
     if (index < 0)
       return null;
     return getComponentAt(index);
   }
   /**
    * Returns the currently selected index or -1 if none is selected
    */
   public int getSelectedIndex() {
     return model.getSelectedIndex();
   }
   /**
    * @return The title TitleBar of the <code>WizardPane</code>
    */
   public TitleBar getTitle() {
     return titleBar;
   }
   /**
    * @return The title of the Component at the specified index.
    */
   public String getTitleAt(int index) {
     WizardEntry te = getWizardEntryAt(index);
     return (te != null) ? te.title : null;
   }
   /**
    * Returns the width of the <code>WizardPane</code>.  If this value
    * is -1, then no width will be used.
    */
   public int getWidth() {
     return width;
   }
   /**
    * Returns the tab entry at a specified index.  Returns null if the
    * index is out of range.
    *
    */
   private WizardEntry getWizardEntryAt(int index) {
     if (index < 0 || index >= wizardList.size())
       return null;
 
     WizardEntry te = (WizardEntry) wizardList.get(index);
 
     return te;
   }
   /**
    * Returns the index of the given <code>Component</code> or -1 if it is not found
    */
   public int indexOfComponent(Component c) {
     for (int i = 0; i < wizardList.size(); i++) {
       WizardEntry te = getWizardEntryAt(i);
       if (te.component == c)
         return i;
     }
     return -1;
   }
   /**
    * Returns the index with the given title or -1 if it is not found
    */
   public int indexOfTitle(String title) {
     for (int i = 0; i < wizardList.size(); i++) {
       WizardEntry te = getWizardEntryAt(i);
       if (te != null && te.title.equals(title))
         return i;
     }
     return -1;
   }
   /**
    * Insert a Component at the specified index.  
    */
   public void insert(String title, Component component, int index) {
     insert(title, null, component, index);
   }
   /**
    * Insert a Component at the specified index.  
    */
   public void insert(String title, String footer, Component component, int index) {
 
     if (index < 0)
       index = 0;
 
     WizardEntry tc = new WizardEntry();
     tc.title = title;
     tc.footer = footer;
     tc.component = component;
 
     int newIndex = -1;
     if (index >= wizardList.size()) {
       wizardList.add(tc);
       newIndex = wizardList.size() - 1;
     } else {
       wizardList.add(index, tc);
       newIndex = index;
     }
 
     //
     // we always have a selected Index if we have some entries
     if (getSelectedIndex() == -1)
       setSelectedIndex(newIndex);
       
     reArrangeVisibleComponents(null);
     
     firePropertyChange(ENTRY_CHANGED_PROPERTY, null, component);
   }
   /**
    * This returns TRUE if the Finish button will be shown on the last wizard page only.  
    * If this is FALSE, then the Finsih button will show on all wizard pages.  
    * 
    * @return boolean
    */
   public boolean isFinishButtonOnLastOnly() {
     return finishButtonOnLastOnly;
   }
   
   /**
    * Called to rearrange the components inside the WizardPane
    * It moves the currently selected component into the visible
    * container and the rest into the invisible bucket.  This 
    * ensures that they get no rendering peers and hence
    * this is more efficient. 
    * 
    * @param removedComponent - an optinal component that has been removed
    */
   private void reArrangeVisibleComponents(Component removedComponent) {
     
     Component selectedC = getSelectedComponent();
     for (int i = 0; i < getCount(); i++) {
       Component c = getComponentAt(i);
       if (c == selectedC) {
         if (! visibleContainer.isAncestorOf(c))
           visibleContainer.add(c);
       } else {
         if (! invisibleContainer.isAncestorOf(c))
           invisibleContainer.add(c);
       }
     }
     if (visibleContainer.isAncestorOf(removedComponent))
       visibleContainer.remove(removedComponent);
     else if (invisibleContainer.isAncestorOf(removedComponent))
       invisibleContainer.remove(removedComponent);
   }
   /**
    * Removes a entry from the <code>WizardPane</code> at represented by the Component c
    */
   public void remove(Component c) {
     for (int i = getCount() - 1; i >= 0; i--) {
       WizardEntry te = getWizardEntryAt(i);
       if (te == null)
         continue;
 
       if (te.component == c) {
         removeComponentAt(i);
       }
 
     }
   }
   
   /**
    * Removes a Component entry from the <code>WizardPane</code> at the specified index.
    */
   public void remove(int index) {
     removeComponentAt(index);
   }
   /**
    * Removes all entries from the <code>WizardPane</code>.
    */
   public void removeAll() {
     for (int i = getCount() - 1; i >= 0; i--) {
       removeComponentAt(i);
     }
   }
   /**
    * Removes a ChangeListener from this component.
    *
    * @param l the ChangeListener to remove
    *
    */
   public void removeChangeListener(ChangeListener l) {
     model.removeChangeListener(l);
   }
   
   /**
    * Removes a Component entry from the <code>WizardPane</code> at the specified index.
    */
   public void removeComponentAt(int index) {
     WizardEntry te = getWizardEntryAt(index);
     if (te == null)
       return;
 
     wizardList.remove(index);
 
     int newIndex = index - 1;
     if (newIndex < 0)
       newIndex = 0;
 
     if (wizardList.size() == 0)
       newIndex = -1;
 
     setSelectedIndex(newIndex);
 
     reArrangeVisibleComponents(te.component);
     
     firePropertyChange(ENTRY_CHANGED_PROPERTY, null, te.component);
   }
   /**
    * Removes a <code>WizardNavigationListener</code> to the WizardPane.
    *
    * @param l The <code>ChangeListener</code> to be added.
    */
   public void removeWizardNavigationListener(WizardNavigationListener l) {
     listenerList.removeListener(WizardNavigationListener.class, l);
   }
   
   /**
    * Adds and removes a Component as a child of the WizardPane. 
    * 
    * @param oldValue - the old component to remove - can be null
    * @param newValue - the new component to add - can be null
    */
   protected void reRegisterComponents(Component oldValue, Component newValue) {
     if (oldValue != null && this.isAncestorOf(oldValue)) {
       super.remove(oldValue);
       if (oldValue instanceof TitleBar)
          ((TitleBar) oldValue).removeActionListener(this);
     }
 
     if (newValue != null && !this.isAncestorOf(newValue)) {
       super.add(newValue, -1);
       if (newValue instanceof TitleBar)
          ((TitleBar) newValue).addActionListener(this);
     }
   }  
   
   /**
    * Sets the border color of the <code>WizardPane</code>
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.BORDER_COLOR_CHANGED_PROPERTY</code>
    */
   public void setBorderColor(Color newValue) {
     Color oldValue = borderColor;
     borderColor = newValue;
     firePropertyChange(BORDER_COLOR_CHANGED_PROPERTY, oldValue, newValue);
   }
   /**
    * Sets the border size of the <code>WizardPane</code>
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.BORDER_SIZE_CHANGED_PROPERTY</code>
    *
    */
   public void setBorderSize(int newBorderSize) {
     int oldValue = borderSize;
     borderSize = newBorderSize;
     firePropertyChange(BORDER_SIZE_CHANGED_PROPERTY, oldValue, newBorderSize);
   }
   /**
    * Sets the button that acts as the "Cancel" button in the <code>WizardPane</code>
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.BUTTONS_CHANGED_PROPERTY</code>
    *
    */
   public void setCancelButton(Button newButton) {
     Button oldValue = cancelButton;
     cancelButton = newButton;
     reRegisterComponents(oldValue, newButton);
     if (cancelButton != null) {
       cancelButton.setActionCommand("finish");
       cancelButton.addActionListener(this);
     }
     firePropertyChange(BUTTONS_CHANGED_PROPERTY, oldValue, newButton);
   }
   /**
    * Sets the <code>Component</code> at the specified index
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.COMPONENT_CHANGED_PROPERTY</code>
    *
    */
   public void setComponentAt(int index, Component component) {
 
     WizardEntry te = getWizardEntryAt(index);
     if (te == null)
       return;
     Component oldValue = te.component;
     te.component = component;
     
     reArrangeVisibleComponents(null);
     
     firePropertyChange(COMPONENT_CHANGED_PROPERTY, oldValue, component);
   }
   
 
   /**
    * @see nextapp.echo.Component#setEnabled(boolean)
    */
   public void setEnabled(boolean newValue) {
     Component c = getCancelButton();
     if (c != null) c.setEnabled(newValue);
     c = getFinishButton();
     if (c != null) c.setEnabled(newValue);
     c = getNextButton();
     if (c != null) c.setEnabled(newValue);
     c = getPreviousButton();
     if (c != null) c.setEnabled(newValue);
     c = getTitle();
     if (c != null) c.setEnabled(newValue);
     c = getFooter();
     if (c != null) c.setEnabled(newValue);
   }
   /**
    * Sets the button that acts as the "Finish" button in the <code>WizardPane</code>
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.BUTTONS_CHANGED_PROPERTY</code>
    * 
    */
   public void setFinishButton(Button newButton) {
     Button oldValue = finishButton;
     finishButton = newButton;
     reRegisterComponents(oldValue, newButton);
     if (finishButton != null) {
       finishButton.setActionCommand("finish");
       finishButton.addActionListener(this);
     }
     firePropertyChange(BUTTONS_CHANGED_PROPERTY, oldValue, newButton);
   }
   /**
    * if this is set to TRUE, the Finish button will be shown on the last wizard page only.  
    * If this is FALSE, then the Finsih button will show on all wizard pages.  
    * 
    * @param newFinishButtonOnLastOnly boolean
    */
   public void setFinishButtonOnLastOnly(boolean newFinishButtonOnLastOnly) {
     boolean oldValue = finishButtonOnLastOnly;
     finishButtonOnLastOnly = newFinishButtonOnLastOnly;
     firePropertyChange(FINISH_LAST_ONLY_CHANGED_PROPERTY, oldValue, newFinishButtonOnLastOnly);
   }
   /**
    * Sets the footer TitleBar of the WizardPane.
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.FOOTERBAR_CHANGED_PROPERTY</code>
    *
    */
   public void setFooter(TitleBar newFooterBar) {
     TitleBar oldValue = footerBar;
     footerBar = newFooterBar;
     reRegisterComponents(oldValue, newFooterBar);
     firePropertyChange(FOOTERBAR_CHANGED_PROPERTY, oldValue, newFooterBar);
   }
   /**
    * Sets the footer at the specified index
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.FOOTER_CHANGED_PROPERTY</code>
    */
   public void setFooterAt(int index, String footerText) {
 
     WizardEntry te = getWizardEntryAt(index);
     if (te == null)
       return;
 
     String oldValue = te.footer;
     te.footer = footerText;
     firePropertyChange(FOOTER_CHANGED_PROPERTY, oldValue, footerText);
   }
   /**
    * Sets the height of the <code>WizardPane</code>.  If this
    * value is -1, then no height will be used.
    * <p>
    * Note that this is the height of the contents of the WizardPane
    * not the outside of the Wizard Pane.  This allows scrolling within
    * the contents of the wizard pane.
    * <p>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.HEIGHT_CHANGED_PROPERTY</code>
    *
    */
   public void setHeight(int newValue) {
     int oldValue = height;
 
     height = newValue;
 
     firePropertyChange(HEIGHT_CHANGED_PROPERTY, oldValue, newValue);
   }
   /**
   * Sets the insets (margins) of the <code>WizardPane</code>
   *
   * @param newValue An insets object that specifies the size of each margin 
   *        of this <code>WizardPane</code>
   */
   public void setInsets(Insets newValue) {
     Insets oldValue = insets;
     insets = newValue;
     firePropertyChange(INSETS_CHANGED_PROPERTY, oldValue, newValue);
   }
   /**
    * Sets the model to be used with this <code>WizardPane</code>
    *.
    */
   public void setModel(SingleSelectionModel model) {
     SingleSelectionModel oldModel = getModel();
     this.model = model;
     firePropertyChange(MODEL_CHANGED_PROPERTY, oldModel, model);
   }
   /**
    * Sets the button that acts as the "Next" button in the <code>WizardPane</code>
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.BUTTONS_CHANGED_PROPERTY</code>
    * 
    */
   public void setNextButton(Button newButton) {
     Button oldValue = nextButton;
     nextButton = newButton;
     reRegisterComponents(oldValue, newButton);
     if (nextButton != null) {
       nextButton.setActionCommand("finish");
       nextButton.addActionListener(this);
     }
     firePropertyChange(BUTTONS_CHANGED_PROPERTY, oldValue, newButton);
   }
   /** 
    * Sets the placement of buttons within the <code>WizardPane</code>
    * <br>
    * @param newPlacement the placement of the buttons 
    *        can be one of the following values.
    *        <ul>
    *        <li>EchoConstants.BOTTOM (the default)</li>
    *        <li>EchoConstants.TOP</li>
    *        </ul>
    */
   public void setPlacement(int newPlacement) {
     int oldValue = placement;
 
     placement = newPlacement;
 
     firePropertyChange(PLACEMENT_CHANGED_PROPERTY, oldValue, newPlacement);
   }
   /**
    * Sets the button that acts as the "Previous" button in the <code>WizardPane</code>
    * <br>
    * This methods fires a <code>PropertyChangeEvent</code> with a
    * <code>getPropertyName()</code> value of 
    * <code>WizardPane.BUTTONS_CHANGED_PROPERTY</code>
   * 
   */
  public void setPreviousButton(Button newButton) {
    Button oldValue = prevButton;
    prevButton = newButton;
    reRegisterComponents(oldValue, newButton);
    if (prevButton != null) {
      prevButton.setActionCommand("finish");
      prevButton.addActionListener(this);
    }
    firePropertyChange(BUTTONS_CHANGED_PROPERTY, oldValue, newButton);
  }
  /**
   * This sets the scroll bar policy to use.
   * 
   * This can be one of :
   * <ul>
   * <li>SCOLLBARS_NONE</li>
   * <li>SCOLLBARS_ALWAYS</li>
   * <li>SCOLLBARS_AUTO</li>
   * </ul>
   *
   */
  public void setScrollBarPolicy(int newScrollBarPolicy) {
    int oldValue = scrollBarPolicy;
    scrollBarPolicy = newScrollBarPolicy;
    firePropertyChange(SCROLLBAR_POLICY_CHANGED_PROPERTY, oldValue, newScrollBarPolicy);
  }
  /**
   * Sets the position of the horizontal scroll bar, in pixels offset from 
   * the left of the component.
   *
   * @param newValue The new position of the horizontal scroll bar, in pixels.
   */
  public void setScrollBarX(int newValue) {
    int oldValue = scrollBarX;
    scrollBarX = newValue;
    firePropertyChange(SCROLL_BAR_X_CHANGED_PROPERTY, oldValue, newValue);
  }
  /**
   * Sets the position of the vertical scroll bar, in pixels offset from 
   * the top of the component.
   *
   * @param newValue The new position of the vertical scroll bar, in pixels.
   */
  public void setScrollBarY(int newValue) {
    int oldValue = scrollBarY;
    scrollBarY = newValue;
    firePropertyChange(SCROLL_BAR_Y_CHANGED_PROPERTY, oldValue, newValue);
  }
  /**
   * Sets the selected tab of the <code>WizardPane</code>.
   */
  public void setSelectedIndex(int index) {
    model.setSelectedIndex(index);
    //
    // now we have to change the title and footer of for that pane
    if (getTitle() != null) {
      getTitle().setText(getTitleAt(index));
    }
    if (getFooter() != null) {
      getFooter().setText(getFooterAt(index));
    }
  }
  /**
   * Sets the title TitleBar of the WizardPane.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>WizardPane.TITLEBAR_CHANGED_PROPERTY</code>
   * 
   */
  public void setTitle(TitleBar newTitleBar) {
    TitleBar oldValue = titleBar;
    titleBar = newTitleBar;
    reRegisterComponents(oldValue, newTitleBar);
    firePropertyChange(TITLEBAR_CHANGED_PROPERTY, oldValue, newTitleBar);
  }
  /**
   * Sets the title at the specified index
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>WizardPane.TITLE_CHANGED_PROPERTY</code>
   * 
   */
  public void setTitleAt(int index, String title) {

    WizardEntry te = getWizardEntryAt(index);
    if (te == null)
      return;

    String oldValue = te.title;
    te.title = title;
    firePropertyChange(TITLE_CHANGED_PROPERTY, oldValue, te.title);
  }
  /**
   * Sets the width of the <code>WizardPane</code>.  If this
   * value is -1, then no width will be used.
   * <p>
   * Note that this is the height of the contents of the WizardPane
   * not the outside of the Wizard Pane.  This allows scrolling within
   * the contents of the wizard pane.
   * <p>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>WizardPane.WIDTH_CHANGED_PROPERTY</code>
   *
   */
  public void setWidth(int newValue) {
    int oldValue = width;
    width = newValue;
    firePropertyChange(WIDTH_CHANGED_PROPERTY, oldValue, newValue);
  }
  
  /**
   * @see nextapp.echo.Component#validate()
   */
  public void validate() {
    super.validate();
    //
    // make sure that the current selected pane component
    // is in our visible container and hence gets a rendering
    // peer.  Then put all the rest in the invisible
    // container so it gets no peer and hence its all
    // the more efficient.
    //
    reArrangeVisibleComponents(null);
  }

  
  /** @see echopoint.util.ReflectionSetter#set(Field, Object) */  
  public Object set(java.lang.reflect.Field field, Object newValue) throws Exception {
    Object oldValue = field.get(this); field.set(this,newValue); return oldValue;
  }
  

}