com.jme3.input.event.KeyInputEvent Java Examples

public void update() {
    if (!context.isRenderable())
        return;
    
    Keyboard.poll();
    while (Keyboard.next()){
        int keyCode = Keyboard.getEventKey();
        char keyChar = Keyboard.getEventCharacter();
        boolean pressed = Keyboard.getEventKeyState();
        boolean down = Keyboard.isRepeatEvent();
        long time = Keyboard.getEventNanoseconds();
        KeyInputEvent evt = new KeyInputEvent(keyCode, keyChar, pressed, down);
        evt.setTime(time);
        listener.onKeyEvent(evt);
    }
}
 

private void onKeyEventQueued(KeyInputEvent evt, NiftyInputConsumer nic) {
    int code = evt.getKeyCode();

    if (code == KeyInput.KEY_LSHIFT || code == KeyInput.KEY_RSHIFT) {
        shiftDown = evt.isPressed();
    } else if (code == KeyInput.KEY_LCONTROL || code == KeyInput.KEY_RCONTROL) {
        ctrlDown = evt.isPressed();
    }
    
    KeyboardInputEvent keyEvt = new KeyboardInputEvent(code,
                                                       evt.getKeyChar(),
                                                       evt.isPressed(),
                                                       shiftDown,
                                                       ctrlDown);

    if (nic.processKeyboardEvent(keyEvt)){
        evt.setConsumed();
    }
}
 

public void forwardEvents(NiftyInputConsumer nic) {
    int queueSize = inputQueue.size();

    for (int i = 0; i < queueSize; i++){
        InputEvent evt = inputQueue.get(i);
        if (evt instanceof MouseMotionEvent){
            onMouseMotionEventQueued( (MouseMotionEvent)evt, nic);
        }else if (evt instanceof MouseButtonEvent){
            onMouseButtonEventQueued( (MouseButtonEvent)evt, nic);
        }else if (evt instanceof KeyInputEvent){
            onKeyEventQueued( (KeyInputEvent)evt, nic);
        }
    }

    inputQueue.clear();
}
 

@Override
public void update() {
     logger.log(Level.FINE, "InputEvent update : {0}",
            new Object[]{listener});
   if (listener != null) {
        InputEvent inputEvent;

        while ((inputEvent = inputEventQueue.poll()) != null) {
            if (inputEvent instanceof TouchEvent) {
                listener.onTouchEvent((TouchEvent)inputEvent);
            } else if (inputEvent instanceof MouseButtonEvent) {
                listener.onMouseButtonEvent((MouseButtonEvent)inputEvent);
            } else if (inputEvent instanceof MouseMotionEvent) {
                listener.onMouseMotionEvent((MouseMotionEvent)inputEvent);
            } else if (inputEvent instanceof KeyInputEvent) {
                listener.onKeyEvent((KeyInputEvent)inputEvent);
            }
        }
    }
}
 

@Override
public void update() {
    if (listener != null) {
        InputEvent inputEvent;

        while ((inputEvent = inputEventQueue.poll()) != null) {
            if (inputEvent instanceof TouchEvent) {
                listener.onTouchEvent((TouchEvent)inputEvent);
            } else if (inputEvent instanceof MouseButtonEvent) {
                listener.onMouseButtonEvent((MouseButtonEvent)inputEvent);
            } else if (inputEvent instanceof MouseMotionEvent) {
                listener.onMouseMotionEvent((MouseMotionEvent)inputEvent);
            } else if (inputEvent instanceof KeyInputEvent) {
                listener.onKeyEvent((KeyInputEvent)inputEvent);
            }
        }
    }
}
 

@Override
public void update() {
    if (!context.isRenderable())
        return;
    
    Keyboard.poll();
    while (Keyboard.next()){
        int keyCode = Keyboard.getEventKey();
        char keyChar = Keyboard.getEventCharacter();
        boolean pressed = Keyboard.getEventKeyState();
        boolean down = Keyboard.isRepeatEvent();
        long time = Keyboard.getEventNanoseconds();
        KeyInputEvent evt = new KeyInputEvent(keyCode, keyChar, pressed, down);
        evt.setTime(time);
        listener.onKeyEvent(evt);
    }
}
 

