package causation.lab;

// packages
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;

// no custom classes

/**
 * <p>
 * This class contains the code for the two bars in the CausalityLab.
 * Its primary function is to lay out the buttons correctly, disable them
 * when the bar is disabled, and fire <code>PropertyChangeEvent</code>s
 * when buttons are pressed.
 * </p><p>
 * The following <code>PropertyChangeEvent</code>s are sent by this class:
 * <ul>
 * <li>("LOCK", Boolean oldState, Boolean newState)
 *	<ul><li>Values always different</ul>
 * <li>("RANDOMIZER", Boolean oldState, Boolean newState)
 *	<ul><li>Values always different</ul>
 * <li>("DATA", null, null)
 * <li>(ARROW", Boolean oldState, Boolean newState)
 *	<ul><li>Values always different</ul>
 * <li>(LATENT", Boolean oldState, Boolean newState)
 *	<ul><li>Values always different</ul>
 * <li>("INDEPENDENCE", null, null)
 * <li>("ENABLED", Boolean oldState, Boolean newState)
 *	<ul><li>Values always different</ul>
 * <li>("BUTTON_ACTIVATED"+index, Boolean oldState, Boolean newState)
 *	<ul><li>Values always different</ul>
 * </ul></p><p>
 * Copyright 1999 by David Danks.  All rights reserved.</p>
 *
 * @version	1.0	May 15, 1999
 * @author	David Danks
 */

