Source code: echopoint/TabbedPane.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 java.util.Iterator;
  import java.util.NoSuchElementException;
  import java.util.EventListener;
  
  import echopoint.tabbedpane.TabImageRenderer;
  
  import nextapp.echo.Color;
  import nextapp.echo.Component;
  import nextapp.echo.Container;
  import nextapp.echo.EchoConstants;
  import nextapp.echo.Font;
  import nextapp.echo.ImageReference;
  import nextapp.echo.Insets;
  import nextapp.echo.ResourceImageReference;
  import nextapp.echo.Style;
  import nextapp.echo.event.ActionEvent;
  import nextapp.echo.event.ActionListener;
  import nextapp.echo.event.ChangeListener;
  
  import echopoint.DevNull;
  import echopoint.EchoPointComponent;
  import echopoint.model.DefaultSingleSelectionModel;
  import echopoint.model.SingleSelectionModel;
  import echopoint.positionable.Scrollable;
  import echopoint.stylesheet.StyleAttrDescriptor;
  import echopoint.stylesheet.StyleInfo;
  import echopoint.stylesheet.SymbolicIntegerValue;
  import echopoint.stylesheet.SymbolicValue;
  import echopoint.ui.resource.ResourceNames;
  
  /**
   * The <code>TabbedPane</code> component provides tabbed panes to the Echo Web Framework.  
   * <p>
   * Any component object can be used as the interior of the tabbed pane, however in 
   * general you would use a Panel object as the content of a tab, and then fill that
   * Panel with other components.
   * <p>
   * The <code>TabbedPane</code> uses a <code>SingleSelectionModel</code> to represent the set of tab 
   * indices and the currently selected index. The <code>DefaultSingleSelectionModel</code> class only
   * raises and event if the currently selected index changes.  So to "trap" the user 
   * clicking on the same tab twice, derive your own <code>SingleSelectionModel</code> class.
   * <p>
   * If the tab count is greater than 0, then there will always be a selected index, 
   * which by default will be initialized to the first tab. If the tab count is 0, 
   * then the selected index will be -1.
   * <p>
   * An optional <code>TabImageRenderer</code> can be used to render "tab image representations".  
   * If a <code>TabImageRenderer</code> is in place, then the image returned will be used
   * as the tab representation, rather then the simple text based approach.  You will
   * typically not want tab borders or tab insets if you are using a <code>TabImageRenderer</code>. 
   * <p>
   * <code>TabbedPane</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 used to render the contents.  
   * <p>
   * The width and height of the <code>TabbedPane</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>TabbedPane</code> will fill its containing component.  
   * <p>
   * Scrollbars can also be used within the <code>TabbedPane</code>.
   * <p>
   * The TabbedPane can also have a close icon on each of the tabs.  If this
   * is pressed, then an ActionEvent is raised.  The DefaultCloseActionListener
   * will close the "tab" that raised the event.  To use the tab closing functionality
   * you will need to create a new DefaultCloseActionListener and attach it as
   * well as set a close image into the TabbedPane.
   * <p>
   * @see echopoint.positionable.Scrollable for more information.
   * @author Brad Baker 
   */
  
  public class TabbedPane extends EchoPointComponent implements Scrollable {
    
    /**
     * Class for default close action. The class implements an <code>ActionListener</code> that
     * removed the tabs from the <code>TabbedPane</code> after clicking on the tab closeIcon
     * 
    * It it possible for this class to invoke another <code>ActionListener</code> before
    * it removes the tabs from the <code>TabbedPane</code>
    */  
   public static class DefaultCloseActionListener implements ActionListener {
     private ActionListener m_beforeListener;
     
     /**
      * Constructs a DefaultCloseActionListener
      */
     public DefaultCloseActionListener() {
       this(null);
     }
 
     /**
      * Constructs a DefaultCloseActionListener with an <code>ActionListener</code> that is invoked 
      * before the tabs is removed from <code>TabbedPane</code>
      * 
      * @param before The <code>ActionListener</code> that is invoked before
      */
     public DefaultCloseActionListener(ActionListener before) {
       m_beforeListener = before;
     }
     
     /**
      * Invoked when an close action occurs.
      *
      * @param e The event describing the close action. The actionCommand holds the tab index
      */
     public void actionPerformed(ActionEvent e) {
       if(m_beforeListener != null)
         m_beforeListener.actionPerformed(e);
       
       int tabidx = Integer.parseInt(e.getActionCommand());
       TabbedPane src = (TabbedPane)e.getSource();
       src.remove(tabidx);      
     }    
   };
   
 
   /** 
    * 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 Icon Spacing property. 
    * Values of this key must be of type <code>Integer.</code>
    */
   public static final String STYLE_ICON_SPACING = "iconSpacing";
   /** 
    * 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";
 
   /** 
    * A style constant for the Tab Insets property. 
    * Values of this key must be of type <code>nextapp.echo.Insets.</code>
    */
   public static final String STYLE_TAB_INSETS = "tabInsets";
 
   /** 
    * A style constant for the RollOver Background property. 
    * Values of this key must be of type <code>nextapp.echo.Color.</code>
    */
   public static final String STYLE_ROLLOVER_BACKGROUND = "rollOverBackground";
   /** 
    * A style constant for the RollOver Foreground property. 
    * Values of this key must be of type <code>nextapp.echo.Color.</code>
    */
   public static final String STYLE_ROLLOVER_FOREGROUND = "rollOverForeground";
 
   /** 
    * A style constant for the Inactive Background property. 
    * Values of this key must be of type <code>nextapp.echo.Color.</code>
    */
   public static final String STYLE_INACTIVE_BACKGROUND = "inactiveBackground";
   /** 
    * A style constant for the Inactive Foreground property. 
    * Values of this key must be of type <code>nextapp.echo.Color.</code>
    */
   public static final String STYLE_INACTIVE_FOREGROUND = "inactiveForeground";
   /** 
    * A style constant for the Inactive RollOver Background property. 
    * Values of this key must be of type <code>nextapp.echo.Color.</code>
    */
   public static final String STYLE_INACTIVE_ROLLOVER_BACKGROUND = "inactiveRollOverBackground";
   /** 
    * A style constant for the Inactive RollOver Foreground property. 
    * Values of this key must be of type <code>nextapp.echo.Color.</code>
    */
   public static final String STYLE_INACTIVE_ROLLOVER_FOREGROUND = "inactiveRollOverForeground";
   /** 
    * A style constant for the Inactive Font property. 
    * Values of this key must be of type <code>nextapp.echo.Font.</code>
    */
   public static final String STYLE_INACTIVE_FONT = "inactiveFont";
   /** 
    * A style constant for the Inactive Font property. 
    * Values of this key must be of type <code>nextapp.echo.Font.</code>
    */
   public static final String STYLE_TAB_PLACEMENT = "tabPlacement";
 
   /** 
    * A style constant for the Close Image property. 
    * Values of this key must be of type <code>nextapp.ImageReference</code>
    */
   public static final String STYLE_CLOSE_IMAGE = "closeImage";
   /** 
    * A style constant for the Close ToolTip property. 
    * Values of this key must be of type <code>String</code>
    */
   public static final String STYLE_CLOSE_TOOLTIP = "closeToolTip";
 
   /**
    * Helper static SymbolicValue[] - tabPlacement - top and bottom  
    */
   public static SymbolicValue[] tabPlacementSymbolics  = {
     new SymbolicIntegerValue(EchoConstants.TOP,"top"),
     new SymbolicIntegerValue(EchoConstants.BOTTOM,"bottom"),
   };
 
   /** 
    * 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_ICON_SPACING,Integer.class,"iconSpacing"),
       new StyleAttrDescriptor(STYLE_INACTIVE_BACKGROUND,Color.class,"inactiveBackground"),
       new StyleAttrDescriptor(STYLE_INACTIVE_FONT,Font.class,"inactiveFont"),
       new StyleAttrDescriptor(STYLE_INACTIVE_FOREGROUND,Color.class,"inactiveForeground"),
       new StyleAttrDescriptor(STYLE_INACTIVE_ROLLOVER_BACKGROUND,Color.class,"inactiveRollOverBackground"),
       new StyleAttrDescriptor(STYLE_INACTIVE_ROLLOVER_FOREGROUND,Color.class,"inactiveRollOverForeground"),
       new StyleAttrDescriptor(STYLE_INSETS,Insets.class,"insets"),
       new StyleAttrDescriptor(STYLE_TAB_INSETS,Insets.class,"tabInsets"),
       new StyleAttrDescriptor(STYLE_ROLLOVER_BACKGROUND,Color.class,"rollOverBackground"),
       new StyleAttrDescriptor(STYLE_ROLLOVER_FOREGROUND,Color.class,"rollOverForeground"),
       new StyleAttrDescriptor(STYLE_TAB_PLACEMENT,Integer.class,"tabPlacement",tabPlacementSymbolics),
       new StyleAttrDescriptor(STYLE_CLOSE_IMAGE,ImageReference.class,"closeImage"),
       new StyleAttrDescriptor(STYLE_CLOSE_TOOLTIP,String.class,"closeToolTip"),      
     };
     /**
      * @see echopoint.stylesheet.StyleInfo#getStyleDescriptors()
      */
     public StyleAttrDescriptor[] getStyleDescriptors() {
       return styleDescriptors;
     }
   }
 
   /** Property Chnage Names */
   public static final String SELECTED_INDEX_CHANGED_PROPERTY = "selindex";
   public static final String MODEL_CHANGED_PROPERTY = "model";
 
   public static final String TAB_REMOVED_PROPERTY = "tabRemove";
   public static final String TAB_ADDED_PROPERTY = "tabAdded";
   public static final String TAB_PLACEMENT_CHANGED_PROPERTY = "tabPlacement";
 
   public static final String BORDER_COLOR_CHANGED_PROPERTY = "borderColor";
   public static final String BORDER_SIZE_CHANGED_PROPERTY = "borderSize";
 
   public static final String ROLLOVER_FOREGROUND_CHANGED_PROPERTY = "rollOverFore";
   public static final String ROLLOVER_BACKGROUND_CHANGED_PROPERTY = "rollOverBack";
 
   public static final String INACTIVE_FOREGROUND_CHANGED_PROPERTY = "inactFore";
   public static final String INACTIVE_BACKGROUND_CHANGED_PROPERTY = "inactBack";
   public static final String INACTIVE_ROLLOVER_FOREGROUND_CHANGED_PROPERTY = "inactRollOverFore";
   public static final String INACTIVE_ROLLOVER_BACKGROUND_CHANGED_PROPERTY = "inactRollOverBack";
   public static final String INACTIVE_FONT_CHANGED_PROPERTY = "inactFont";
 
   public static final String INSETS_CHANGED_PROPERTY = "insets";
   public static final String TAB_INSETS_CHANGED_PROPERTY = "tabInsets";
   public static final String ICON_SPACING_CHANGED_PROPERTY = "iconSpacing";
   public static final String TAB_SPACING_CHANGED_PROPERTY = "tabSpacing";
 
   public static final String TAB_ICON_CHANGED_PROPERTY = "tabIcon";
   public static final String TAB_TITLE_CHANGED_PROPERTY = "tabTitle";
   public static final String TAB_TIP_CHANGED_PROPERTY = "tabTip";
   public static final String TAB_COMPONENT_CHANGED_PROPERTY = "tabComponent";
 
   public static final String RENDERING_CHANGED_PROPERTY = "rendering";
   public static final String TAB_IMAGE_RENDERER_CHANGED_PROPERTY = "tabImageRenderer";
 
   public static final String SCROLLBAR_POLICY_CHANGED_PROPERTY = "scrollbarsPolicy";
   public static final String WIDTH_CHANGED_PROPERTY = "width";
   public static final String HEIGHT_CHANGED_PROPERTY = "height";
   public static final String SCROLL_BAR_X_CHANGED_PROPERTY = "scrollbarX";
   public static final String SCROLL_BAR_Y_CHANGED_PROPERTY = "scrollbarX";
 
   public static final String CLOSE_IMAGE_CHANGED_PROPERTY = "closeImage";
   public static final String CLOSE_TOOLTIP_CHANGED_PROPERTY = "closeToolTip";
 
   //
   // defaults colors and insets
   //
   public static final Insets DEFAULT_INSETS = new Insets(2);
   public static final Insets DEFAULT_TAB_INSETS = new Insets(2);
 
   public final static Color DEFAULT_BACKGROUND = new Color(0xc0, 0xc0, 0xc0);
   public final static Color DEFAULT_FOREGROUND = Color.BLACK;
 
   public final static Color DEFAULT_ROLLOVER_BACKGROUND = DEFAULT_BACKGROUND;
   public final static Color DEFAULT_ROLLOVER_FOREGROUND = new Color(0x77, 0x88, 0x99); // light slate grey
 
   public final static Color DEFAULT_INACTIVE_BACKGROUND = new Color(0xe0, 0xe0, 0xe0);
   public final static Color DEFAULT_INACTIVE_FOREGROUND = new Color(0x80, 0x80, 0x80);
 
   public final static Color DEFAULT_INACTIVE_ROLLOVER_BACKGROUND = DEFAULT_INACTIVE_BACKGROUND;
   public final static Color DEFAULT_INACTIVE_ROLLOVER_FOREGROUND = new Color(0x00, 0x00, 0x5A);
 
   /**
    * default close image
    */
   public static ImageReference DEFAULT_CLOSE_IMAGE = null;
   static {
     DEFAULT_CLOSE_IMAGE = new ResourceImageReference(ResourceNames.WINDOW_CLOSE, 17, 14);
   }
 
   //
   // we always have a border for tabs for starters!
   private Color borderColor = Color.BLACK;
   private int borderSize = 1;
 
   //
   // our rollover colors
   private Color rollOverForeground = DEFAULT_ROLLOVER_FOREGROUND;
   private Color rollOverBackground = DEFAULT_ROLLOVER_BACKGROUND;
 
   //
   // inactive tab colors.  By default they are null.
   private Color inactiveForeground = DEFAULT_INACTIVE_FOREGROUND;
   private Color inactiveBackground = DEFAULT_INACTIVE_BACKGROUND;
   private Color inactiveRollOverForeground = DEFAULT_INACTIVE_ROLLOVER_FOREGROUND;
   private Color inactiveRollOverBackground = DEFAULT_INACTIVE_ROLLOVER_BACKGROUND;
   private Font inactiveFont = null;
 
   // the insets
   private Insets insets = DEFAULT_INSETS;
   private Insets tabInsets = DEFAULT_TAB_INSETS;
 
   //
   // the spacing to between the tab icon and text
   private int iconSpacing = 5;
   private int tabSpacing = 3;
   
   //
   // our image renderer is initially null
   private TabImageRenderer tabImageRender = null;
 
   //
   // contain where the tabs are placed
   private int tabPlacement = EchoConstants.TOP;
 
   //
   // our width and height
   private int width = Integer.MAX_VALUE;
   private int height = Integer.MAX_VALUE;
   private int scrollBarPolicy = SCROLLBARS_NEVER;
   
   // closeImage
   private ImageReference closeImage = null;
   private String closeToolTip = "Close Tab";
   
   //
   // the invisible component container
   private DevNull invisibleContainer;
   // 
   // the visible component container
   private Container visibleContainer;
 
   //
   // contains our list of TabContents
   private java.util.ArrayList tabList = new java.util.ArrayList();
 
   /**
    * <code>TabEntry</code> is a simple class used to hold tab entrie
    */
   private class TabEntry implements Serializable {
     private String tabTitle;
     private ImageReference tabIcon;
     private String tabTipText;
     private Component tabComponent;
     private int scrollBarX = 0;
     private int scrollBarY = 0;
   };
 
   //
   // our model
   private SingleSelectionModel model;
   
   /**
    * Constructs a TabbedPane with the tab placement as <code>EchoConstants.TOP</code>
    * and the specified TabImageRenderer.
    * <p>
    * If the TabImageRenderer is non null then the borders will be removed 
    * and the tab insets will be set to zero.  This is usually the appearance 
    * you will want.
    * 
    */
   public TabbedPane(TabImageRenderer renderer) {
     this(EchoConstants.TOP,renderer);
   }
 
   /**
    * Constructs a TabbedPane with the tab placement as <code>EchoConstants.TOP</code>
    */
   public TabbedPane() {
     this(EchoConstants.TOP);
   }
   
   /**
    * Constructs a new TabbedPane
    * <br>
    * @param tabPlacement  the tab placement of the tabbed pane,
    *        can be one of the following values.
    *        <ul>
    *        <li>EchoConstants.TOP (the default)</li>
    *        <li>EchoConstants.BOTTOM</li>
    *        </ul>
    */
   public TabbedPane(int tabPlacement) {
     this(tabPlacement,null);
   }  
   /**
    * Constructs a new TabbedPane.  
    * <p>
    * If the TabImageRenderer is
    * non null then the borders will be removed and the tab
    * insets will be set to zero.  This is usually the appearance 
    * you will want.
    * <br>
    * @param tabPlacement  the tab placement of the tabbed pane,
    *        can be one of the following values.
    *        <ul>
    *        <li>EchoConstants.TOP (the default)</li>
    *        <li>EchoConstants.BOTTOM</li>
    *        </ul>
    * @param renderer - the TabImageRenderer to use
    */
   public TabbedPane(int tabPlacement, TabImageRenderer renderer) {
     super();
     
     invisibleContainer = new DevNull();
     super.add(invisibleContainer,-1);
     
     visibleContainer = new Container();
     super.add(visibleContainer,-1);
     
     setTabPlacement(tabPlacement);
     setBackground(DEFAULT_BACKGROUND);
     setForeground(DEFAULT_FOREGROUND);
 
     setModel(new DefaultSingleSelectionModel());
     
     setTabImageRender(renderer);
     if (renderer != null) {
       setTabInsets(new Insets(0));
       setBorderSize(0);
       setBorderColor(null);
     }
     
   }
 
   /**
    * Adds an ActionListener to the TabbedPane.  It will be informed
    * if the Tabs have close icons and the use has asked to
    * close the tab.
    *  
    * @param l - a new ActionListener
    */  
   public void addActionListener(ActionListener l) {
     listenerList.addListener(ActionListener.class, l);
   }  
 
   /**
    * Removes an ActionListener to the TabbedPane.  
    *  
    * @param l - a ActionListener to remove
    */  
   public void removeActionListener(ActionListener l) {
     listenerList.removeListener(ActionListener.class, l);
   }  
   
   /**
    * Notifies all listeners that have registered for this event type.
    *
    * @param e The <code>ActionEvent</code> to send.
    */
   public void fireActionPerformed(ActionEvent e) {
     EventListener[] listeners = listenerList.getListeners(ActionListener.class);
     for (int index = 0; index < listeners.length; ++index) {
       ((ActionListener) listeners[index]).actionPerformed(e);
     }
   }
   
   /**
    * Adds a component to the <code>TabbedPane</code>.  
    * <p>
    * <i>Cover method for insertTab</i>
    *
    */
   public void add(String tabTitle, Component component) {
     addTab(tabTitle, null, component, null);
   }
   
   /**
    * Adds a component to the <code>TabbedPane</code>
    * <p>
    * <i>Cover method for insertTab</i>
    *
    */
   public void add(String tabTitle, ImageReference tabIcon, Component component) {
     addTab(tabTitle, tabIcon, component, null);
   }
   /**
    * Adds a component to the <code>TabbedPane</code>
    * <p>
    * <i>Cover method for insertTab</i>
    *
    */
   public void add(String tabTitle, ImageReference tabIcon, Component component, String tabToolTip) {
     insertTab(tabTitle, tabIcon, component, tabToolTip, tabList.size());
   }
   /**
    * Adds a component to the <code>TabbedPane</code> with an empty title.  
    * <p>
    * <i>Cover method for insertTab</i>
    *
    */
   public void add(Component component) {
     insertTab(null,null,component,null,tabList.size());
   }
   /**
    * Adds a component to the <code>TabbedPane</code> with an empty title.
    * at the specified index.
    * <p>
    * <i>Cover method for insertTab</i>
    *
    */
   public void add(Component component, int index) {
     insertTab("", null, component, null, index);
   }
   /**
    * Adds a <code>ChangeListener</code> to the tabbed pane.
    *
    * @param l The <code>ChangeListener</code> to be added.
    */
   public void addChangeListener(ChangeListener l) {
     model.addChangeListener(l);
   }
   /**
    * Adds a component to the <code>TabbedPane</code>.  
    * <i>Cover method for insertTab</i>
    *
    */
   public void addTab(String tabTitle, Component component) {
     addTab(tabTitle, null, component, null);
   }
   
   /**
    * Adds a component to the <code>TabbedPane</code>.  
    * <i>Cover method for insertTab</i>
    *
    */
   public void addTab(ImageReference tabIcon, Component component) {
     addTab(null, tabIcon, component, null);
   }
   
   /**
    * Adds a component to the <code>TabbedPane</code>
    * <i>Cover method for insertTab</i>
    *
    */
   public void addTab(String tabTitle, ImageReference tabIcon, Component component) {
     addTab(tabTitle, tabIcon, component, null);
   }
   /**
    * Adds a component to the <code>TabbedPane</code>
    * <i>Cover method for insertTab</i>
    *
    */
   public void addTab(String tabTitle, ImageReference tabIcon, Component component, String tabToolTip) {
     insertTab(tabTitle, tabIcon, component, tabToolTip, tabList.size());
   }
   /**
    * 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_ICON_SPACING)) {
       setIconSpacing(style.getIntegerAttribute(STYLE_ICON_SPACING));
     }
 
     if (style.hasAttribute(STYLE_ROLLOVER_BACKGROUND)) {
       setRollOverBackground((Color) style.getAttribute(STYLE_ROLLOVER_BACKGROUND));
     }
     if (style.hasAttribute(STYLE_ROLLOVER_FOREGROUND)) {
       setRollOverForeground((Color) style.getAttribute(STYLE_ROLLOVER_FOREGROUND));
     }
 
     if (style.hasAttribute(STYLE_INACTIVE_BACKGROUND)) {
       setInactiveBackground((Color) style.getAttribute(STYLE_INACTIVE_BACKGROUND));
     }
     if (style.hasAttribute(STYLE_INACTIVE_FOREGROUND)) {
       setInactiveForeground((Color) style.getAttribute(STYLE_INACTIVE_FOREGROUND));
     }
     if (style.hasAttribute(STYLE_INACTIVE_ROLLOVER_BACKGROUND)) {
       setInactiveRollOverBackground((Color) style.getAttribute(STYLE_INACTIVE_ROLLOVER_BACKGROUND));
     }
     if (style.hasAttribute(STYLE_INACTIVE_ROLLOVER_FOREGROUND)) {
       setInactiveRollOverForeground((Color) style.getAttribute(STYLE_INACTIVE_ROLLOVER_FOREGROUND));
     }
     if (style.hasAttribute(STYLE_INACTIVE_FONT)) {
       setInactiveFont((Font) style.getAttribute(STYLE_INACTIVE_FONT));
     }
 
     if (style.hasAttribute(STYLE_TAB_PLACEMENT))
       setTabPlacement(style.getIntegerAttribute(STYLE_TAB_PLACEMENT));
 
     if (style.hasAttribute(STYLE_INSETS)) {
       setInsets((Insets) style.getAttribute(STYLE_INSETS));
     }
     if (style.hasAttribute(STYLE_TAB_INSETS)) {
       setTabInsets((Insets) style.getAttribute(STYLE_TAB_INSETS));
     }
 
     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));
 
     if (style.hasAttribute(STYLE_CLOSE_IMAGE)) 
       setCloseImage((ImageReference) style.getAttribute(STYLE_CLOSE_IMAGE));
 
     if (style.hasAttribute(STYLE_CLOSE_TOOLTIP)) 
       setCloseToolTip(style.getStringAttribute(STYLE_CLOSE_TOOLTIP));
 
   }
   /**
    * @return The <code>Color</code> of the <code>TabbedPane's</code> border.
    */
   public Color getBorderColor() {
     return borderColor;
   }
   /**
    * @return The size of the <code>TabbedPane's</code> border.
    */
   public int getBorderSize() {
     return borderSize;
   }
   /**
    * @return The <code>Component</code> of the tab at the specified index.
    */
   public Component getComponentAt(int index) {
     TabEntry te = getTabEntryAt(index);
     return (te != null) ? te.tabComponent : null;
   }
   /**
    * Returns the number of tabs within the <code>TabbedPane</code>.
    */
   public int getCount() {
     return getTabCount();
   }
   /**
    * Returns the height of the <code>WizardPane</code>.  If this value
    * is -1, then no height will be used.
    */
   public int getHeight() {
     return height;
   }
   /**
    * @return The <code>ImageReference</code> incon of the tab at the specified index.
    */
   public ImageReference getIconAt(int index) {
     TabEntry te = getTabEntryAt(index);
     return (te != null) ? te.tabIcon : null;
   }
   /**
    * @return The icon spacing of the <code>TabbedPane</code>
    */
   public int getIconSpacing() {
     return iconSpacing;
   }
   /**
    * @return the background <code>Color</code> of the inactive tabs
    */
   public Color getInactiveBackground() {
     return inactiveBackground;
   }
   /**
    * @return the <code>Font</code> of the inactive tabs
    */
   public Font getInactiveFont() {
     return inactiveFont;
   }
   /**
    * @return the foreground <code>Color</code> of the inactive tabs
    */
   public Color getInactiveForeground() {
     return inactiveForeground;
   }
   /**
    * @return the rollover background <code>Color</code> of the inactive tabs
    */
   public Color getInactiveRollOverBackground() {
     return inactiveRollOverBackground;
   }
   /**
    * @return the rollover foreground <code>Color</code> of the inactive tabs
    */
   public Color getInactiveRollOverForeground() {
     return inactiveRollOverForeground;
   }
   /** 
   * 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>TabbedPane</code>.
    *
    */
   public SingleSelectionModel getModel() {
     return model;
   }
   /**
    * @return the rollover background <code>Color</code> of the tabs
    */
   public Color getRollOverBackground() {
     return rollOverBackground;
   }
   /**
    * @return the rollover foreground <code>Color</code> of the tabs
    */
   public Color getRollOverForeground() {
     return rollOverForeground;
   }
   /**
    * 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() {
     TabEntry entry = getTabEntryAt(getSelectedIndex());
     if (entry == null)
       return 0;
     return entry.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() {
     TabEntry entry = getTabEntryAt(getSelectedIndex());
     if (entry == null)
       return 0;
     return entry.scrollBarY;
   }
   /**
    * @return the <code>Component</code> at the currently selected index or null if
    * no tab is currently selected.
    */
   public Component getSelectedComponent() {
     int index = model.getSelectedIndex();
     if (index < 0)
       return null;
     return getComponentAt(index);
   }
   /**
    * Returns the currently selected tab index or -1 if none is selected
    */
   public int getSelectedIndex() {
     return model.getSelectedIndex();
   }
   /**
    * Returns the number of tabs within the <code>TabbedPane</code>.
    */
   public int getTabCount() {
     return tabList.size();
   }
   /**
    * Returns the tab entry at a specified index.  Returns null if the
    * index is out of range.
    *
    */
   private TabEntry getTabEntryAt(int index) {
     if (index < 0 || index >= tabList.size())
       return null;
 
     TabEntry te = (TabEntry) tabList.get(index);
 
     return te;
   }
   /**
    * @return The tab placement of the <code>TabbedPane</code>
    *
    */
   public int getTabPlacement() {
     return tabPlacement;
   }
   /**
    * @return The title of the tab at the specified index.
    */
   public String getTitleAt(int index) {
     TabEntry te = getTabEntryAt(index);
     return (te != null) ? te.tabTitle : null;
   }
   /**
    * @return The tool tip of the tab at the specified index.
    */
   public String getToolTipAt(int index) {
     TabEntry te = getTabEntryAt(index);
     return (te != null) ? te.tabTipText : 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 index of the given <code>Component</code> or -1 if it is not found
    */
   public int indexOfComponent(Component c) {
     for (int i = 0; i < tabList.size(); i++) {
       TabEntry te = getTabEntryAt(i);
       if (te.tabComponent == c)
         return i;
     }
     return -1;
   }
   /**
    * Returns the index of the tab with the given title or -1 if it is not found
    */
   public int indexOfTab(String tabTitle) {
     for (int i = 0; i < tabList.size(); i++) {
       TabEntry te = getTabEntryAt(i);
       if (te.tabTitle.equals(tabTitle))
         return i;
     }
     return -1;
   }
   /**
    * Returns the index of the tab with the given <code>ImageReference </code> 
    * icon or -1 if it is not found
    */
   public int indexOfTab(ImageReference icon) {
     for (int i = 0; i < tabList.size(); i++) {
       TabEntry te = getTabEntryAt(i);
       if (te.tabIcon == icon)
         return i;
     }
     return -1;
   }
   
   /**
    * Returns the index of the specified Component or -1 if it
    * cannot be found. 
    * @param component - the component to search for
    * @return - the index where ther component occurs or -1 if it cannot be found
    */
   public int getTabIndex(Component component) {
     int index = 0;
     for (Iterator iter = tabList.iterator(); iter.hasNext(); ){
       TabEntry entry = (TabEntry)iter.next();
       if (entry.tabComponent == component)
         return index;
       ++index;
     }
     return -1;
   }
   
   /**
    * This will set the specified Component as the selected tab.
    *  
    * @param component - the component to search for 
    * @throws NoSuchElementException if the Component cannnot be found
    */
   public void setSelected(Component component) throws NoSuchElementException {
     int index = getTabIndex(component);
     if (index < 0)
       throw new NoSuchElementException("Tab component not found");
     setSelectedIndex(index);
   }
   
   /**
    * Insert a tab at the specified index.  
    */
   public void insertTab(String tabTitle, ImageReference tabIcon, Component component, String tabToolTip, int index) {
 
     if (index < 0)
       index = 0;
 
     if (tabTitle == null && tabIcon == null)
       tabTitle = "Tab " + index;
 
     TabEntry tc = new TabEntry();
     tc.tabTitle = tabTitle;
     tc.tabIcon = tabIcon;
     tc.tabTipText = tabToolTip;
     tc.tabComponent = component;
 
     int newIndex = -1;
     if (index >= tabList.size()) {
       tabList.add(tc);
       newIndex = tabList.size() - 1;
     } else {
       tabList.add(index, tc);
       newIndex = index;
     }
 
     //
     // we always have a selected Index if we have some entries
     if (getSelectedIndex() == -1)
       setSelectedIndex(newIndex);
 
     reArrangeVisibleComponents(null);
 
     //
     // fire the icon property change to get the image handlers in place
     firePropertyChange(TAB_ICON_CHANGED_PROPERTY, -1, newIndex);
 
     //
     // an one for any one interested
     firePropertyChange(TAB_ADDED_PROPERTY, -1, newIndex);
   }
   /**
    * Removes a tab which corresponds to the index
    */
   public void remove(int index) {
     removeTabAt(index);
   }
   /**
    * Removes a tab which corresponds to the Component c.
    */
   public void remove(Component c) {
     for (int i = getTabCount() - 1; i >= 0; i--) {
 
       TabEntry te = getTabEntryAt(i);
       if (te == null)
         continue;
 
       if (te.tabComponent == c) {
         removeTabAt(i);
       }
     }
   }
   /**
    * Removes all tabs entries.
    */
   public void removeAll() {
     for (int i = getTabCount() - 1; i >= 0; i--) {
       removeTabAt(i);
     }
   }
   /**
    * Removes a ChangeListener from this component.
    *
    * @param l the ChangeListener to remove
   *
   */
  public void removeChangeListener(ChangeListener l) {
    model.removeChangeListener(l);
  }
  /**
   * Removes a tab from the tabbed pane at the specified index.
   */
  public void removeTabAt(int index) {
    TabEntry te = getTabEntryAt(index);
    if (te == null)
      return;

    tabList.remove(index);

    int newIndex = index - 1;
    if (newIndex < 0)
      newIndex = 0;

    if (tabList.size() == 0)
      newIndex = -1;

    reArrangeVisibleComponents(te.tabComponent);

    firePropertyChange(TAB_REMOVED_PROPERTY, -1, index);

    setSelectedIndex(newIndex);
  }

  
  /**
   * Called to rearrange the components inside the TabbedPane
   * 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);
  }
  
  /**
   * Sets the border Color of the <code>TabbedPane</code>
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.BORDER_COLOR_CHANGED_PROPERTY</code>
   *
   */
  public void setBorderColor(nextapp.echo.Color newBorderColor) {
    Color oldValue = borderColor;
    borderColor = newBorderColor;
    firePropertyChange(BORDER_COLOR_CHANGED_PROPERTY, oldValue, newBorderColor);
  }
  /**
   * Sets the border size of the <code>TabbedPane</code>
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.BORDER_SIZE_CHANGED_PROPERTY</code>
   *
   */
  public void setBorderSize(int newBorderSize) {
    int oldValue = borderSize;
    borderSize = newBorderSize;
    firePropertyChange(BORDER_SIZE_CHANGED_PROPERTY, oldValue, newBorderSize);
  }

  /**
   * 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>TabbedPane.TAB_COMPONENT_CHANGED_PROPERTY</code>
   *
   */
  public void setComponentAt(int index, Component component) {

    TabEntry te = getTabEntryAt(index);
    if (te == null)
      return;

    Component oldValue = te.tabComponent;

    te.tabComponent = component;

    firePropertyChange(TAB_COMPONENT_CHANGED_PROPERTY, oldValue, component);
  }
  /**
   * Sets the height of the <code>TabbedPane</code>.  If this
   * value is -1, then no height will be used.
   * <p>
   * Note that this is the height of the contents of the TabbedPane
   * not the outside of the TabbedPane.  This allows scrolling within
   * the contents of the TabbedPane.
   * <p>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.HEIGHT_CHANGED_PROPERTY</code>
   *
   */
  public void setHeight(int newValue) {
    int oldValue = height;
    height = newValue;
    firePropertyChange(HEIGHT_CHANGED_PROPERTY, oldValue, newValue);
  }
  /**
   * Sets the <code>ImageReference</code> icon at the specified index
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.TAB_ICON_CHANGED_PROPERTY</code>
   *
   */
  public void setIconAt(int index, ImageReference newImageRef) {

    TabEntry te = getTabEntryAt(index);
    if (te == null)
      return;

    te.tabIcon = newImageRef;

    //
    // note here that we send down the index of the changed tab icon
    // not the image itself.
    firePropertyChange(TAB_ICON_CHANGED_PROPERTY, -1, index);
  }
  /**
   * Sets the icon spacing of the <code>TabbedPane</code>
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.ICON_SPACING_CHANGED_PROPERTY</code>
   * 
   */
  public void setIconSpacing(int newIconSpacing) {
    int oldValue = iconSpacing;
    iconSpacing = newIconSpacing;
    firePropertyChange(ICON_SPACING_CHANGED_PROPERTY, oldValue, newIconSpacing);
  }
  /**
   * Sets the background <code>Color</code> of the <code>TabbedPane's</code> inactive tabs.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.INACTIVE_BACKGROUND_CHANGED_PROPERTY</code>
   *
   */
  public void setInactiveBackground(Color newInactiveBackground) {
    Color oldValue = inactiveBackground;
    inactiveBackground = newInactiveBackground;
    firePropertyChange(INACTIVE_BACKGROUND_CHANGED_PROPERTY, oldValue, newInactiveBackground);
  }
  /**
   * Sets the <code>Font</code> of the <code>TabbedPane's</code> inactive tabs.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.INACTIVE_FONT_CHANGED_PROPERTY</code>
   *
   */
  public void setInactiveFont(Font newInactiveFont) {
    Font oldValue = inactiveFont;
    inactiveFont = newInactiveFont;
    firePropertyChange(INACTIVE_FONT_CHANGED_PROPERTY, oldValue, newInactiveFont);
  }
  /**
   * Sets the foreground <code>Color</code> of the <code>TabbedPane's</code> inactive tabs.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.INACTIVE_BACKGROUND_CHANGED_PROPERTY</code>
   *
   */
  public void setInactiveForeground(Color newInactiveForeground) {
    Color oldValue = inactiveForeground;
    inactiveForeground = newInactiveForeground;
    firePropertyChange(INACTIVE_BACKGROUND_CHANGED_PROPERTY, oldValue, newInactiveForeground);
  }
  /**
   * Sets the rollover background <code>Color</code> of the <code>TabbedPane's</code> inactive tabs.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.INACTIVE_ROLLOVER_BACKGROUND_CHANGED_PROPERTY</code>
   *
   */
  public void setInactiveRollOverBackground(Color newInactiveRollOverBackground) {
    Color oldValue = inactiveRollOverBackground;
    inactiveRollOverBackground = newInactiveRollOverBackground;
    firePropertyChange(INACTIVE_ROLLOVER_BACKGROUND_CHANGED_PROPERTY, oldValue, newInactiveRollOverBackground);
  }
  /**
   * Sets the rollover foreground <code>Color</code> of the <code>TabbedPane's</code> inactive tabs.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.INACTIVE_ROLLOVER_BACKGROUND_CHANGED_PROPERTY</code>
   *
   */
  public void setInactiveRollOverForeground(Color newInactiveRollOverForeground) {
    Color oldValue = inactiveRollOverForeground;
    inactiveRollOverForeground = newInactiveRollOverForeground;
    firePropertyChange(INACTIVE_ROLLOVER_BACKGROUND_CHANGED_PROPERTY, oldValue, newInactiveRollOverForeground);
  }
  /**
  * Sets the insets (margins) of the <code>TabbedPane</code>
  *
  * @param newValue An insets object that specifies the size of each margin 
  *        of this <code>TabbedPane</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>TabbedPane</code>
   *.
   * @param model the model to be used
   *
   */
  public void setModel(SingleSelectionModel model) {
    SingleSelectionModel oldModel = getModel();
    this.model = model;
    firePropertyChange(MODEL_CHANGED_PROPERTY, oldModel, model);
  }
  /**
   * Sets the rollover background <code>Color</code> of the <code>TabbedPane's</code> tabs.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.ROLLOVER_BACKGROUND_CHANGED_PROPERTY</code>
   *
   */
  public void setRollOverBackground(Color newRollOverBackground) {
    Color oldValue = rollOverBackground;
    rollOverBackground = newRollOverBackground;
    firePropertyChange(ROLLOVER_BACKGROUND_CHANGED_PROPERTY, oldValue, newRollOverBackground);
  }
  /**
   * Sets the rollover foreground <code>Color</code> of the <code>TabbedPane's</code> tabs.
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> with a
   * <code>getPropertyName()</code> value of 
   * <code>TabbedPane.ROLLOVER_BACKGROUND_CHANGED_PROPERTY</code>
   *
   */
  public void setRollOverForeground(Color newRollOverForeground) {
    Color oldValue = rollOverForeground;
    rollOverForeground = newRollOverForeground;
    firePropertyChange(ROLLOVER_BACKGROUND_CHANGED_PROPERTY, oldValue, newRollOverForeground);
  }
  /**
   * 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) {
    TabEntry entry = getTabEntryAt(getSelectedIndex());
    if (entry == null)
      return;

    int oldValue = entry.scrollBarX;
    entry.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) {
    TabEntry entry = getTabEntryAt(getSelectedIndex());
    if (entry == null)
      return;

    int oldValue = entry.scrollBarY;
    entry.scrollBarY = newValue;
    firePropertyChange(SCROLL_BAR_Y_CHANGED_PROPERTY, oldValue, newValue);
  }
  /**
   * Sets the selected tab of the <code>TabbedPane</code>.
   */
  public void setSelectedIndex(int index) {
    model.setSelectedIndex(index);
  }
  /** 
   * Sets the tab placement of the <code>TabbedPane</code>
   *
   * @param newTabPlacement the tab placement of the tabbed pane,
   *        can be one of the following values.
   *        <ul>
   *        <li>EchoConstants.TOP (the default)</li>
   *        <li>EchoConstants.BOTTOM</li>
   *        </ul>
   */
  public void setTabPlacement(int newTabPlacement) {
    int oldValue = tabPlacement;
    tabPlacement = newTabPlacement;
    firePropertyChange(TAB_PLACEMENT_CHANGED_PROPERTY, oldValue, newTabPlacement);
  }
  /**
   * Sets the title at the specified index
   * <br>
   * This methods fires a <code>PropertyChangeEvent</code> wi