private void onKeyEvent(KeyEvent keyEvent, boolean pressed) {

        int code = convertKeyCode(keyEvent.getID());
        char keyChar = keyEvent.getKeyChar();

        final KeyInputEvent event = new KeyInputEvent(code, keyChar, pressed, false);
        event.setTime(getInputTimeNanos());

        EXECUTOR.addToExecute(new Runnable() {

          @Override
          public void run() {
            keyInputEvents.add(event);
          }
          
        });
    }
 

@Override
public void onKeyEvent( KeyInputEvent evt ) {
    ModifiedKeyInputEvent mEvt = (ModifiedKeyInputEvent)evt;
    if( mEvt.isPressed() || mEvt.isRepeating() ) {
        KeyAction key = mEvt.toKeyAction(); //new KeyAction(code, (control?KeyAction.CONTROL_DOWN:0), (shift?KeyAction.SHIFT_DOWN:0) );
        KeyActionListener handler = actionMap.get(key);
        if( handler != null ) {
            handler.keyAction(TextEntryComponent.this, key);
            evt.setConsumed();
            return;
        }

        // Making sure that no matter what, certain
        // characters never make it directly to the
        // document
        if( evt.getKeyChar() >= 32 ) {
            model.insert(evt.getKeyChar());
            evt.setConsumed();
            //resetText(); ...should be automatic now
        }
    }
}
 

protected void dispatch(KeyInputEvent evt) {
    if( !isEnabled() )
        return;
        
    // Intercept for key modifiers
    int code = evt.getKeyCode();
    if( code == KeyInput.KEY_LSHIFT || code == KeyInput.KEY_RSHIFT ) {
        setModifier(KeyModifiers.SHIFT_DOWN, evt.isPressed());
    }
    if( code == KeyInput.KEY_LCONTROL || code == KeyInput.KEY_RCONTROL ) {
        setModifier(KeyModifiers.CONTROL_DOWN, evt.isPressed());
    }        
    if( code == KeyInput.KEY_LMENU || code == KeyInput.KEY_RMENU ) {
        setModifier(KeyModifiers.ALT_DOWN, evt.isPressed());
    }        
        
    ModifiedKeyInputEvent wrapper = null;
    for( KeyListener l : keyListeners.getArray() ) {
        // Only wrap if we will actually deliver
        if( wrapper == null ) {
            wrapper = new ModifiedKeyInputEvent(evt, modifiers);
        }
        l.onKeyEvent(wrapper);
    }
}
 

@Override
public void onKeyEvent(KeyInputEvent evt) {
    if (evt.isReleased())
        return;
    if (evt.getKeyChar() == '\n' || evt.getKeyChar() == '\r') {
        txt3.setText(str.toString());
        str.setLength(0);
    } else {
        str.append(evt.getKeyChar());
    }
}
 

public void onKeyEvent(KeyInputEvent kie) {
    if (kie.isPressed()) {
        if (KeyInput.KEY_LSHIFT == kie.getKeyCode()) {
            shiftModifier = true;
        }
    } else if (kie.isReleased()) {
        if (KeyInput.KEY_LSHIFT == kie.getKeyCode()) {
            shiftModifier = false;
        }
    }
}
 

public void keyReleased(KeyEvent evt) {
    int code = convertAwtKey(evt.getKeyCode());
    KeyInputEvent keyEvent = new KeyInputEvent(code, evt.getKeyChar(), false, false);
    keyEvent.setTime(evt.getWhen());
    synchronized (eventQueue){
        eventQueue.add(keyEvent);
    }
}
 

private void onKeyEventQueued(KeyInputEvent evt) {
    if (evt.isRepeating()) {
        return; // repeat events not used for bindings
    }
    
    int hash = KeyTrigger.keyHash(evt.getKeyCode());
    invokeActions(hash, evt.isPressed());
    invokeTimedActions(hash, evt.getTime(), evt.isPressed());
}
 

public void keyPressed(KeyEvent evt) {
    int code = convertAwtKey(evt.getKeyCode());
    KeyInputEvent keyEvent = new KeyInputEvent(code, evt.getKeyChar(), true, false);
    keyEvent.setTime(evt.getWhen());
    synchronized (eventQueue){
        eventQueue.add(keyEvent);
    }
}
 

/**
 * Callback from RawInputListener. Do not use.
 */
public void onKeyEvent(KeyInputEvent evt) {
    if (!eventsPermitted) {
        throw new UnsupportedOperationException("KeyInput has raised an event at an illegal time.");
    }

    inputQueue.add(evt);
}
 

