com.jme3.input.event.MouseButtonEvent Java Examples

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 onMouseButtonEvent( MouseButtonEvent evt ) {
    if( !isEnabled() ) {
        return;
    }
    if( evt.isPressed() ) {
        // Save the location for later
        clickStart.set(evt.getX(), evt.getY());
    } else if( evt.isReleased() ) {
        
        Vector2f click = new Vector2f(evt.getX(), evt.getY());
        if( click.distanceSquared(clickStart) < clickRadiusSq ) {
            processClickEvent(click, evt);
        }  
    }
}
 

@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);
            }
        }
    }
}
 

public void onMouseButtonEvent(MouseButtonEvent mbe) {
    //on a click release we request the focus for the top component
    //this allow netbeans to catch keyEvents and trigger actions according to keymapping
    if (mbe.isReleased()) {
        java.awt.EventQueue.invokeLater(new Runnable() {

            public void run() {
                SceneViewerTopComponent.findInstance().requestActive();
            }
        });
    }

}
 

private void onMouseButtonEventQueued(MouseButtonEvent evt, NiftyInputConsumer nic) {
    boolean wasPressed = pressed;
    boolean forwardToNifty = true;
    
    buttonIndex = evt.getButtonIndex();
    pressed = evt.isPressed();
    
    // Mouse button raised. End dragging
    if (wasPressed && !pressed){
        if (!niftyOwnsDragging){
            forwardToNifty = false;
        }
        isDragging = false;
        niftyOwnsDragging = false;
    }

    boolean consumed = false;
    if (forwardToNifty){
        consumed = nic.processMouseEvent(x, y, 0, buttonIndex, pressed);
        if (consumed){
            evt.setConsumed();
        }
    }
    
    // Mouse button pressed. Begin dragging
    if (!wasPressed && pressed){
        isDragging = true;
        niftyOwnsDragging = consumed;
    }
}
 

public void mousePressed(MouseEvent arg0) {
    MouseButtonEvent evt = new MouseButtonEvent(getJMEButtonIndex(arg0), true, arg0.getX(), arg0.getY());
    evt.setTime(arg0.getWhen());
    synchronized (eventQueue){
        eventQueue.add(evt);
    }
}
 

public void mouseReleased(MouseEvent arg0) {
    MouseButtonEvent evt = new MouseButtonEvent(getJMEButtonIndex(arg0), false, arg0.getX(), arg0.getY());
    evt.setTime(arg0.getWhen());
    synchronized (eventQueue){
        eventQueue.add(evt);
    }
}
 

private void onMouseButton(MouseEvent event, final boolean pressed) {

        final MouseButtonEvent mouseButtonEvent = new MouseButtonEvent(convertButton(event.getButton()), pressed, mouseX, mouseY);
        mouseButtonEvent.setTime(getInputTimeNanos());

        EXECUTOR.addToExecute(new Runnable() {

          @Override
          public void run() {
            mouseButtonEvents.add(mouseButtonEvent);
          }
          
        });
    }
 

@Override
public void mouseReleased(MouseEvent awtEvt) {
    int y = component.getHeight() - awtEvt.getY();
    MouseButtonEvent evt = new MouseButtonEvent(getJMEButtonIndex(awtEvt), false, awtEvt.getX(), y);
    evt.setTime(awtEvt.getWhen());
    synchronized (eventQueue) {
        eventQueue.add(evt);
    }
}
 

@Override
public void mousePressed(MouseEvent awtEvt) {
    // Must flip Y!
    int y = component.getHeight() - awtEvt.getY();
    MouseButtonEvent evt = new MouseButtonEvent(getJMEButtonIndex(awtEvt), true, awtEvt.getX(), y);
    evt.setTime(awtEvt.getWhen());
    synchronized (eventQueue) {
        eventQueue.add(evt);
    }
}
 

/**
 * Callback from RawInputListener. Do not use.
 */
public void onMouseButtonEvent(MouseButtonEvent evt) {
    if (!eventsPermitted) {
        throw new UnsupportedOperationException("MouseInput has raised an event at an illegal time.");
    }
    //updating cursor pos on click, so that non android touch events can properly update cursor position.
    cursorPos.set(evt.getX(), evt.getY());
    inputQueue.add(evt);
}
 

@Override
public void mouseButtonEvent( MouseButtonEvent event, Spatial target, Spatial capture ) {

    // Buttons always consume their click events
    event.setConsumed();

    // Do our own better handling of 'click' now
    //super.mouseButtonEvent(event, target, capture);
    if( !isEnabled() )
        return;                                            

    if( event.isPressed() ) {
        setPressed(event.isPressed());
    } else if( isPressed() ) {
        // Only run the up processing if we were already pressed
        // This also handles the case where we weren't enabled before
        // but are now, etc.
        
        if( target == capture ) {
            // Then we are still over the button and we should run the
            // click
            runClick();
        }
        // If we run the up without checking properly then we
        // potentially get up events with no down event.  This messes
        // up listeners that are (correctly) expecting an up for every
        // down and no ups without downs.
        // So, any time the capture is us then we will run, else not
        if( capture == Button.this ) {
            setPressed(false);
        }
    }
}
 

public void onMouseButtonEvent(MouseButtonEvent evt) {
}
 

@Override
public void onMouseButtonEvent(MouseButtonEvent evt) { }
 

private void onMouseButtonEventQueued(MouseButtonEvent evt) {
    int hash = MouseButtonTrigger.mouseButtonHash(evt.getButtonIndex());
    invokeActions(hash, evt.isPressed());
    invokeTimedActions(hash, evt.getTime(), evt.isPressed());
}
 

private void onMouseButton(final long window, final int button, final int action, final int mods) {
    final MouseButtonEvent mouseButtonEvent = new MouseButtonEvent(convertButton(button), action == GLFW_PRESS, mouseX, mouseY);
    mouseButtonEvent.setTime(getInputTimeNanos());
    mouseButtonEvents.add(mouseButtonEvent);
}
 

public void onMouseButtonEvent(MouseButtonEvent evt) {
    if (inputManager.isCursorVisible() && evt.getButtonIndex() >= 0 || evt.getButtonIndex() <= 2){
        inputQueue.add(evt);
    }
}
 

private void onMouseButton(final long window, final int button, final int action, final int mods) {
    final boolean pressed = action == GLFW_PRESS;
    final MouseButtonEvent mouseButtonEvent = new MouseButtonEvent(convertButton(button), pressed, mouseX, mouseY);
    mouseButtonEvent.setTime(getInputTimeNanos());
    mouseButtonEvents.add(mouseButtonEvent);
}
 

@Override
public void onMouseButtonEvent(MouseButtonEvent evt) {}
 

public AWTMouseInput(AWTContext context) {
    super(context);
    mouseMotionEvents = new LinkedList<MouseMotionEvent>();
    mouseButtonEvents = new LinkedList<MouseButtonEvent>();
}
 

@Override
public void onMouseButtonEvent( MouseButtonEvent evt ) {
    if( isEnabled() ) {
        dispatch(evt);
    }
}
 

protected void dispatch( MouseButtonEvent evt ) {
    if( getSession().buttonEvent(evt.getButtonIndex(), evt.getX(), evt.getY(), evt.isPressed()) ) {
        evt.setConsumed();
    }
}
 

public void onMouseButtonEvent( MouseButtonEvent evt ) {
}
 

@Override
protected void click( MouseButtonEvent event, Spatial target, Spatial capture ) {
}
 

/**
 * Invoked on mouse button events.
 * 
 * @param evt 
 */
public void onMouseButtonEvent(MouseButtonEvent evt);