/*******************
 * Class QwertyPanel (v7) offers basic keyboard-style entry from a gridbag of onscreen
 * buttons. All letters are upper-case only. Enter, dot, hyphen, space and backspace
 * are also available. At the top left there is a button that switches between
 * qwerty and alphabetic layout. There is a method to re-label any of the four 'soft'
 * Fkeys in the top row. They default to F1 thru F4 - if they are re-labeled as ""
 * they are automatically disabled. There are also methods to enable/disable a single
 * key or all keys, to add and remove ActionListeners, to switch between layouts and to
 * interrogate which layout is being used and whether a particular key is enabled.
 * The colors used for enabled and disabled buttons can be set in the overloaded constructor
 * and are set as public in case you want to change them after instantiation. This is made
 * easier to achieve by subclassing Button as QPButton and adding relevant functionality
 * to its constructor. ActionCommands passed are the strings that appear on the face
 * of the buttons.
 *
 * This version now includes numbers too.
 *
 * Constructors:	QwertyPanel(),
 *					QwertyPanel(int LAYOUT_TYPE),
 *					QwertyPanel(int LAYOUT_TYPE, Color enabledColor, Color disabledColor)
 *
 * Public methods:	void	setFkey(int number, String label)
 *					void	setKeyEnabled(String label, boolean state)
 *					void	enableAllKeys()
 *					void	disableAllKeys()
 *					boolean	isKeyEnabled(String label)
 *					boolean	isQwertyLayout()
 *					void	setLayout(int LAYOUT_TYPE)
 *					void	addActionListener(ActionListener l)
 *					void	removeActionListener(ActionListener l)
 *
 * The previous version used two panels (one for each key layout) treated as a CardLayout.
 * This revised version uses one panel only and re-labels the keys to achieve different
 * key layouts. I found it more difficult in terms of logic and data management,
 * especially concerning keeping a record of which keys are dis/enabled. But it works
 * faster and was an interesting challenge.
 *
 * Andy Murray 23/11/02
 */

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.StringTokenizer;

public class QwertyPanel extends Panel implements ActionListener
{
	private Panel buttonPanel;
	private GridBagLayout bag;
	private GridBagConstraints c;
	private QPButton [] btn;
	private int totalButtons;
	public Color enabledColor, disabledColor;
	private Font boldFont, italicFont;
	private final StringTokenizer qwertyST, alphaST;
	private String [] qwertyLabels, alphaLabels;
	private boolean [] enabledFlags;//indexed by alpha position
	public static final int	ALPHA_LAYOUT	=0,
							QWERTY_LAYOUT	=1;

	TextField peek;//***************for debugging

	/**
	 * This QwertyPanel constructor allows for the fullest num of instance variables
	 */
	QwertyPanel(int LAYOUT_TYPE, Color enabledColor, Color disabledColor)
	{
		totalButtons=46;
		peek = new TextField(40);
		alphaST = new StringTokenizer("dummy,F1,F2,F3,F4,1,2,3,4,5,6,7,8,9,0,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,Enter,T,U,V,W,X,Y,Z,.,-,<<<,Space", ",");
		qwertyST = new StringTokenizer("dummy,F1,F2,F3,F4,1,2,3,4,5,6,7,8,9,0,Q,W,E,R,T,Y,U,I,O,P,A,S,D,F,G,H,J,K,L,Enter,Z,X,C,V,B,N,M,.,-,<<<,Space", ",");
		qwertyLabels = new String[totalButtons];
		alphaLabels = new String[totalButtons];
		enabledFlags = new boolean[totalButtons];
		for (int i=0;i<totalButtons;i++)
		{
			qwertyLabels[i]=qwertyST.nextToken();
			alphaLabels[i]=alphaST.nextToken();
			enabledFlags[i]=true;
		}
		boldFont = new Font("SansSerif", Font.BOLD, 14);
		italicFont = new Font("Serif", Font.ITALIC, 14);
		this.enabledColor = enabledColor;
		this.disabledColor = disabledColor;
		makeAllButtons();
		buttonPanel = new Panel();
		buttonPanel.setBackground(Color.black);
		bag = new GridBagLayout();
		c = new GridBagConstraints();
		buttonPanel.setLayout(bag);
		assemblePanel();
		setLayout(LAYOUT_TYPE);
		this.add(buttonPanel);
//		this.add(peek);	//for debugging*************************
	}