@Override
public void onKeyEvent(KeyInputEvent kie) {
    //don't forget the super call
    super.onKeyEvent(kie);
    if (kie.isPressed()) {
        if (KeyInput.KEY_LSHIFT == kie.getKeyCode()) {
            forceCameraControls = true;
        }
    } else if (kie.isReleased()) {
        if (KeyInput.KEY_LSHIFT == kie.getKeyCode()) {
            forceCameraControls = false;
        }
    }
}
 

@Override
public void onKeyEvent(KeyInputEvent kie) {
    super.onKeyEvent(kie);
    if (kie.isPressed()) {
        if (KeyInput.KEY_LSHIFT == kie.getKeyCode()) {
            forceCameraControls = true;
        }
    } else if (kie.isReleased()) {
        if (KeyInput.KEY_LSHIFT == kie.getKeyCode()) {
            forceCameraControls = false;
        }
    }
}
 

@Override
public void initialize() {
    if (!context.isRenderable()) {
        return;
    }

    glfwSetKeyCallback(context.getWindowHandle(), keyCallback = new GLFWKeyCallback() {
        @Override
        public void invoke(long window, int key, int scancode, int action, int mods) {
            scancode = GlfwKeyMap.toJmeKeyCode(key);
            if( key == GLFW_KEY_LEFT_SHIFT || key == GLFW_KEY_RIGHT_SHIFT ) {
                shift_pressed = (action == GLFW_PRESS);
            } else if( key >= 'A' && key <= 'Z' && !shift_pressed ) {
                key += 32; // make lowercase
            } else if( key >= 'a' && key <= 'z' && shift_pressed ) {
                key -= 32; // make uppercase
            }
            final KeyInputEvent evt = new KeyInputEvent(scancode, (char) key, GLFW_PRESS == action, GLFW_REPEAT == action);
            evt.setTime(getInputTimeNanos());
            keyInputEvents.add(evt);
        }
    });

    glfwSetInputMode(context.getWindowHandle(), GLFW_STICKY_KEYS, 1);

    initialized = true;
    logger.fine("Keyboard created.");
}
 

@Override
public void keyReleased(KeyEvent evt) {
    int code = convertAwtKey(evt.getKeyCode());
    
    // Check if key was already released
    if (keyStateSet.get(code)) {
        keyStateSet.clear(code);
        KeyInputEvent keyEvent = new KeyInputEvent(code, evt.getKeyChar(), false, false);
        keyEvent.setTime(evt.getWhen());
        synchronized (eventQueue){
            eventQueue.add(keyEvent);
        }                        
    }
}
 

@Override
public void keyPressed(KeyEvent evt) {
    int code = convertAwtKey(evt.getKeyCode());
    
    // Check if key was already pressed
    if (!keyStateSet.get(code)){
        keyStateSet.set(code);
        KeyInputEvent keyEvent = new KeyInputEvent(code, evt.getKeyChar(), true, false);
        keyEvent.setTime(evt.getWhen());
        synchronized (eventQueue){
            eventQueue.add(keyEvent);
        }            
    }
}
 

public void onKeyEvent(KeyInputEvent evt) {
    inputQueue.add(evt);
}
 

@Override
public void onKeyEvent(KeyInputEvent evt) {}
 

public AWTKeyInput(AWTContext context) {
    super(context);
    keyInputEvents = new LinkedList<KeyInputEvent>();
}
 

public void onKeyEvent(KeyInputEvent evt) {
}
 

public void simulateKeyEvent( KeyInputEvent event ) {
    inputSys.onKeyEvent(event);
}
 

public ModifiedKeyInputEvent( KeyInputEvent delegate, int modifiers ) {
    super(delegate.getKeyCode(), delegate.getKeyChar(), 
          delegate.isPressed(), delegate.isRepeating());
    this.delegate = delegate;
    this.modifiers = modifiers;                  
}
 

public void onKeyEvent( KeyInputEvent evt ) {
}
 

@Override
public void onKeyEvent( KeyInputEvent evt ) {
    dispatch(evt);
}
 

/**
 * Invoked on keyboard key press or release events.
 * 
 * @param evt 
 */
public void onKeyEvent(KeyInputEvent evt);
 

public void onKeyEvent( KeyInputEvent evt );