Adding multiple event handlers

Programming Questions

bryan.g.f..

Adding multiple event handlers

in Programming Questions • 1 month ago

Hello folks,

I have a simple keyboard input class that allows me to handle multiple simultaneous key presses:

import java.util.*;
private HashSet<Integer> keySet = new HashSet<Integer>();
public void keyPressed() {
keySet.add(keyCode);
}
public void keyReleased() {
keySet.remove(keyCode);
}
public boolean isKeyDown(int pKey) {
return keySet.contains(pKey);
}

This currently resides in a tab (thus as a static (inner) class, if I understand the environment correctly). As you can see, I'm using various key input functions such as keyPressed(). The problem is that I cannot use these functions in any other tab, since it is considered a duplicate method.

Ultimately, I'd like to be able to register multiple event handlers (and I don't want to work outside of Processing's built-in event handling, since apparently it does some fancy things such as event caching between draw calls, etc).

One solution is to wrap the tabbed file into its own class, rename the keyPressed() etc functions so that they are not overriding PApplet's built-in functions (i.e. onKeyPressed), then call those renamed functions from within the main tab's keyPressed() method - i.e.:

{inside main tab}
KeyboardInput kb = new KeyboardInput();
...
public void keyPressed(){
kb.onKeyPressed();
..other stuff..
}

But this is kinda messy, as not only do I need to keep an instance around, but I need to remember to manually hook these things in whenever I'm using this keyboard class in another project. Ideally, somewhere inside of the keyboard input class I'd like to have it register its methods as event handlers which will be automatically called by processing.

Is there any built-in way to do this?

Replies(4)

GoToLoop

Re: Adding multiple event handlers

1 month ago

This currently resides in a tab (thus as a static (inner) class,
if I understand the environment correctly.

By default, classes in Processing are nested. But they're non-static inner classes.
Unless we declare them as static. However, it doesn't go well w/ Processing's API.

One solution is to wrap the tabbed file into its own class, ...

I don't get why those internal Processing callback functions should go to specialized classes.
They work alright and is well organized by defining them in the main sketch itself.

Here's a simple example of multiple keys:
http://studio.processingtogether.com/sp/pad/export/ro.9sMuvRRTXcVG-/latest

/**
 * KeyReleased Example (v2.01)
 * by  TFGuy44 (2013/May)
 * mod GoToLoop
 *
 * http://forum.processing.org/topic/help-with-key-released
 * http://studio.processingtogether.com/sp/pad/export/ro.9sMuvRRTXcVG-/latest
 */

final static byte NUM_KEYS_DOWN = 'z' - 'a' + 1;
final static boolean[] keysDown = new boolean[NUM_KEYS_DOWN];

final static byte  GAP = 15, BOLD = 2;
final static color BG = #4080A0, FG = #F0F040;

void setup() {
  size(NUM_KEYS_DOWN*GAP - GAP + BOLD*2, 150, JAVA2D);
  noLoop();

  stroke(FG);
  strokeWeight(BOLD);
}

void draw() {
  background(BG);

  for (int i = 0; i != NUM_KEYS_DOWN; ++i)
    if (keysDown[i])   line(i*GAP + BOLD, 0, i*GAP + BOLD, height);
}

void keyPressed() {
  setKeysDown(keyCode, true);
  redraw();
}

void keyReleased() {
  setKeysDown(keyCode, false);
  redraw();
}

final static void setKeysDown(int k, boolean bool) {
  if (k >= 'A' & k <= 'Z')   keysDown[k - 'A'] = bool;
}

bryan.g.f..

Re: Adding multiple event handlers

1 month ago

By default, classes in Processing are nested. But they're non-static inner classes.
Unless we declare them as static. However, it doesn't go well w/ Processing's API.

Thanks for the clarification.

I'm just trying to minimize the size of my primary tab as much as possible. I've ended up doing the following, which isn't ideal, but certainly cleans up my code:

Main Tab:

KeyDownCache keyboard = new KeyDownCache();
MouseDownCache mouse = new MouseDownCache();
public void keyPressed() {
keyboard.onKeyPressed(keyCode);
}
public void keyReleased(){
keyboard.onKeyReleased(keyCode);
}
void mousePressed() {
mouse.onMousePressed(mouseButton);
}
void mouseReleased() {
mouse.onMouseReleased(mouseButton);
}

KeyDownCache:

import java.util.*;
public class KeyDownCache{
private HashSet<Integer> keySet = new HashSet<Integer>();
public void onKeyPressed(int pKeyCode) {
keySet.add(pKeyCode);
}
public void onKeyReleased(int pKeyCode) {
keySet.remove(pKeyCode);
}
public boolean isKeyDown(int pKeyCode) {
return keySet.contains(pKeyCode);
}
}

MouseDownCache:

public class MouseDownCache {
private boolean mLeft, mRight, mCenter;
public void onMousePressed(int pMouseButton) {
switch(pMouseButton) {
case LEFT:
mLeft = true;
break;
case RIGHT:
mRight = true;
break;
case CENTER:
mCenter = true;
break;
}
}
public void onMouseReleased(int pMouseButton) {
switch(pMouseButton) {
case LEFT:
mLeft = false;
break;
case RIGHT:
mRight = false;
break;
case CENTER:
mCenter = false;
break;
}
}
public boolean isMouseDown(int pMouseButton) {
switch(pMouseButton) {
case LEFT:
return mLeft;
case RIGHT:
return mRight;
case CENTER:
return mCenter;
default:
return false;
}
}
}

With that, then from anywhere in my code (main tab or another tab), I can do the following:

if (keyboard.isKeyDown(VK_SHIFT)) boost = 3f;
if (keyboard.isKeyDown(VK_W)) fpCamera.moveForward(boost);
if (keyboard.isKeyDown(VK_S)) fpCamera.moveBackward(boost);
if (keyboard.isKeyDown(VK_D)) fpCamera.moveRight(boost);
if (keyboard.isKeyDown(VK_A)) fpCamera.moveLeft(boost);
if (keyboard.isKeyDown(VK_SPACE)) fpCamera.moveUp(boost);
if (keyboard.isKeyDown(VK_C)) fpCamera.moveDown(boost);
...
if (mouse.isMouseDown(RIGHT)) fpCamera.mouseLook(mouseX-pmouseX, mouseY-pmouseY);

GoToLoop

Re: Adding multiple event handlers

1 month ago

I'm just trying to minimize the size of my primary tab as much as possible.

Excellent strategy. Just remember: Tabs don't need to be classes only!
We can have tabs raging from 1 field variable to containing 1 function to multiple classes!
All they have in common is that they belong to the sketch's top-class.

Also, as you've seen in the example I posted, a boolean Array is enough to deal w/ multiple keys.
The <Delete> key's code is 127, which we can get from this l33t way -> '~' + 1.
So a new boolean['~' + 2] or new boolean[0200] is all we need to get all common keys!

bryan.g.f..

Re: Adding multiple event handlers

1 month ago

Very cool. I didn't think a HashSet would impact the performance of my sketch too much, but it's nice to see the exact range. Thanks for your answer.