Class Name

KeyEvent

Description

A KeyEvent object contains information about a keyboard event that has occurred. This object is automatically passed to the keyboard event functions (keyPressed(), keyReleased(), and keyTyped()) when they are called with an event parameter.

The KeyEvent object provides additional information beyond what's available in the global keyboard variables (key and keyCode). For most basic keyboard interactions, using the global variables is sufficient and more convenient. However, the KeyEvent object is useful when you need more detailed information about the keyboard event, such as modifier keys that were held down or the raw key codes.

For Java programmers: This is Processing's interface to Java's KeyEvent class. You can access the underlying Java KeyEvent using event.getNative(). The key constants (like UP, DOWN) are simplified versions of Java's KeyEvent constants (like KeyEvent.VK_UPKeyEvent.VK_DOWN).

Examples

  • String message = "";
    boolean capsLock = false;
    
    void setup() {
      size(600, 300);
      background(220);
    }
    
    void draw() {
      background(220);
      
      // Instructions
      fill(0);
      textAlign(CENTER);
      textSize(14);
      text("Type with different modifier keys held down", width/2, 30);
      text("Try Shift, Ctrl, Alt, and special keys like arrows", width/2, 50);
      
      // Display current message
      textAlign(LEFT);
      textSize(16);
      text("Message: " + message, 20, 100);
      
      // Status
      textSize(12);
      text("Caps Lock: " + (capsLock ? "ON" : "OFF"), 20, 130);
    }
    
    void keyPressed(KeyEvent event) {
      char keyChar = event.getKey();
      int keyCode = event.getKeyCode();
      
      // Check modifier keys
      boolean shiftDown = event.isShiftDown();
      boolean ctrlDown = event.isControlDown();
      boolean altDown = event.isAltDown();
      boolean metaDown = event.isMetaDown();
      
      // Print detailed key information
      println("Key pressed: '" + keyChar + "' (code: " + keyCode + ")");
      println("Modifiers - Shift: " + shiftDown + ", Ctrl: " + ctrlDown + 
              ", Alt: " + altDown + ", Meta: " + metaDown);
      
      // Handle special keys
      if (keyCode == UP) {
        message = message.toUpperCase();
        println("Converted to uppercase");
      } else if (keyCode == DOWN) {
        message = message.toLowerCase();
        println("Converted to lowercase");
      } else if (keyCode == BACKSPACE && message.length() > 0) {
        message = message.substring(0, message.length()-1);
      } else if (keyCode == ENTER) {
        println("Message completed: " + message);
        message = "";
      } else if (keyCode == TAB) {
        message += "    "; // Add tab spacing
      } else if (keyChar >= 32 && keyChar <= 126) { // Printable characters
        // Handle modifier combinations
        if (ctrlDown && keyChar == 'c') {
          println("Copy command detected");
        } else if (ctrlDown && keyChar == 'v') {
          println("Paste command detected");
        } else if (ctrlDown && keyChar == 'z') {
          println("Undo command detected");
          if (message.length() > 0) {
            message = message.substring(0, message.length()-1);
          }
        } else if (!ctrlDown) { // Don't add text for Ctrl combinations
          if (shiftDown && altDown) {
            message += "[" + keyChar + "]"; // Special formatting
          } else {
            message += keyChar;
          }
        }
      }
      
      // Check for caps lock toggle (simplified detection)
      if (keyCode == 20) { // CAPS_LOCK key code
        capsLock = !capsLock;
      }
    }
    
  • ArrayList<String> keyLog = new ArrayList<String>();
    int maxLogEntries = 15;
    
    void setup() {
      size(500, 400);
      background(240);
    }
    
    void draw() {
      background(240);
      
      // Title
      fill(0);
      textAlign(CENTER);
      textSize(16);
      text("Keyboard Event Logger", width/2, 25);
      
      // Instructions
      textSize(12);
      text("Press any keys to see detailed event information", width/2, 45);
      
      // Draw log entries
      textAlign(LEFT);
      textSize(11);
      for (int i = 0; i < keyLog.size(); i++) {
        fill(0, 200);
        text(keyLog.get(i), 10, 80 + i * 15);
      }
      
      // Draw border around log area
      noFill();
      stroke(100);
      rect(5, 60, width-10, height-70);
    }
    
    void keyPressed(KeyEvent event) {
      logKeyEvent("PRESSED", event);
    }
    
    void keyReleased(KeyEvent event) {
      logKeyEvent("RELEASED", event);
    }
    
    void keyTyped(KeyEvent event) {
      logKeyEvent("TYPED", event);
    }
    
    void logKeyEvent(String type, KeyEvent event) {
      char keyChar = event.getKey();
      int keyCode = event.getKeyCode();
      
      // Build modifier string
      String modifiers = "";
      if (event.isShiftDown()) modifiers += "Shift+";
      if (event.isControlDown()) modifiers += "Ctrl+";
      if (event.isAltDown()) modifiers += "Alt+";
      if (event.isMetaDown()) modifiers += "Meta+";
      
      // Create readable key name
      String keyName;
      if (keyCode == UP) keyName = "UP";
      else if (keyCode == DOWN) keyName = "DOWN";
      else if (keyCode == LEFT) keyName = "LEFT";
      else if (keyCode == RIGHT) keyName = "RIGHT";
      else if (keyCode == ENTER) keyName = "ENTER";
      else if (keyCode == TAB) keyName = "TAB";
      else if (keyCode == BACKSPACE) keyName = "BACKSPACE";
      else if (keyCode == DELETE) keyName = "DELETE";
      else if (keyCode == ESC) keyName = "ESC";
      else if (keyChar >= 32 && keyChar <= 126) keyName = "'" + keyChar + "'";
      else keyName = "code:" + keyCode;
      
      // Format log entry
      String logEntry = type + " " + modifiers + keyName;
      if (event.isAutoRepeat()) {
        logEntry += " (auto-repeat)";
      }
      
      // Add to log
      keyLog.add(logEntry);
      
      // Keep log size manageable
      while (keyLog.size() > maxLogEntries) {
        keyLog.remove(0);
      }
      
      // Also print to console for debugging
      println(logEntry);
    }
    

Methods

  • getKey()Returns the character that was typed (same as global 'key' variable)
  • getKeyCode()Returns the key code for special keys (same as global 'keyCode' variable)
  • isShiftDown()Returns true if the Shift key was held down during the event
  • isControlDown()Returns true if the Control key was held down during the event
  • isAltDown()Returns true if the Alt key was held down during the event
  • isMetaDown()Returns true if the Meta/Cmd key was held down during the event
  • isAutoRepeat()Returns true if this event was generated by key auto‑repeat
  • getNative()Returns the underlying Java KeyEvent object