package ch.werner_randelshofer.gui;

/*
Copyright (C) 1999 Werner Randelshofer
werner.randelshofer@mythen.ch
http://www.mythen.ch/w.randelshofer/
    
Permission to use this release of AbstractButton is hereby
granted without fee provided that the complete copyright
notice and this permission notice appear in all copies
and in supporting documentation.
*/

import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Event;
import java.awt.Color;
import java.awt.ItemSelectable;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import ch.werner_randelshofer.gui.event.ChangeListener;
import ch.werner_randelshofer.gui.event.ChangeEvent;
import ch.werner_randelshofer.gui.model.ButtonModel;
import ch.werner_randelshofer.gui.model.DefaultButtonModel;
import ch.werner_randelshofer.gui.event.EventListenerList;

/**
Toggle button with six states: Unselected,
Unselected pressed, Unselected disabled, Selected, SelectedPressed
, Selected disabled.

@author	Werner Randelshofer, Staldenmattweg 2, CH-6405 Immensee, Switzerland.
@version	1.0	1999-02-21	Created.
*/
public class AbstractButton
extends Canvas
implements MouseListener, ChangeListener, ItemListener, ActionListener, ItemSelectable
	{
	private ChangeEvent changeEvent_;
	private Dimension preferredSize_, minimumSize_;
	private EventListenerList listenerList_ = new EventListenerList();
	private ButtonModel model_;
	private Icon selectedIcon_, unselectedIcon_;
	
	public AbstractButton()
		{
		setModel(new DefaultButtonModel());
		addMouseListener(this);
		}
	
	public ButtonModel getModel()
		{ return model_; }
	public void setModel(ButtonModel m)
		{
		if (model_ != null)
			{
			model_.removeChangeListener(this);
			model_.removeActionListener(this);
			model_.removeItemListener(this);
			}
		model_ = m;
		if (model_ != null)
			{
			model_.addChangeListener(this);
			model_.addActionListener(this);
			model_.addItemListener(this);
			}
		}
	
	public void setSelected(boolean b)
		{ model_.setSelected(b); }
	
	public void setSelectedIcon(Icon icon)
		{ selectedIcon_ = icon; }
	public void setUnselectedIcon(Icon icon)
		{ unselectedIcon_ = icon; }
	public void setIcon(Icon icon)
		{ setUnselectedIcon(icon); }
	public Icon getIcon()
		{ return getUnselectedIcon(); }
	public Icon getUnselectedIcon()
		{ return unselectedIcon_; }
	public Icon getSelectedIcon()
		{ return selectedIcon_; }

	public void paint(Graphics g)
		{
		Dimension s = getSize();
		g.setColor(getForeground());
		g.drawRect(0,0,s.width-1,s.height-1);
		if (! model_.isEnabled())
			{
			g.setColor(Color.lightGray);
			g.fillRect(1,1,s.width-2,s.height-2);
			}
		if (model_.isPressed() && model_.isArmed())
			{
			g.setColor(Color.gray.darker());
			g.fillRect(1,1,s.width-3,s.height-3);
			g.setColor(Color.darkGray);
			g.drawLine(1,1,s.width-2,1);
			g.drawLine(1,1,1,s.height-2);
			g.setColor(Color.gray);
			g.drawLine(2,s.height-2,s.width-2,s.height-2);
			g.drawLine(s.width-2,s.height-2,s.width-2,2);
			}
		else
			{
			g.setColor(Color.lightGray);
			g.fillRect(1,1,s.width-2,s.height-2);
			g.setColor(Color.white);
			g.drawLine(1,1,s.width-3,1);
			g.drawLine(1,1,1,s.height-3);
			/*
			g.setColor(Color.darkGray);
			g.drawLine(2,s.height-2,s.width-2,s.height-2);
			g.drawLine(s.width-2,s.height-2,s.width-2,2);
			*/
			}
		Icon icon = (getModel().isSelected() && selectedIcon_ != null) ? selectedIcon_ : unselectedIcon_;
		if (icon != null)
			{
			icon.paintIcon(this,g,2,2);	
			}
		}

	public Dimension getPreferredSize()
		{
		if (preferredSize_ == null)
			{
			Icon icon = getIcon();
			if (icon != null)
				{
				Dimension d = new Dimension(icon.getIconWidth()+4,icon.getIconHeight()+4);
				return d;
				}
			else
				{ return super.getPreferredSize(); }
			}
		return preferredSize_;
		}
	public void setPreferredSize(Dimension d)
		{ preferredSize_ = d;  }
	
	public Dimension getMinimumSize()
		{
		if (minimumSize_ == null)
			{ return super.getMinimumSize(); }
		return minimumSize_;
		}
	public void setMinimumSize(Dimension d)
		{ minimumSize_ = d;  }
	
	public void mouseClicked(MouseEvent event)
		{
		}
	public void mouseEntered(MouseEvent event)
		{ model_.setArmed(true); }
	public void mouseExited(MouseEvent event)
		{ model_.setArmed(false); }
	public void mousePressed(MouseEvent event)
		{ model_.setPressed(true); 	}
	public void mouseReleased(MouseEvent event)
		{ model_.setPressed(false); }

	/** Sets the action command of the button. */
	public void setActionCommand(String command)
		{ model_.setActionCommand(command); }

	/** Gets the action command of the button. */
	public String getActionCommand()
		{ return model_.getActionCommand(); }
	
	/** Gets the selected state of the button. */
	public boolean isSelected()
		{ return model_.isSelected(); }
	
	public void stateChanged(ChangeEvent event)
		{
		repaint();
		fireStateChanged();
		}
	public void itemStateChanged(ItemEvent event)
		{
		fireItemStateChanged(
			new ItemEvent(this,ItemEvent.ITEM_STATE_CHANGED,this,
						event.getStateChange())
						);
		}
	public void actionPerformed(ActionEvent event)
		{
		fireActionPerformed(
			new ActionEvent(this,ActionEvent.ACTION_PERFORMED,model_.getActionCommand())
			);
		}
	public void addChangeListener(ChangeListener l)
		{ listenerList_.add(ChangeListener.class,l); }
	public void removeChangeListener(ChangeListener l)
		{ listenerList_.remove(ChangeListener.class,l); }
	public void addActionListener(ActionListener l)
		{ listenerList_.add(ActionListener.class,l); }
	public void removeActionListener(ActionListener l)
		{ listenerList_.remove(ActionListener.class,l); }
	public void addItemListener(ItemListener l)
		{ listenerList_.add(ItemListener.class,l); }
	public void removeItemListener(ItemListener l)
		{ listenerList_.remove(ItemListener.class,l); }

	/*
	 * Notify all listeners that have registered interest for
	 * notification on this event type.  The event instance 
	 * is lazily created using the parameters passed into 
	 * the fire method.
	 *
	 * @param e the ActionEvent to deliver to listeners
	 * @see EventListenerList
	 */
	protected void fireActionPerformed(ActionEvent e)
		{
		// Guaranteed to return a non-null array
		Object[] listeners = listenerList_.getListenerList();
		// Process the listeners last to first, notifying
		// those that are interested in this event
		for (int i = listeners.length-2; i>=0; i-=2)
			{
			if (listeners[i]==ActionListener.class)
				{
				// Lazily create the event:
				// if (changeEvent == null)
				// changeEvent = new ChangeEvent(this);
				((ActionListener)listeners[i+1]).actionPerformed(e);
				}
			}
		}
	/*
	 * Notify all listeners that have registered interest for
	 * notification on this event type.  The event instance 
	 * is lazily created using the parameters passed into 
	 * the fire method.
	 *
	 * @param e the ItemEvent to deliver to listeners
	 * @see EventListenerList
	 */
	protected void fireItemStateChanged(ItemEvent e)
		{
		// Guaranteed to return a non-null array
		Object[] listeners = listenerList_.getListenerList();
		// Process the listeners last to first, notifying
		// those that are interested in this event
		for (int i = listeners.length-2; i>=0; i-=2)
			{
			if (listeners[i]==ItemListener.class)
				{
				// Lazily create the event:
				// if (changeEvent == null)
				// changeEvent = new ChangeEvent(this);
				((ItemListener)listeners[i+1]).itemStateChanged(e);
				}
			}
		}
	/*
	 * Notify all listeners that have registered interest for
	 * notification on this event type.  The event instance 
	 * is lazily created using the parameters passed into 
	 * the fire method.
	 *
	 * @see EventListenerList
	 */
	protected void fireStateChanged()
		{
		// Guaranteed to return a non-null array
		Object[] listeners = listenerList_.getListenerList();
		// Process the listeners last to first, notifying
		// those that are interested in this event
		for (int i = listeners.length-2; i>=0; i-=2)
			{
			if (listeners[i]==ChangeListener.class)
				{
				// Lazily create the event:
				if (changeEvent_ == null)
					changeEvent_ = new ChangeEvent(this);
				((ChangeListener)listeners[i+1]).stateChanged(changeEvent_);
				}
			}
		}
	
	public Object[] getSelectedObjects()
		{ return null; }
	}