I am trying to get my application to respond to keyboard input. Eventually, I would like it to register ctrl+f and initiate a search, but I started simple and tried for the space bar. The Java tutorials on using Key Bindings got me this far, but no matter what I apply the key binding to, nothing registers. In the below code, panel is a JPanel and the others are assorted swing objects which have been added to panel.
Action ctrlF = new AbstractAction() {
public void actionPerformed(ActionEvent e) {
System.out.println("Action performed");
}
};
panel.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
openStallsList.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
openStalls.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
stallScroller.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
assignLabel.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
tenantInfo.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
unitSpinner.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
buildingAddress.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
buildingLogo.getInputMap().put(KeyStroke.getKeyStroke("SPACE"),"crtlF");
What am I missing here? Does it have something to do with focus? There are a couple of assorted labels and buttons which are not included on that list. Is there any way to get panel to register all of the input from all of it's children?
Thanks
First, you need bind a KeyStroke to some kind of "key". Now personally, it's eaiser to specifiy the virtual key then using a String, as the String value can be a little temperamental, but that's me
panel.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0),"crtlF");
Next, you need to bind the "key" to an Action
panel.getActionMap().put("crtlF", ctrlF);
See How to use key bindings for more details.
The next problem you will have is the component will need to be focused before the key binding can be triggered
You could try and get the InputMap with a different focus requirement using either WHEN_ANCESTOR_OF_FOCUSED_COMPONENT or WHEN_IN_FOCUSED_WINDOW which will allow you to change the focus level required by the component in order for the key binding to be triggered.
i.e.,
int condition = JComponent.WHEN_IN_FOCUSED_WINDOW;
InputMap inputMap = panel.getInputMap(condition);
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0),"crtlF");
//... etc
Related
I have an issue where I am trying to make "player" icon move around my JFrame using keyboard controls. I have one object that I want to move around with the w, a, s, and d keys. I am using key bindings because in my research it seems that they are better suited to this task.
I have managed to attach all the desired keys to my icon, and they all call the action, the only issue is that I have no way to distinguish which button is being pressed. I was hoping this could be accomplished in some way by using the getActionCommand() on my action event. So far it hasn't worked.
Other examples that I have seen seem to have a solution to this, but they also have a lot of extra code with few comments, making it extremely difficult to determine what is actually happening. They all seem to involve multiple classes, with methods and fields. I am hoping to make this code a little less involved.
What I want to know: What is the best way to get this to work? Can I do it with key bindings? Does it need to be really complicated?
I really appreciate any help, even if it's just sources that I can use to help find an answer on my own.
Here's my existing code:
//My method that gets called by the constructor
//This is all based on a tutorial I found: ftp://ecs.csus.edu/clevengr/133/handouts/UsingJavaKeyBindings.pdf
//player is just an image icon
public static void setUpKeys() {
InputMap playerMap = player.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
KeyStroke wKey = KeyStroke.getKeyStroke('w');
KeyStroke aKey = KeyStroke.getKeyStroke('a');
KeyStroke sKey = KeyStroke.getKeyStroke('s');
KeyStroke dKey = KeyStroke.getKeyStroke('d');
KeyStroke wSprint = KeyStroke.getKeyStroke((char) ('w' + KeyEvent.SHIFT_DOWN_MASK)); //As a side note, what's the best way to get it to move faster when the shift key is held down? Not that important, but if someone happens to know, that'd be great
playerMap.put(wKey, "moveUp");
playerMap.put(aKey, "moveLeft");
playerMap.put(sKey, "moveDown");
playerMap.put(dKey, "moveRight");
playerMap.put(wSprint, "moveFast");
ActionMap playerAction = player.getActionMap();
playerAction.put("moveUp", playerMoved);
playerAction.put("moveLeft", playerMoved);
playerAction.put("moveDown", playerMoved);
playerAction.put("moveRight", playerMoved);
playerAction.put("moveFast", playerMoved);
}
And here is my playerMoved action:
static Action playerMoved = new AbstractAction() {
//This isn't important, just put it in instead of suppressing the warning
private static final long serialVersionUID = 2L;
//This doesn't do anything yet, just gives console confirmation
public void actionPerformed(ActionEvent e) {
System.out.println("Activated");
//Here's what I was talking about with the getActionCommand() not working
if (e.getActionCommand().equals("moveUp")) {
System.out.println("up");
}
}
};
If anyone needs any other parts of my code, I can provide it. I just wanted to cut it down to what I feel is important for this question
I was hoping this could be accomplished in some way by using the getActionCommand() on my action event.
You don't want to do this because you would be attempting to use the "action command" for "processing". That is not a good design as it will result in nested if/else statements.
Instead you need to create an Action that accepts parameters to control the movement. So you will need 4 separate Actions to control the movement. See the MotionWithKeyBindings example found in Motion Using the Keyboard, for a complete working example of this approach.
It demonstrates how a simple Action can be made reusable by specifying parameters for the Action. This provides far more flexibility than your current Action.
Note 1:
You use the following debug code in your Action:
System.out.println("Activated");
Instead of simply displaying a hard coded value it would be better to do something like
System.out.println( e.getActionCommand() );
In which case you should notice the value is "a, s, w, d", which is the KeyStroke you use to invoke the Action.
So this would mean the if statement should be testing for either of the above characters, not the String "moveUp" which is the String used to identify the Action in the ActionMap.
However, as mentioned above, this is not the solution you should be using, I just wanted to better explain how the "action command" is determined.
Note 2:
The only time you might want to use a single Action and the getActionCommand() method is when you want to use the "action command" as "data" for the Action.
For an example of this approach check out: how to put actionlistenerand actioncommand to multiple jbuttons. It is an example of a simple numeric entry panel where the number key pressed is added to a text field. So therefore the key character becomes the data for the text field and no special processing is required.
What is the closest equivalent of Java's KeyBindings in C#? I am attempting to port a Swing application to C#, but it is unclear which method I should use.
Here is a sample of the Java I am porting:
Action goUp = new AbstractAction() {
#Override
public void actionPerformed(ActionEvent e) {
panel.upPressed = true;
}
};
Action stopUp = new AbstractAction() {
#Override
public void actionPerformed(ActionEvent e) {
panel.upPressed = false;
}
};
InputMap getInputMap = panel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
getInputMap.put(KeyStroke.getKeyStroke("W"), "goUp");
getInputMap.put(KeyStroke.getKeyStroke("released W"), "stopUp");
panel.getActionMap().put("goUp", goUp);
panel.getActionMap().put("stopUp", stopUp);
In Winforms, I am not aware of anything that is exactly like InputMap. Keyboard input is usually handled in one of two ways:
Shortcut keys, i.e. MenuItem.Shortcut. This is assignable in the Designer, or in code. Pressing the associated key will invoke the menu item's Click event handler(s). Of course, to use this method requires that the action you want to take is represented in the UI as a menu item.
Various key event handling in the UI. This can get fairly complicated depending on your needs, but is often the most appropriate way, and is the primary way to handle key input not associated with a menu item. The simplest event is the KeyPress event. Given your example, you probably want to handle KeyDown and KeyUp so that you can track the actual state of the key. Note that you will receive multiple KeyDown events as the auto-repeat kicks in for a key; if this would be a problem for your handler, you'll need to track the key state and for a key for which you've already seen KeyDown, only handle the KeyDown event if you've seen the corresponding KeyUp event.
Note that WPF does have a key binding model that is more similar to InputMap. Of course, the syntax is entirely different, but it breaks apart the idea of the menu items, commands, and key bindings, so you can mix and match as necessary (and in particular, have key bindings that don't correspond to any menu item). So if using WPF is an option, you might find that part of the transition easier (and probably only that part, since Swing is otherwise much more like Winforms than WPF :) ).
I asked this question a little earlier, but maybe some of you were asleep, as where I live at the time it was probably very early in silicon valley.
My program has assigned new functions to the arrow keys, but for the very last part of the Swing display's presentation I need them to function normally within a TextArea, moing the cursor and such.
Is there a way to restore to defaults, or through an AbstractAction assign simple movement of the cursor once again?
The original answer I gave you showed how to replace the Action. If you need to restore the default Action then it is probably easier to create a new InputMap and ActionMap entry for the Action. The Key Bindings link I gave you shows how to do this.
Then when you need to restore the default Action you can use:
textField.getInputMap().put(keystroke, "none");
This will cause the original InputMap to be search again.
Another approach it to save the Action before you update the ActionMap with the custom Action. Something like:
Action original = textField.getActionMap().get(...);
Reread the Key Bindings link to better understand the usage of the InputMap and ActionMap.
So far I've got ESC key to close the window, using the following code:
KeyStroke escapeKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0, false);
Action escapeAction = new AbstractAction() {
public void actionPerformed(ActionEvent e) {
screen.dispose();
}
};
screen.getRootPane().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(escapeKeyStroke, "ESCAPE");
screen.getRootPane().getActionMap().put("ESCAPE", escapeAction);
But I am wondering how I would go about adding a CTRL+A event? I remember reading about a way where you set booleans for keypressed/released, but I don't see that working with this piece of code, so I am wondering how I can implement CTRL+A.
Thank You
It's the second parameter of the KeyStroke.getKeyStroke(...) method that matters, as you'll want to use the InputEvent.CTRL_DOWN_MASK there to let the KeyEvent.VK_A be a control-A.
e.g.,
KeyStroke ctrlAKeyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_A,
InputEvent.CTRL_DOWN_MASK);
I wouldn't worry about using the 3 parameter method that uses a boolean since you're more interested in key press, not key down or key release.
Regarding your comment:
Correction to my earlier comment. It works, if I make it let's say Ctrl+W. Ctrl+A just attempts to do its native "select all" function in a textfield in the frame. Any way to avoid that?
From the little I understand, this will be a problem if the component that has focus (such as a JTextArea) responds directly to the ctrl-A key press. To get around this, you can add the same binding to this component, but being sure to bind it to its InputMap that uses the JComponent.WHEN_FOCUSED; condition.
I am new to Java and am in the process of making a GUI of CLI application of Poker Game. It requires "Enter Key" to continue. I have tried to find out if there is some Event Handler for "Enter Key" so that I could change that Event to Mouse Button. But unfortunately I could not find any such thing. Now I have thought of passing carriage return to Java Console onClick Event. I have tried:
ContinueBtn = new JButton();
ContinueBtn.addMouseListener(this);
.
.
.
public void mouseReleased(MouseEvent e) {
System.out.println("\r\n");
//OR
char c = (char) KeyEvent.VK_ENTER;
System.out.println(c)
//OR
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
out.write("\r\n");
out.newLine();
out.flush();
//OR
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
out.write((char)10); /*OR*/ out.write((char)13);
}
It is still not working. Can anyone suggest what should I do?
Add proper Action or ActionListener, then implements KeyBindings, output form
KeyBindings should be javax.swing.Action, inside this Action call
myButton.doClick()
that invoke Action or ActionListener added to the JButton
For 'Enter' on JButtons, you probably want to use JRootPane.setDefaultButton(). Both JWindow and JDialog have a getRootPane() method.
The only trick is that the window / dialog has to be visible already to set the default button. I usually just override setVisible() in the windows that need a default button:
public void setVisible(boolean b) {
if (b) {
getRootPane().setDefaultButton(button);
}
super.setVisible(b);
}
I am not clear about your question, but from what i understand about your situation this might help.
(anything like a button)ActionPerformed(java.awt.event.ActionEvent evt)
Key bindings in Swing are handled with InputMaps and ActionMaps.
Sun has a nice tutorial on the key binding API. The tutorial has this to say:
An alternative to key bindings is using key listeners. Key listeners
have their place as a low-level interface to keyboard input, but for
responding to individual keys key bindings are more appropriate and
tend to result in more easily maintained code. Key listeners are also
difficult if the key binding is to be active when the component
doesn't have focus. Some of the advantages of key bindings are they're
somewhat self documenting, take the containment hierarchy into
account, encourage reusable chunks of code (Action objects), and allow
actions to be easily removed, customized, or shared. Also, they make
it easy to change the key to which an action is bound. Another
advantage of Actions is that they have an enabled state which provides
an easy way to disable the action without having to track which
component it is attached to.
java.awt.event.KeyListener (KeyListener Tutorial).