package javacodebook.gui.keystroke;

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

/**
 * @author Benjamin Rusch
 * 
 * Die einzelnen Buttons können über CTRL + A für "Hinzufügen" und CTRL + D 
 * für "Löschen" aufgerufen werden. Ist einer der Buttons im Focus, 
 * funktioniert das Auslösen auch über ENTER.
 */

public class KeyStrokes  extends Frame {
	
	private Button addButton = new Button("Hinzufügen");
	private Button deleteButton = new Button("Löschen");
	private TextField field = new TextField(15);
	private Panel north = new Panel(); 
	private TextArea editor = new TextArea(9,20);
	
	/**
 	* Konstruktor von KeyStrokes.  
 	*/	
	public KeyStrokes(String title) {
		
		super(title);

		// Focus wird beim Programmstart aufs Textfeld gesetzt, und beim Fenster-
		// Schließen wird Programm beendet
		addWindowListener(new WindowAdapter() {
            public void windowOpened(WindowEvent e) {
                field.requestFocus(); // Focus wird gesetzt
            }
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
		
		// Anmelden eines ActionListeners an den addButton
		addButton.addActionListener(new ActionListener(){
					public void actionPerformed(ActionEvent ae){
						copyText(); 
					}
				});
		
		// Anmelden eines ActionListeners an den deleteButton		
		deleteButton.addActionListener(new ActionListener(){
					public void actionPerformed(ActionEvent ae){
						deleteText();
					}
				});
		
		// Wenn der addButton im Focus ist und ENTER gedrückt wird
		// wird automatisch der Text aus dem TextFeld in die TextArea 
		// kopiert. Zusätzlich müssen hier auch die allgemeinen Operationen, 
		// die ausgeführt werden sollen, egal welche Komponente im Focus ist,
		// implementiert sein. In unserem Fall das Hinzufügen und Löschen
		// über CTRL+A bzw. CTRL+B 
		addButton.addKeyListener(new KeyAdapter(){
					public void keyPressed(KeyEvent e) {
						int code = e.getKeyCode();
						
						if(code==KeyEvent.VK_ENTER) {
							copyText(); 
						}	
						else if ((code==KeyEvent.VK_A)&&(e.getModifiers()==2)) {
							copyText();
						}
						else if ((code==KeyEvent.VK_D)&&(e.getModifiers()==2))	{
							deleteText();
						}
					}
				
				});
				
		// Wenn der deleteButton im Focus ist und ENTER gedrückt wird
		// wird automatisch die TextArea gelöscht. 
		// Zusätzlich müssen hier auch die allgemeinen Operationen, 
		// die ausgeführt werden sollen egal welche Komponente im Focus ist,
		// implementiert sein. In unserem Fall das Hinzufügen und Löschen
		// über CTRL+A bzw. CTRL+B	
		deleteButton.addKeyListener(new KeyAdapter(){
					public void keyPressed(KeyEvent e) {
						int code = e.getKeyCode();
						if( code==KeyEvent.VK_ENTER){
							deleteText(); 
						}
						else if ((code==KeyEvent.VK_A)&& (e.getModifiers()==2))
						{
							copyText();
						}
						else if ((code==KeyEvent.VK_D)&& (e.getModifiers()==2))
						{
							deleteText();
						}
					}
				
				});
		
		// Auch das TextFeld kann im Focus sein. 
		// Die allgemeinen Operationen für Hinzufügen und Löschen über CTRL+A bzw. 
		// CTRL+B müssen also auch hier implementiert sein.				
		field.addKeyListener(new KeyAdapter(){
					public void keyPressed(KeyEvent e) {
						
						int code = e.getKeyCode();
						
						if ((code==KeyEvent.VK_A)&& (e.getModifiers()==2))
						{
							copyText();
						}
						else if ((code==KeyEvent.VK_D)&& (e.getModifiers()==2))
						{
							deleteText();
						}
						
					}
				
				});

				
		// Editor soll nicht focusierbar sein
		editor.setFocusable(false);

		// Platzieren der Komponenten
		north.add(addButton);
		north.add(deleteButton);
		north.add(field);

		add(north, BorderLayout.NORTH);
		add(editor);
	}
	
	/**
	 * Kopiert Text vom Textfeld in die TextArea.
	 */
	private void copyText() {
		editor.append(field.getText());
	}
	
	/**
	 * Löscht die TextArea.
	 */
	private void deleteText() {
		editor.setText("");
	}
}

--- Neue Klasse ---

package javacodebook.gui.keystroke;

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

/**
 * @author Benjamin Rusch
 * 
 * Die einzelnen Buttons können über CTRL + A, F2 und SHIFT + F2 für "Hinzufügen" 
 * und über CTRL + D, F3 und SHIFT F3 für "Löschen" aufgerufen werden. 
 * Ist einer der Buttons im Focus, funktioniert das Auslösen auch über ENTER.
 */

public class KeyStrokesSwing  extends JFrame {
	
	
	// Tasten(bzw. Tastenkombinationen) werden durch Objekte der KeyStroke-Klasse 
	// repräsentiert. Durch die Methode:
	//  	getKeyStroke(int keyCode, int modifier, boolean onKeyRelease)
	// bekommt man entsprechendes KeyStroke-Objekt.
	// keyCode: definiert die Taste(Konstanten der Klasse KeyEvent können verwendet werden)
	// modifier: bei normalen Tasten Druck == 0
	//			 bei Shift == 1 
	//			 bei Strg == 2
	// onKeyRelease: bei true wird Event erst beim loslassen der Taste ausgelöst 
	//				 bei false schon beim drücken
	public static final KeyStroke enter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0,false);
	
	public static final KeyStroke f2 = KeyStroke.getKeyStroke(KeyEvent.VK_F2,0,false);
	public static final KeyStroke shiftF2 = KeyStroke.getKeyStroke(KeyEvent.VK_F2,1,false);
	public static final KeyStroke controlA = KeyStroke.getKeyStroke(KeyEvent.VK_A,2,false);
	
	public static final KeyStroke f3 = KeyStroke.getKeyStroke(KeyEvent.VK_F3,0,false);
	public static final KeyStroke shiftF3 = KeyStroke.getKeyStroke(KeyEvent.VK_F3,1,false);
	public static final KeyStroke controlD = KeyStroke.getKeyStroke(KeyEvent.VK_D,2,false);

	private JButton addButton		= new JButton("Hinzufügen");
	private JButton deleteButton	= new JButton("Löschen");
	private JTextField field 		= new JTextField(15);
	private JPanel north			= new JPanel(); 
	private JTextArea editor		= new JTextArea(9,20);
	
	private Container content		= null;

	/**
 	*	Konstruktor von KeyStrokes.  
 	*/	
	public KeyStrokesSwing(String title) {
		
		super(title);

		content = this.getContentPane();
		// Focus aufs Textfeld setzen, und Programm-Beenden-Funktionalität 
		// implementieren
		addWindowListener(new WindowAdapter() {
            public void windowOpened(WindowEvent e) {
                field.requestFocus(); // Focus wird gesetzt
            }
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
		

		// Anmelden eines ActionListeners an den addButton, die AbstractAction 
		// erfüllt auch das ActionListener interface.
		addButton.addActionListener(new AddAction());
		
		// Anmelden eines ActionListeners an den deleteButton		
		deleteButton.addActionListener(new DeleteAction());

		 // Keystrokes werden mit zugehöriger Action-Schlüssel an den addButton 
		 // angemeldet.
		addButton.getInputMap().put(f2,"add");
    	addButton.getInputMap().put(shiftF2,"add");
	    addButton.getInputMap().put(controlA,"add");
		addButton.getInputMap().put(f3,"delete");
    	addButton.getInputMap().put(shiftF3,"delete");
	    addButton.getInputMap().put(controlD,"delete");
	    addButton.getInputMap().put(enter,"add");
	    
	    // Beide Möglichen Aktionen die ausgeführt werden sollen, wenn die 
	    // Komponente im Focus ist, müssen über den entsprechenden Schlüssel 
	    // an seiner ActionMap angemeldet werden. 
	    // (Anmerkung: Delete soll über "Strg + D" natürlich auch ausgeführt werden, 
	    // wenn der addButton im Focus ist.) 
	    addButton.getActionMap().put("add", new AddAction());
	    addButton.getActionMap().put("delete", new DeleteAction());
	    
	    // Keystrokes und Actions werden an den deleteButton angemeldet.
		deleteButton.getInputMap().put(f2,"add");
    	deleteButton.getInputMap().put(shiftF2,"add");
	    deleteButton.getInputMap().put(controlA,"add");
		deleteButton.getInputMap().put(f3,"delete");
    	deleteButton.getInputMap().put(shiftF3,"delete");
	    deleteButton.getInputMap().put(controlD,"delete");
	    deleteButton.getInputMap().put(enter,"delete");
	    
	    deleteButton.getActionMap().put("add", new AddAction());
	    deleteButton.getActionMap().put("delete", new DeleteAction());
	    
	    // Keystrokes und Action werden an das field angemeldet.
		field.getInputMap().put(f2,"add");
    	field.getInputMap().put(shiftF2,"add");
	    field.getInputMap().put(controlA,"add");
		field.getInputMap().put(f3,"delete");
    	field.getInputMap().put(shiftF3,"delete");
	    field.getInputMap().put(controlD,"delete");
	    
	    field.getActionMap().put("add", new AddAction());
	    field.getActionMap().put("delete", new DeleteAction());

		// Editor soll nicht focusierbar sein
		editor.setFocusable(false);

		// Platzieren der Komponenten
		north.add(addButton);
		north.add(deleteButton);
		north.add(field);

		content.add(north, BorderLayout.NORTH);
		content.add(editor);
	}
	
	private class AddAction extends AbstractAction {
		 public void actionPerformed(ActionEvent evt) {
	                editor.append(field.getText());
	            }
	}
	private class DeleteAction extends AbstractAction {
		 public void actionPerformed(ActionEvent evt) {
	                editor.setText("");
	            }
	}
}

--- Neue Klasse ---

package javacodebook.gui.keystroke;


/**
 * @author Benjamin Rusch
 * In der Starter Klasse mit der main Methode wird das KeyStrokes-Frame 
 * erzeugt.
 */

public class Starter {

	public static void main(String[] args) {

		KeyStrokes ks =  new KeyStrokes("Aktionen über Tastenkombinationen"
				+" mit AWT");
		ks.pack();
		ks.setVisible(true);
		
		KeyStrokesSwing kss =  new KeyStrokesSwing("Aktionen über "
				+"Tastenkombinationen mit Swing");
		kss.pack();
		kss.setVisible(true);
	}
}