public class ButtonBar extends JPanel implements ActionListener,
	LayoutManager {

/////////////////// Class Variables ///////////////////
// types of ButtonBars
	public static final int SETUP_GATHER_DATA_BAR = 0;
	public static final int HYPOTHESIZE_PREDICT_BAR = 1;

// Label text
	private static final String[] SGD_LABEL = {"Setup Experiment",
		"& Gather Data"};
	private static final String[] HP_LABEL = {"Hypothesize &",
		"Make Predictions"};
	private static final Font FONT = new Font("Dialog", Font.BOLD, 11);

// Tooltip text
	private static final String LOCK_TOOLTIP = "Lock a variable";
	private static final String RAND_TOOLTIP = "Randomize a variable";
	private static final String DATA_TOOLTIP = "Collect a dataset";
	private static final String ARROW_TOOLTIP = "Draw an arrow";
	private static final String LATENT_TOOLTIP = "Add a latent variable";
	private static final String INDEP_TOOLTIP = "Get independence facts";
	
// icon directory
	private static final String DIR = "icons/";
// SGD Button icons
 	private static final String LOCK_ENABLED = "lockup.gif";
 	private static final String LOCK_SELECTED = "lockdown.gif";
 	private static final String LOCK_ROLLOVER = "lockroll.gif";
 	private static final String LOCK_DISABLED = "lockoff.gif";
 	private static final String RAND_ENABLED = "randup.gif";
 	private static final String RAND_SELECTED = "randdown.gif";
 	private static final String RAND_ROLLOVER = "randroll.gif";
 	private static final String RAND_DISABLED = "randoff.gif";
 	private static final String DATA_ENABLED = "dataup.gif";
 	private static final String DATA_SELECTED = "datadown.gif";
 	private static final String DATA_ROLLOVER = "dataroll.gif";
 	private static final String DATA_DISABLED = "dataoff.gif";
// HP Button icons
 	private static final String ARROW_ENABLED = "arrowup.gif";
 	private static final String ARROW_SELECTED = "arrowdown.gif";
 	private static final String ARROW_ROLLOVER = "arrowroll.gif";
 	private static final String ARROW_DISABLED = "arrowoff.gif";
 	private static final String LATENT_ENABLED = "latentup.gif";
 	private static final String LATENT_SELECTED = "latentdown.gif";
 	private static final String LATENT_ROLLOVER = "latentroll.gif";
 	private static final String LATENT_DISABLED = "latentoff.gif";
 	private static final String INDEP_ENABLED = "indepup.gif";
 	private static final String INDEP_SELECTED = "indepdown.gif";
 	private static final String INDEP_ROLLOVER = "indeproll.gif";
 	private static final String INDEP_DISABLED = "indepoff.gif";

// Background info
	private static final Color ENABLED_BACKGROUND = 
		new Color(153, 204, 153);
	private static final Color DISABLED_BACKGROUND =
		new Color(204, 204, 204);
	private static final Color LABEL = new Color(102, 102, 102);
	private static final Insets MARGIN = new Insets(3, 3, 3, 3);
	private static final int UPPER_PIXEL_GAP = 15;
	private static final int LOWER_PIXEL_GAP = UPPER_PIXEL_GAP;

/////////////////// Instance Variables ///////////////////
	// barEnabled tells us whether the bar is enabled; buttonActivated
	// tells us whether we can use the button or not.
	private boolean barEnabled = true;
	private boolean[] buttonActivated = new boolean[4];
	private String[] label = null;
	private JToggleButton toggled = null;
	private int type;
	private URL codebase;

/////////////////// Constructors ///////////////////

//	public ButtonBar() { this(SETUP_GATHER_DATA_BAR, new URL()); }
//	public ButtonBar(int type) { this(type, new URL()); }
/**
 * This constructor creates a ButtonBar of type <code>type</code>, and
 * loads images from <code>codebase</code>
 * @param	type		The type of ButtonBar
 * @param	codebase	The codebase for loading images
 */
	public ButtonBar(int type, URL codebase) {
		this.type = type;
		this.codebase = codebase;
		setLayout(this);
		setFont(FONT);
		for (int i=0; i<buttonActivated.length; i++) {
			buttonActivated[i] = true;
		}
	
		if (type == SETUP_GATHER_DATA_BAR) sgdInit(); 
		else if (type == HYPOTHESIZE_PREDICT_BAR) hpInit();
	}
/**
 * A helper method that does the initialization for a SetupGatherDataBar.
 */
	private void sgdInit() {
		label = SGD_LABEL;
		// add the buttons
		JToggleButton lock = createToggleButton("LOCK", LOCK_TOOLTIP,
			LOCK_ENABLED, LOCK_SELECTED, LOCK_ROLLOVER, LOCK_DISABLED);
		add(lock);		
		JToggleButton rand = createToggleButton("RANDOMIZER", RAND_TOOLTIP,
			RAND_ENABLED, RAND_SELECTED, RAND_ROLLOVER, RAND_DISABLED);
		add(rand);
		JButton data = createButton("DATA", DATA_TOOLTIP,
			DATA_ENABLED, DATA_SELECTED, DATA_ROLLOVER, DATA_DISABLED);
		add(data);
	}
/**
 * A helper method that does the initialization for an 
 * HypothesizePredictBar.
 */
	private void hpInit() {
		label = HP_LABEL;
		// add the buttons
		JToggleButton arrow = createToggleButton("ARROW", ARROW_TOOLTIP,
			ARROW_ENABLED, ARROW_SELECTED, ARROW_ROLLOVER, ARROW_DISABLED);
		add(arrow);
		JToggleButton latent = createToggleButton("LATENT", LATENT_TOOLTIP,
			LATENT_ENABLED, LATENT_SELECTED, LATENT_ROLLOVER, LATENT_DISABLED);
		add(latent);
		JButton indep = createButton("INDEPENDENCE", INDEP_TOOLTIP,
			INDEP_ENABLED, INDEP_SELECTED, INDEP_ROLLOVER, INDEP_DISABLED);
		add(indep);
	}

/////////////////// Instance Methods ///////////////////

/**
 * Called when a button is pressed.  Usually, we just fire off the correct
 * <code>PropertyChangeEvent</code>.
 */
	public void actionPerformed(ActionEvent a) {
		// if it's a toggle button, do the appropriate logic, and only
		// fire the needed PCEs
		if (a.getSource() instanceof JToggleButton) {
			if (toggled == null) {	// none pressed
				toggled = (JToggleButton)a.getSource();
				firePropertyChange(a.getActionCommand(), 
					new Boolean(false), new Boolean(true));
			}
			else if (toggled == a.getSource()) {	// remove setting
				toggled = null;
				firePropertyChange(a.getActionCommand(), 
					new Boolean(true), new Boolean(false));
			}
			else {	// unset toggled, and then send messages
				toggled.setSelected(false);
				firePropertyChange(toggled.getActionCommand(), 
					new Boolean(true), new Boolean(false));
				toggled = (JToggleButton)a.getSource();
				firePropertyChange(a.getActionCommand(), 
					new Boolean(false), new Boolean(true));
			}
		}
		else {	// otherwise, we just want to notify that it was clicked
			firePropertyChange(a.getActionCommand(), null, null);
		}
	}

/**
 * @return	Whether the bar is enabled
 */
	public boolean isBarEnabled() { return barEnabled; }
/**
 * @param	b	Whether the bar should be enabled
 */
	public void setBarEnabled(boolean b) {
		if (b == barEnabled) return;
		// do the change
		barEnabled = b;
		Component[] children = getComponents();
		for (int i=0; i<children.length; i++) {
			if (children[i] instanceof AbstractButton) {
				if (buttonActivated[i]) {
					((AbstractButton)children[i]).setEnabled(b);
				}
			}
		}
		firePropertyChange("ENABLED", new Boolean(!(b)), 
			new Boolean(b));
		invalidate();
	}
/**
 * @param	index	The index of the button to check
 * @return	Whether that button can be pressed
 */
	public boolean isButtonActivated(int index) { 
		return buttonActivated[index];
	}
/**
 * @param	index	The index of the button to set
 * @param	b		Whether that button should be able to be pressed
 */
	public void setButtonActivated(int index, boolean b) {
		if (b == buttonActivated[index]) return;
		buttonActivated[index] = b;
		Component[] comps = getComponents();
		if (comps[index].isEnabled()) comps[index].setEnabled(b);
		else if (index == 0) comps[index].setEnabled(b);
		firePropertyChange("BUTTON_ACTIVATED"+index, new Boolean(!(b)), 
			new Boolean(b));
		invalidate();
	}
/**
 * @return	<code>true</code> always, since we fill the background
 */
	public boolean isOpaque() { return true; }
	
/**
 * Un-selects any of the JToggleButtons that might be selected.  This
 * is here to make switching bars easier.
 */
	public void deselectAll() {
		// if nothing's selected, just return
		if (toggled == null) return;
		// otherwise, call actionPerformed on toggled
		toggled.doClick();
	} 

/**
 * This method paints the background and text for the ButtonBar.
 * @param	g	The Graphics context in which to paint the ButtonBar
 */
	public void paintComponent(Graphics g) {
		int height = getHeight();
		int width = getWidth();
		FontMetrics fm = getFontMetrics(getFont());
		// first, paint the background
		if (barEnabled) g.setColor(ENABLED_BACKGROUND);
		else g.setColor(DISABLED_BACKGROUND);
		g.fillRect(0, 0, width, height);
		// then paint the label
		g.setColor(LABEL);
		int topInset = (height-getPreferredSize().height)/2+MARGIN.top;
		for (int i=0; i<label.length; i++) {
			int leftInset = (width-fm.stringWidth(label[i]))/2;
			g.drawString(label[i], leftInset, topInset+fm.getAscent());
			topInset += fm.getHeight();
		}
	}

/**
 * @return	The preferred size of the ButtonBar
 */
	public Dimension getPreferredSize() {
		int height = MARGIN.top+MARGIN.bottom;
		int width = 0;
		FontMetrics fm = getFontMetrics(getFont());
		// factor in the label
		height += fm.getHeight()*label.length;
		for (int i=0; i<label.length; i++)
			width = Math.max(width, fm.stringWidth(label[i]));
		height += UPPER_PIXEL_GAP;
		// factor in the components
		Component[] comps = getComponents();
		width = Math.max(width, comps[0].getPreferredSize().width+
			comps[1].getPreferredSize().width);
		height += Math.max(comps[0].getPreferredSize().height,
			comps[1].getPreferredSize().height);
		height += LOWER_PIXEL_GAP;
		width = Math.max(width, comps[2].getPreferredSize().width);
		height += comps[2].getPreferredSize().height;
		width += MARGIN.left+MARGIN.right;
		
		return new Dimension(width, height);
	}
/**
 * @return	The minimum size of the ButtonBar (currently the same as the 
 *				preferred size).
 */
	public Dimension getMinimumSize() { return getPreferredSize(); }
/**
 * @return	The preferred size (LayoutManager method)
 */
	public Dimension preferredLayoutSize(Container parent) {
		return getPreferredSize();
	}
/**
 * @return	The minimum size (LayoutManager method)
 */
	public Dimension minimumLayoutSize(Container parent) {
		return getPreferredSize();
	}
/**
 * This method takes care of laying out the ButtonBar
 * @param	parent	The ButtonBar to be layed out
 */
	public void layoutContainer(Container parent) {
		Dimension size = getSize();
		int topInset = (size.height-getPreferredSize().height)/2;
		FontMetrics fm = getFontMetrics(getFont());
		
		// leave room for the label
		int height = topInset+MARGIN.top+fm.getHeight()*label.length+
			UPPER_PIXEL_GAP;
		Component[] comps = getComponents();
		// layout the side-by-side buttons
		int leftInset = (size.width-comps[0].getPreferredSize().width-
			comps[1].getPreferredSize().width)/2;
		int adjust = (comps[0].getPreferredSize().height-
			comps[1].getPreferredSize().height)/2;
		if (adjust < 0) {	// comps[1] is bigger than comps[0]
			comps[0].setBounds(leftInset, height+adjust,
				comps[0].getPreferredSize().width,
				comps[0].getPreferredSize().height);
			leftInset += comps[0].getPreferredSize().width;
			comps[1].setBounds(leftInset, height,
				comps[1].getPreferredSize().width,
				comps[1].getPreferredSize().height);
			height += comps[1].getPreferredSize().height+LOWER_PIXEL_GAP;
		}
		else {	// comps[0] is same size or bigger than comps[1]
			comps[0].setBounds(leftInset, height,
				comps[0].getPreferredSize().width,
				comps[0].getPreferredSize().height);
			leftInset += comps[0].getPreferredSize().width;
			comps[1].setBounds(leftInset, height-adjust,
				comps[1].getPreferredSize().width,
				comps[1].getPreferredSize().height);
			height += comps[0].getPreferredSize().height+LOWER_PIXEL_GAP;
		}
		// layout the bottom button
		leftInset = (size.width-comps[2].getPreferredSize().width)/2;
		comps[2].setBounds(leftInset, height,
			comps[2].getPreferredSize().width,
			comps[2].getPreferredSize().height);
	}
/**
 * LayoutManager method that is currently unimplemented 
 */
 	public void addLayoutComponent(String name, Component comp) { ; }
/**
 * LayoutManager method that is currently unimplemented 
 */
 	public void removeLayoutComponent(Component comp) { ; }
 	
/**
 * Does the (extensive) work of creating JToggleButtons for us.  If an
 * icon String is null, then don't do any set at all.
 * @param	action			The action command
 * @param	tooltip			The rollover String
 * @param	enabledIcon		The filename of the Icon for an enabled button
 * @param	selectedIcon	The filename of the Icon for a selected button
 * @param	rolloverIcon	The filename of the Icon for a rollover button
 * @param	disabledIcon	The filename of the Icon for a disabled button
 */
	private JToggleButton createToggleButton(String action, String tooltip,
		String enabledIcon, String selectedIcon, String rolloverIcon,
		String disabledIcon) {
		
		JToggleButton button = new JToggleButton();
		button.setContentAreaFilled(false);
		button.setMargin(new Insets(0, 0, 0, 0));
		button.setBorder(null);
		try {
			if (enabledIcon != null)
				button.setIcon(new 
					ImageIcon(new URL(codebase+DIR+enabledIcon)));
			if (selectedIcon != null) {
				button.setSelectedIcon(new 
					ImageIcon(new URL(codebase+DIR+selectedIcon)));
				button.setPressedIcon(new 
					ImageIcon(new URL(codebase+DIR+selectedIcon)));
			}
			if (rolloverIcon != null)
				button.setRolloverIcon(new 
					ImageIcon(new URL(codebase+DIR+rolloverIcon)));
			if (disabledIcon != null)
				button.setDisabledIcon(new 
					ImageIcon(new URL(codebase+DIR+disabledIcon)));
		}
		catch (MalformedURLException m) {
			System.out.println("Bad Icon URL: "+m.toString());
			return null;
		}
		button.addActionListener(this);
		button.setActionCommand(action);
		button.setToolTipText(tooltip);
		
		return button;
	}
/**
 * Does the (extensive) work of creating JButtons for us.  If an
 * icon String is null, then don't do any set at all.
 * @param	action			The action command
 * @param	tooltip			The rollover String
 * @param	enabledIcon		The filename of the Icon for an enabled button
 * @param	selectedIcon	The filename of the Icon for a selected button
 * @param	rolloverIcon	The filename of the Icon for a rollover button
 * @param	disabledIcon	The filename of the Icon for a disabled button
 */
	private JButton createButton(String action, String tooltip,
		String enabledIcon, String selectedIcon, String rolloverIcon,
		String disabledIcon) {
		
		JButton button = new JButton();
		button.setContentAreaFilled(false);
		button.setMargin(new Insets(0, 0, 0, 0));
		button.setBorder(null);
		try {
			if (enabledIcon != null)
				button.setIcon(new 
					ImageIcon(new URL(codebase+DIR+enabledIcon)));
			if (selectedIcon != null) {
				button.setSelectedIcon(new 
					ImageIcon(new URL(codebase+DIR+selectedIcon)));
				button.setPressedIcon(new 
					ImageIcon(new URL(codebase+DIR+selectedIcon)));
			}
			if (rolloverIcon != null)
				button.setRolloverIcon(new 
					ImageIcon(new URL(codebase+DIR+rolloverIcon)));
			if (disabledIcon != null)
				button.setDisabledIcon(new 
					ImageIcon(new URL(codebase+DIR+disabledIcon)));
		}
		catch (MalformedURLException m) {
			System.out.println("Bad Icon URL: "+m.toString());
			return null;
		}
		button.addActionListener(this);
		button.setActionCommand(action);
		button.setToolTipText(tooltip);
		
		return button;
	}
}