/*
    $Author: $
    $Date: $
    $Revision: $
    $NoKeywords: $
*/

package jp.co.ntl.awt;

import java.awt.*;
import java.io.Serializable;
import java.util.Vector;
import java.beans.*;

public class TabbedPanel extends BaseTabbedPanel implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

    private PropertyChange myPropertyChangeHandler = new PropertyChange();
    private VetoableChangeSupport vetos = new VetoableChangeSupport(this);
    private PropertyChangeSupport changes = new PropertyChangeSupport(this);
	Vector vPanels;

	String[] labels = null;

	transient boolean bOsHack;
	public TabbedPanel(){
		this(TOP, ROUNDED);
	}

	public TabbedPanel(boolean bTabsOnTop) {
		this(bTabsOnTop ? TOP : BOTTOM, bTabsOnTop ? ROUNDED : SQUARE);
	}

	public TabbedPanel(int tabsPostion, int tabsStyle){
		super(tabsPostion, tabsStyle);
		vPanels = new Vector();
		String sOS = System.getProperty("os.name");
		if (sOS.equals("Windows 95"))
			bOsHack = true;
		else
			bOsHack = false;

		super.addCurrentTabListener(myPropertyChangeHandler);
	}

	public int getCurrentPanelNdx() {
	    return curIndex;
	}

	public void setCurrentPanelNdx(int index) throws PropertyVetoException {
		if (index != curIndex) {
			Integer oldindex = new Integer(curIndex);
			Integer newindex = new Integer(index);

			vetos.fireVetoableChange("CurrentPanelNdx", oldindex, newindex);
		    showTabPanel(index);

	        if (! java.beans.Beans.isDesignTime())
	            curIndex = index;

	        changes.firePropertyChange("CurrentPanelNdx", oldindex, newindex);
		}
	}

	public void setPanelLabels(String[] sLabels) throws PropertyVetoException {
		String[] oldLabels = labels;

		vetos.fireVetoableChange("PanelLabels", oldLabels, sLabels);

	    labels=sLabels;
	    updatePanelLabels();

        changes.firePropertyChange("PanelLabels", oldLabels, sLabels);
	}

	public String[] getPanelLabels() {
	    return labels;
	}

	public void setPanelLabel(String newLabel, int labelIndex) throws PropertyVetoException {

		if(labelIndex >= 0 && labelIndex < labels.length && labels[labelIndex] != newLabel) {
			String oldLabel = labels[labelIndex];
			vetos.fireVetoableChange("PanelLabel", oldLabel, newLabel);

		    labels[labelIndex] = newLabel;
		    updatePanelLabels();

	        changes.firePropertyChange("PanelLabel", oldLabel, newLabel);
		}

	}

	public String getPanelLabel(int labelIndex) {
		if(labelIndex >= 0 && labelIndex < labels.length) {
	    	return labels[labelIndex];
	    } else {
	    	return null;
	    }
	}

	public void setTabsOnBottom(boolean bTabsOnBottom) throws PropertyVetoException {
		Boolean oldValue = new Boolean(getTabsOnBottom());
		Boolean newValue = new Boolean(bTabsOnBottom);

		if(!oldValue.equals(newValue)) {
			vetos.fireVetoableChange("TabsOnBottom", oldValue, newValue);

			setTabsInfo(bTabsOnBottom ? BOTTOM : TOP, bTabsOnBottom ? SQUARE : ROUNDED);
		    doLayout();

		    changes.firePropertyChange("TabsOnBottom", oldValue, newValue);
		}
	}

	public boolean isTabsOnBottom() {
	     return getTabsPosition() == TOP ? false : true;
	}

	public boolean getTabsOnBottom() {
	     return isTabsOnBottom();
	}

	public synchronized void setTabPanel(String sLabel, boolean bEnabled, Component panel, int index) throws PropertyVetoException {
		if ((index < 0) || (index >= vPanels.size())) {
			return;
        }

		if (index == getCurrentTab() && !bEnabled) {
			return;
        }

		try {
			Component oldPanel = (Component) vPanels.elementAt(index);
			vetos.fireVetoableChange("TabPanel", oldPanel, panel);

			vPanels.setElementAt(panel, index);
			setTab(sLabel, bEnabled, index);

			changes.firePropertyChange("TabPanel", oldPanel, panel);
		} catch (ArrayIndexOutOfBoundsException e) {
		}
	}

	public synchronized Component getTabPanel(int index) {
		if ((index < 0) || (index >= vPanels.size())) {
			return null;
		}

		Component p = null;
		try {
			p =  (Component)vPanels.elementAt(index);
		} catch (ArrayIndexOutOfBoundsException e) {
		}
		return p;
	}

	public synchronized int getPanelTabIndex(Component panel) {
		return vPanels.indexOf(panel);
	}

	public synchronized void showTabPanel(int index) {
		if (isEnabled(index)) {
			try {
				Component p = (Component) vPanels.elementAt(index);
				try {
					setCurrentTab(index);
				} catch (java.beans.PropertyVetoException e) {
				}
				showPanel(p);
			}
			catch (ArrayIndexOutOfBoundsException e) {}
		}
	}

	public int addTabPanel(String sLabel, boolean bEnabled, Component panel) {
		return addTabPanel(sLabel, bEnabled, panel, -1);
	}

	public int addTabPanel(String sLabel, boolean bEnabled, Component panel, int pos) {
		if (pos == -1) {
		    vPanels.addElement(panel);
		} else {
		    vPanels.insertElementAt(panel, pos);
        }
		return addTab(sLabel, bEnabled, pos);
	}

	public Component add(Component comp) {
	    return add(comp,-1);
	}


	public synchronized Component add(Component comp, int pos) {
		boolean wasSuppressingRepaints = setSuppressRepaints(true);
		super.add(comp, pos);
        comp.setVisible(false);
		try {
			int newIndex = addTabPanel(createDefaultLabel(vPanels.size()),true,comp,pos);
			if (newIndex == curIndex || java.beans.Beans.isDesignTime())
				showTabPanel(newIndex);
			updatePanelLabels();
		} finally {
			setSuppressRepaints(wasSuppressingRepaints);
		}

		triggerRepaint();

		return comp;
	}

	public synchronized Component add(String name, Component comp) {
	    return comp;
	}

	public synchronized void remove(Component comp) {
		int i = getPanelTabIndex(comp);

		if (countTabs() == 1) {
			removeAllTabPanels();
		} else {
			if (i == 0) {
				showTabPanel(1);
			} else {
				showTabPanel(i-1);
			}
			removeTabPanel(i);
		}
	}


	public void updatePanelLabels() {
	    try {
	    	for (int i=0;i<vPanels.size();i++) {
				String newlabel;
				if (labels!=null) {
					try {
			    		newlabel=labels[i];
					} catch (ArrayIndexOutOfBoundsException e) {
			    		newlabel=createDefaultLabel(i);
					}
				} else {
			    	newlabel=createDefaultLabel(i);
				}
				setLabel(newlabel,i);
		    }
	    } catch(Throwable thr) {
	    }
	}


	public synchronized void enableTabPanel(boolean bEnable, int index) throws PropertyVetoException {
		if ((index < 0) || (index >= vPanels.size()) || index == curIndex) {
			return;
		}

		setEnabled(bEnable, index);
	}

	public synchronized void insertTabPanel(String sLabel, boolean bEnabled, Component panel, int index) {
        if ((index < 0) || (index >= vPanels.size())) {
            return;
        }

        if (index == getCurrentTab() && !bEnabled) {
            return;
        }

        try {
            vPanels.insertElementAt(panel, index);
            insertTab(sLabel, bEnabled, index);
        } catch (ArrayIndexOutOfBoundsException e) {
        }
    }

	public synchronized void removeTabPanel(int index) {
		if ((index < 0) || (index >= vPanels.size()) || index == curIndex) {
			return;
		}

		try {
			Component p = (Component) vPanels.elementAt(index);
			super.remove(p);
			vPanels.removeElementAt(index);
		} catch (ArrayIndexOutOfBoundsException e) {
		}

		removeTab(index);
	}

	public synchronized void removeAllTabPanels() {
		vPanels = new Vector();
		curIndex = -1;
		removeAllTabs();
	}

	public int countTabs() {
		return vPanels.size();
	}

    public Dimension getPreferredSize() {
    	Dimension p = getSize();
    	Dimension m = getMinimumSize();
    	return new Dimension(Math.max(p.width, m.width), Math.max(p.height, m.height));
    }

    public Dimension getMinimumSize() {
        return new Dimension(20, 40);
    }

	public void update(Graphics g) {
		paint(g);
	}

	public void paint(Graphics g) {
		super.paint(g);
	}

    public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
    	super.addPropertyChangeListener(listener);
    	changes.addPropertyChangeListener(listener);
    }

    public synchronized void removePropertyChangeListener(PropertyChangeListener listener) {
    	super.removePropertyChangeListener(listener);
    	changes.removePropertyChangeListener(listener);
    }

    public synchronized void addVetoableChangeListener(VetoableChangeListener listener) {
     	super.addVetoableChangeListener(listener);
		vetos.addVetoableChangeListener(listener);
    }

    public synchronized void removeVetoableChangeListener(VetoableChangeListener listener) {
    	super.removeVetoableChangeListener(listener);
    	vetos.removeVetoableChangeListener(listener);
    }

    class PropertyChange implements PropertyChangeListener, Serializable {
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
        public void propertyChange(PropertyChangeEvent e) {
	        showTabPanel(((Integer)e.getNewValue()).intValue());
        }
    }

	private String createDefaultLabel(int i) {
	    String name="tab - ";
	    name += String.valueOf(i);
	    return name;
	}

}