	/**
	 * The assemblePanel() method uses GridBagLayout to size and position the buttons
	 */
	private void assemblePanel()
	{
		c.insets = new Insets(1,1,1,1);
		c.fill = GridBagConstraints.BOTH;
		c.ipadx = 4;
		c.ipady = 4;
		c.gridheight = 4;
		c.gridwidth = 4;	//no of cells-1 ???

		//top row
		btn[0].setLabel("qwerty");
		for (int i=0;i<4;i++)
		{
			bag.setConstraints(btn[i],c);
			buttonPanel.add(btn[i]);
		}
		c.gridwidth = GridBagConstraints.REMAINDER; //end row
		bag.setConstraints(btn[4],c);
		buttonPanel.add(btn[4]);

		//next 4 num/letter rows
		for (int r=0;r<4;r++)
		{
			c.gridwidth=2;
			for (int i=5+10*r;i<14+10*r;i++)
			{
				bag.setConstraints(btn[i],c);
				buttonPanel.add(btn[i]);
			}
			c.gridwidth=GridBagConstraints.REMAINDER; //end row
			bag.setConstraints(btn[14+10*r],c);buttonPanel.add(btn[14+10*r]);
		}

		//space bar
		bag.setConstraints(btn[45],c);
		buttonPanel.add(btn[45]);
	}

	/**
	 * the letter buttons are created all with the same labels and later labelled
	 * differently, appropriate to qwerty/alpha layout
	 */
	private void makeAllButtons()
	{
		btn = new QPButton[totalButtons];
		btn[0]=new QPButton("xxx",Color.black,Color.red);
		btn[0].setForeground(enabledColor);
		btn[0].addActionListener(this);
		for (int i=1;i<5;i++)	//top row Fkeys
		{
			btn[i]=new QPButton("F"+i, enabledColor, disabledColor);
			btn[i].setFont(boldFont);
		}
		for (int i=5;i<15;i++)	//number keys
		{
			btn[i]=new QPButton(""+((i-4)%10), enabledColor, disabledColor);
			btn[i].setFont(italicFont);
		}
		for (int i=15;i<totalButtons;i++)	//letter keys
		{
			btn[i]=new QPButton("x", enabledColor, disabledColor);
			btn[i].setFont(boldFont);
		}
	}

	/**
	 * Other constructors use fewer instance variables:
	 */
	QwertyPanel()
	{
		this(QWERTY_LAYOUT, Color.orange, Color.lightGray);
	}

	QwertyPanel(int LAYOUT_TYPE)
	{
		this(LAYOUT_TYPE, Color.orange, Color.lightGray);
	}

	/**
	 * The only action to listen for internally is the change of layout key
	 */
	public void actionPerformed(ActionEvent ae)
	{
		String clicked = ae.getActionCommand();
		this.setLayout((clicked.equals("qwerty")) ? QWERTY_LAYOUT : ALPHA_LAYOUT);
	}


	////////////////////// PUBLIC INTERFACE STUFF ///////////////////////

	/**
	 * First off, here are two useful private methods called by public class methods:
	 */
	private int getBtnIndexFromLabel(String label)
	{
		int index=1;
		while (index<totalButtons)
		{
			if (btn[index].getLabel().equals(label)) {break;}
			index++;
		}
		return (index<totalButtons) ? index : -1;
	}

	private int qwertyToAlpha(int visibleIndex)
	{
		int match = 0;
		//filter fkeys first:
		if (visibleIndex<15) { match=visibleIndex; }
		//otherwise:
		else
		{
			match=15;
			while(match<totalButtons)
			{
				if (btn[visibleIndex].getLabel().equals(alphaLabels[match])) {break;}
				match++;
			}
		}
		return (match<totalButtons) ? match : -1;
	}

	/**
	 * The setFkey method allows any of the four soft 'Fkey' buttons to be labelled
	 * as desired. These are numbered 1 thru 4 for the purposes of access using this
	 * method. When clicked, the Fkey buttons send their current label to any registered
	 * ActionListeners as their ActionCommand. Fkeys labelled "" are automatically disabled.
	 */
	public void setFkey(int number, String label)
	{
		if ( (number>0) && (number<5) )
		{
			btn[number].setLabel(label);
			if (label.length()==0) {btn[number].setEnabled(false);}
		}
	}

	/**
	 * The setKeyEnabled method allows any QwertyPanel button (except the layout switch)
	 * to be enabled or disabled. Both states have an associated background color. When
	 * switching between alpha and qwerty layout, it is the identity of a button that
	 * is dis/enabled, not a fixed position in the grid.
	 */

