/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation.
    *
   *  This program 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 General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  package org.xnap.gui.component;
  
  import java.awt.Event;
  import java.awt.FlowLayout;
  import java.awt.GridBagLayout;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.FocusAdapter;
  import java.awt.event.FocusEvent;
  import java.awt.event.KeyAdapter;
  import java.awt.event.KeyEvent;
  
  import javax.swing.AbstractAction;
  import javax.swing.Action;
  import javax.swing.JCheckBox;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JToggleButton;
  import javax.swing.KeyStroke;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  
  import org.xnap.XNap;
  import org.xnap.gui.util.GridBagHelper;
  
  public class KeyStrokePanel extends JPanel 
  	implements ChangeListener, ActionListener {
      
      //--- Data field(s) ---
  
  	private JCheckBox ctrlCheckBox;
      private JCheckBox shiftCheckBox;
  	private JCheckBox metaCheckBox;
  	private JCheckBox altCheckBox;
  	private JToggleButton charButton;
  	private KeyStroke defaultKeyStroke;
  	int keyCode;
  	private CharButtonListener keyListener = new CharButtonListener();
      protected transient ChangeEvent changeEvent;
      
      //--- Constructor(s) ---
  
      public KeyStrokePanel()
      {
  		setLayout(new GridBagLayout());
  
  		ctrlCheckBox 
  			= new JCheckBox(KeyEvent.getKeyModifiersText(Event.CTRL_MASK));
  		ctrlCheckBox.addActionListener(this);
  		GridBagHelper.addComponent(this, ctrlCheckBox);
  
  		altCheckBox 
  			= new JCheckBox(KeyEvent.getKeyModifiersText(Event.ALT_MASK));
  		altCheckBox.addActionListener(this);
  		GridBagHelper.addComponent(this, altCheckBox);
  
  		metaCheckBox
  			= new JCheckBox(KeyEvent.getKeyModifiersText(Event.META_MASK));
  		metaCheckBox.addActionListener(this);
  		GridBagHelper.addComponent(this, metaCheckBox);
  		
  		shiftCheckBox
  			= new JCheckBox(KeyEvent.getKeyModifiersText(Event.SHIFT_MASK));
  		shiftCheckBox.addActionListener(this);
  		GridBagHelper.addComponent(this, shiftCheckBox);
  
  		charButton = new JToggleButton(" ");
  		charButton.addChangeListener(this);
  		charButton.addFocusListener(new UntoggleListener());
  		GridBagHelper.addComponent(this, charButton);
  		
  		// XXX: workaround to horizontally fill space
  		GridBagHelper.add(this, new JLabel());
  
  		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
  		buttonPanel.add(new XNapButton(new DefaultAction()));
  		buttonPanel.add(new XNapButton(new NoneAction()));
  		GridBagHelper.addPanel(this, buttonPanel);
      }
  
  	/***
 	 *  @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
 	 */
 	public void actionPerformed(ActionEvent e)
 	{
 		fireChangeEvent();
 	}
 
     /***
      */
     public void addChangeListener(ChangeListener l) 
     {
         listenerList.add(ChangeListener.class, l);
     }
     
     /***
      * 
      */
     public void removeChangeListener(ChangeListener l) 
     {
         listenerList.remove(ChangeListener.class, l);
     }
 
     protected void fireChangeEvent() {
         Object[] listeners = listenerList.getListenerList();
 
         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 KeyStroke getKeyStroke()
 	{
     	if (keyCode == KeyEvent.VK_UNDEFINED) {
 			return null;
     	}
     	else {
     		int m = 0;
     		m |= (ctrlCheckBox.isSelected()) ? Event.CTRL_MASK : 0;
     		m |= (altCheckBox.isSelected()) ? Event.ALT_MASK : 0;
     		m |= (metaCheckBox.isSelected()) ? Event.META_MASK : 0;
     		m |= (shiftCheckBox.isSelected()) ? Event.SHIFT_MASK : 0;
     		return KeyStroke.getKeyStroke(keyCode, m);
     	}
     }
     
 	public void setKeyStroke(KeyStroke keyStroke)
 	{
 		if (keyStroke != null) {
 			int m = keyStroke.getModifiers();
 			ctrlCheckBox.setSelected((m & Event.CTRL_MASK) != 0);
 			altCheckBox.setSelected((m & Event.ALT_MASK) != 0);
 			metaCheckBox.setSelected((m & Event.META_MASK) != 0);
 			shiftCheckBox.setSelected((m & Event.SHIFT_MASK) != 0);
 			keyCode = keyStroke.getKeyCode();
 			charButton.setText(KeyEvent.getKeyText(keyCode));
 		}
 		else {
 			ctrlCheckBox.setSelected(false);
 			altCheckBox.setSelected(false);
 			metaCheckBox.setSelected(false);
 			shiftCheckBox.setSelected(false);
 			charButton.setText(" ");
 			keyCode = KeyEvent.VK_UNDEFINED;
 		}
 	}
 	
 	public void setDefaultKeyStroke(KeyStroke defaultKeyStroke)
 	{
 		this.defaultKeyStroke = defaultKeyStroke;
 	}
 
 	public void stateChanged(ChangeEvent e) 
 	{
 		if (charButton.isSelected()) {
 			// record the key that is pressed next
 			charButton.addKeyListener(keyListener);
 		}
 		else {
 			charButton.removeKeyListener(keyListener);
 			fireChangeEvent();
 		}
 	}
 
 	private class CharButtonListener extends KeyAdapter {
 
 		public void keyPressed(KeyEvent e) 
 		{
 			keyCode = e.getKeyCode();
 			
 			charButton.setSelected(false);
 			charButton.setText(KeyEvent.getKeyText(keyCode));
 			//  charButton.setText(KeyStroke.getKeyStrokeForEvent(e).toString());
 		}
 
 	}
 
 	private class UntoggleListener extends FocusAdapter {
 
 		public void focusLost(FocusEvent e)
 		{
 			charButton.setSelected(false);
 		}
 
 	}
 
     /***
      * Reperforms a search.
      */
     private class DefaultAction extends AbstractAction {
 
         public DefaultAction() 
 		{
             putValue(Action.NAME, XNap.tr("Default"));
             putValue(Action.SHORT_DESCRIPTION, XNap.tr("Reset to default"));
         }
 
         public void actionPerformed(ActionEvent event) 
 		{
 			setKeyStroke(defaultKeyStroke);
 			fireChangeEvent();
         }
     }
 
     /***
      * Reperforms a search.
      */
     private class NoneAction extends AbstractAction {
 
         public NoneAction() 
 		{
             putValue(Action.NAME, XNap.tr("None"));
             putValue(Action.SHORT_DESCRIPTION,
 					 XNap.tr("Assigns no keystroke"));
         }
 
         public void actionPerformed(ActionEvent event) 
 		{
         	setKeyStroke(null);
 			fireChangeEvent();
 		}
         
     }
 
 	/***
 	 * @param stroke
 	 * @return
 	 */
 	public static String toString(KeyStroke stroke)
 	{
 		StringBuffer sb = new StringBuffer();
 
 		int m = stroke.getModifiers();
 		if ((m & Event.CTRL_MASK) != 0) {
 			sb.append(KeyEvent.getKeyModifiersText(Event.CTRL_MASK));
 			sb.append("+");
 		}
 		if ((m & Event.ALT_MASK) != 0) {
 			sb.append(KeyEvent.getKeyModifiersText(Event.ALT_MASK));
 			sb.append("+");
 		}
 		if ((m & Event.META_MASK) != 0) {
 			sb.append(KeyEvent.getKeyModifiersText(Event.META_MASK));
 			sb.append("+");
 		}
 		if ((m & Event.SHIFT_MASK) != 0) {
 			sb.append(KeyEvent.getKeyModifiersText(Event.SHIFT_MASK));
 			sb.append("+");
 		}
 		sb.append(KeyEvent.getKeyText(stroke.getKeyCode()));
 		return sb.toString();
 	}
 
 }