	 // this was the brain-tangling bit!

	public void setKeyEnabled(String label, boolean state)
	{
		int visibleIndex, logicalIndex;
		visibleIndex = getBtnIndexFromLabel(label);
		if (visibleIndex>-1)
		{
//			peek.setText("vis index="+visibleIndex);	//**************************
			logicalIndex=(isQwertyLayout()) ? qwertyToAlpha(visibleIndex) : visibleIndex;
			btn[visibleIndex].setEnabled(state);
			enabledFlags[logicalIndex]=state;
		}
	}

	/**
	 * The isKeyEnabled method allows you to check the enabled/disabled state of any
	 * button by referencing its label. The method returns true for an enabled button.
	 */
	public boolean isKeyEnabled(String label)
	{
		if (label.equals("")) { return false; }
		else
		{
			int index = getBtnIndexFromLabel(label);
			if (isQwertyLayout()) { index=qwertyToAlpha(index);}
			return (index>-1) ? enabledFlags[index] : false;
		}
	}

	/**
	 * The enableAllKeys method does what it says on the tin, except that it doesn't
	 * enable buttons with "" label (Fkeys can be set to have no label)
	 */
	public void enableAllKeys()
	{
		for (int i=1;i<totalButtons;i++)
		{
			btn[i].setEnabled((btn[i].getLabel().length()>0));
			enabledFlags[i]=true;
		}
	}

	/**
	 * The disableAllKeys method does what it says on the tin, except that it doesn't
	 * disable the alpha/qwerty switch.
	 */
	public void disableAllKeys()
	{
		for (int i=1;i<totalButtons;i++)
		{
			btn[i].setEnabled(false);
			enabledFlags[i]=false;
		}
	}

	/**
	 * The setLayout method allows you to switch between the qwerty and alphabetic
	 * layout patterns by passing statics QWERTY_LAYOUT or ALPHA_LAYOUT.
	 * Switching layouts preserves the enable state of letter buttons.
	 */
	public void setLayout(int type)	//where type = ALPHA_LAYOUT / QWERTY_LAYOUT
	{
		btn[0].setLabel((type==ALPHA_LAYOUT) ? "qwerty" : "abc");
		//don't bother with fkeys or number keys, which always stay in same position
		for (int i=15;i<totalButtons;i++)
		{
			switch (type)
			{
				case ALPHA_LAYOUT :
					btn[i].setLabel(alphaLabels[i]);
					btn[i].setEnabled(enabledFlags[i]);
					break;
				case QWERTY_LAYOUT :
					btn[i].setLabel(qwertyLabels[i]);
					btn[i].setEnabled(enabledFlags[qwertyToAlpha(i)]);
			}
		}
	}

	/**
	 * The addActionListener method adds the specified action listener to receive
	 * action events from any button in QwertyPanel except the layout switch.
	 */
	public void addActionListener(ActionListener l)
	{
		for (int i=1;i<totalButtons;i++) { btn[i].addActionListener(l); }
	}

	/**
	 * The removeActionListener method removes the specified action listener so that
	 * it no longer receives action events from buttons in QwertyPanel.
	 */
	public void removeActionListener(ActionListener l)
	{
		for (int i=1;i<totalButtons;i++) { btn[i].removeActionListener(l); }
	}

	public boolean isQwertyLayout()
	{
		return (btn[15].getLabel().equals("Q"));
	}
}

/**
 * This is the customised Button subclass that includes automated background colouring
 * of enabled and disabled states. Its setEnabled() method sets this color, then calls
 * the setEnabled() method in the superclass. I've included constructors that can set
 * the enabled and disabled colors, and also methods to change them after instantiation.
 */
class QPButton extends Button
{
	private Color enabledColor;
	private Color disabledColor;

	QPButton(String s, Color enabledColor, Color disabledColor)
	{
		this.setLabel(s);
		this.enabledColor=enabledColor;
		this.disabledColor=disabledColor;
		this.setBackground(enabledColor);
	}

	QPButton()
	{
		this("", Color.orange, Color.lightGray);
	}

	QPButton(String s)
	{
		this(s, Color.orange, Color.lightGray);
	}

	public void setEnabled(boolean b)
	{
		this.setBackground( (b==true) ? enabledColor : disabledColor );
		super.setEnabled(b);
	}

	public void setEnabledColor(Color c)
	{ this.enabledColor=c; }

	public void setDisabledColor(Color c)
	{ this.disabledColor=c; }
}