sigonasr2
/
jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Mouse and input support for NEWT canvas and display

Browse Source 
git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@9944 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
3.0
jul..om 12 years ago
parent c9c1ae1cae
commit 54c7447efa
5 changed files with 904 additions and 12 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 605
      engine/src/jogl/com/jme3/input/jogl/NewtKeyInput.java
  2. 286
      engine/src/jogl/com/jme3/input/jogl/NewtMouseInput.java
  3. 16
      engine/src/jogl/com/jme3/system/jogl/JoglAbstractDisplay.java
  4. 6
      engine/src/jogl/com/jme3/system/jogl/JoglContext.java
  5. 3
      engine/src/jogl/com/jme3/system/jogl/JoglNewtDisplay.java

605
engine/src/jogl/com/jme3/input/jogl/NewtKeyInput.java
Unescape View File

@ -0,0 +1,605 @@
/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.input.jogl;
import com.jme3.input.KeyInput;
import com.jme3.input.RawInputListener;
import com.jme3.input.event.KeyInputEvent;
import com.jogamp.newt.event.KeyEvent;
import com.jogamp.newt.event.KeyListener;
import com.jogamp.newt.opengl.GLWindow;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.logging.Level;
import java.util.logging.Logger;
public class NewtKeyInput implements KeyInput, KeyListener {
private static final Logger logger = Logger.getLogger(NewtKeyInput.class.getName());
private final ArrayList<KeyInputEvent> eventQueue = new ArrayList<KeyInputEvent>();
private RawInputListener listener;
private GLWindow component;
private BitSet keyStateSet = new BitSet(0xFF);
public NewtKeyInput() {
}
public void initialize() {
}
public void destroy() {
}
public void setInputSource(GLWindow comp){
synchronized (eventQueue){
if (component != null){
component.removeKeyListener(this);
eventQueue.clear();
keyStateSet.clear();
}
component = comp;
component.addKeyListener(this);
}
}
public long getInputTimeNanos() {
return System.nanoTime();
}
public void update() {
synchronized (eventQueue){
// flush events to listener
for (int i = 0; i < eventQueue.size(); i++){
listener.onKeyEvent(eventQueue.get(i));
}
eventQueue.clear();
}
}
public boolean isInitialized() {
return true;
}
public void setInputListener(RawInputListener listener) {
this.listener = listener;
}
public void keyTyped(KeyEvent evt) {
// key code is zero for typed events
}
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);
}
System.out.println(evt);
}
}
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);
}
System.out.println(evt);
}
}
/**
* <code>convertJmeCode</code> converts KeyInput key codes to AWT key codes.
*
* @param key jme KeyInput key code
* @return awt KeyEvent key code
*/
public static int convertJmeCode( int key ) {
switch ( key ) {
case KEY_ESCAPE:
return KeyEvent.VK_ESCAPE;
case KEY_1:
return KeyEvent.VK_1;
case KEY_2:
return KeyEvent.VK_2;
case KEY_3:
return KeyEvent.VK_3;
case KEY_4:
return KeyEvent.VK_4;
case KEY_5:
return KeyEvent.VK_5;
case KEY_6:
return KeyEvent.VK_6;
case KEY_7:
return KeyEvent.VK_7;
case KEY_8:
return KeyEvent.VK_8;
case KEY_9:
return KeyEvent.VK_9;
case KEY_0:
return KeyEvent.VK_0;
case KEY_MINUS:
return KeyEvent.VK_MINUS;
case KEY_EQUALS:
return KeyEvent.VK_EQUALS;
case KEY_BACK:
return KeyEvent.VK_BACK_SPACE;
case KEY_TAB:
return KeyEvent.VK_TAB;
case KEY_Q:
return KeyEvent.VK_Q;
case KEY_W:
return KeyEvent.VK_W;
case KEY_E:
return KeyEvent.VK_E;
case KEY_R:
return KeyEvent.VK_R;
case KEY_T:
return KeyEvent.VK_T;
case KEY_Y:
return KeyEvent.VK_Y;
case KEY_U:
return KeyEvent.VK_U;
case KEY_I:
return KeyEvent.VK_I;
case KEY_O:
return KeyEvent.VK_O;
case KEY_P:
return KeyEvent.VK_P;
case KEY_LBRACKET:
return KeyEvent.VK_OPEN_BRACKET;
case KEY_RBRACKET:
return KeyEvent.VK_CLOSE_BRACKET;
case KEY_RETURN:
return KeyEvent.VK_ENTER;
case KEY_LCONTROL:
return KeyEvent.VK_CONTROL;
case KEY_A:
return KeyEvent.VK_A;
case KEY_S:
return KeyEvent.VK_S;
case KEY_D:
return KeyEvent.VK_D;
case KEY_F:
return KeyEvent.VK_F;
case KEY_G:
return KeyEvent.VK_G;
case KEY_H:
return KeyEvent.VK_H;
case KEY_J:
return KeyEvent.VK_J;
case KEY_K:
return KeyEvent.VK_K;
case KEY_L:
return KeyEvent.VK_L;
case KEY_SEMICOLON:
return KeyEvent.VK_SEMICOLON;
case KEY_APOSTROPHE:
return KeyEvent.VK_QUOTE;
case KEY_GRAVE:
return KeyEvent.VK_DEAD_GRAVE;
case KEY_LSHIFT:
return KeyEvent.VK_SHIFT;
case KEY_BACKSLASH:
return KeyEvent.VK_BACK_SLASH;
case KEY_Z:
return KeyEvent.VK_Z;
case KEY_X:
return KeyEvent.VK_X;
case KEY_C:
return KeyEvent.VK_C;
case KEY_V:
return KeyEvent.VK_V;
case KEY_B:
return KeyEvent.VK_B;
case KEY_N:
return KeyEvent.VK_N;
case KEY_M:
return KeyEvent.VK_M;
case KEY_COMMA:
return KeyEvent.VK_COMMA;
case KEY_PERIOD:
return KeyEvent.VK_PERIOD;
case KEY_SLASH:
return KeyEvent.VK_SLASH;
case KEY_RSHIFT:
return KeyEvent.VK_SHIFT;
case KEY_MULTIPLY:
return KeyEvent.VK_MULTIPLY;
case KEY_SPACE:
return KeyEvent.VK_SPACE;
case KEY_CAPITAL:
return KeyEvent.VK_CAPS_LOCK;
case KEY_F1:
return KeyEvent.VK_F1;
case KEY_F2:
return KeyEvent.VK_F2;
case KEY_F3:
return KeyEvent.VK_F3;
case KEY_F4:
return KeyEvent.VK_F4;
case KEY_F5:
return KeyEvent.VK_F5;
case KEY_F6:
return KeyEvent.VK_F6;
case KEY_F7:
return KeyEvent.VK_F7;
case KEY_F8:
return KeyEvent.VK_F8;
case KEY_F9:
return KeyEvent.VK_F9;
case KEY_F10:
return KeyEvent.VK_F10;
case KEY_NUMLOCK:
return KeyEvent.VK_NUM_LOCK;
case KEY_SCROLL:
return KeyEvent.VK_SCROLL_LOCK;
case KEY_NUMPAD7:
return KeyEvent.VK_NUMPAD7;
case KEY_NUMPAD8:
return KeyEvent.VK_NUMPAD8;
case KEY_NUMPAD9:
return KeyEvent.VK_NUMPAD9;
case KEY_SUBTRACT:
return KeyEvent.VK_SUBTRACT;
case KEY_NUMPAD4:
return KeyEvent.VK_NUMPAD4;
case KEY_NUMPAD5:
return KeyEvent.VK_NUMPAD5;
case KEY_NUMPAD6:
return KeyEvent.VK_NUMPAD6;
case KEY_ADD:
return KeyEvent.VK_ADD;
case KEY_NUMPAD1:
return KeyEvent.VK_NUMPAD1;
case KEY_NUMPAD2:
return KeyEvent.VK_NUMPAD2;
case KEY_NUMPAD3:
return KeyEvent.VK_NUMPAD3;
case KEY_NUMPAD0:
return KeyEvent.VK_NUMPAD0;
case KEY_DECIMAL:
return KeyEvent.VK_DECIMAL;
case KEY_F11:
return KeyEvent.VK_F11;
case KEY_F12:
return KeyEvent.VK_F12;
case KEY_F13:
return KeyEvent.VK_F13;
case KEY_F14:
return KeyEvent.VK_F14;
case KEY_F15:
return KeyEvent.VK_F15;
case KEY_KANA:
return KeyEvent.VK_KANA;
case KEY_CONVERT:
return KeyEvent.VK_CONVERT;
case KEY_NOCONVERT:
return KeyEvent.VK_NONCONVERT;
case KEY_NUMPADEQUALS:
return KeyEvent.VK_EQUALS;
case KEY_CIRCUMFLEX:
return KeyEvent.VK_CIRCUMFLEX;
case KEY_AT:
return KeyEvent.VK_AT;
case KEY_COLON:
return KeyEvent.VK_COLON;
case KEY_UNDERLINE:
return KeyEvent.VK_UNDERSCORE;
case KEY_STOP:
return KeyEvent.VK_STOP;
case KEY_NUMPADENTER:
return KeyEvent.VK_ENTER;
case KEY_RCONTROL:
return KeyEvent.VK_CONTROL;
case KEY_NUMPADCOMMA:
return KeyEvent.VK_COMMA;
case KEY_DIVIDE:
return KeyEvent.VK_DIVIDE;
case KEY_PAUSE:
return KeyEvent.VK_PAUSE;
case KEY_HOME:
return KeyEvent.VK_HOME;
case KEY_UP:
return KeyEvent.VK_UP;
case KEY_PRIOR:
return KeyEvent.VK_PAGE_UP;
case KEY_LEFT:
return KeyEvent.VK_LEFT;
case KEY_RIGHT:
return KeyEvent.VK_RIGHT;
case KEY_END:
return KeyEvent.VK_END;
case KEY_DOWN:
return KeyEvent.VK_DOWN;
case KEY_NEXT:
return KeyEvent.VK_PAGE_DOWN;
case KEY_INSERT:
return KeyEvent.VK_INSERT;
case KEY_DELETE:
return KeyEvent.VK_DELETE;
case KEY_LMENU:
return KeyEvent.VK_ALT; //todo: location left
case KEY_RMENU:
return KeyEvent.VK_ALT; //todo: location right
}
logger.log(Level.WARNING, "unsupported key:{0}", key);
return 0x10000 + key;
}
/**
* <code>convertAwtKey</code> converts AWT key codes to KeyInput key codes.
*
* @param key awt KeyEvent key code
* @return jme KeyInput key code
*/
public static int convertAwtKey(int key) {
switch ( key ) {
case KeyEvent.VK_ESCAPE:
return KEY_ESCAPE;
case KeyEvent.VK_1:
return KEY_1;
case KeyEvent.VK_2:
return KEY_2;
case KeyEvent.VK_3:
return KEY_3;
case KeyEvent.VK_4:
return KEY_4;
case KeyEvent.VK_5:
return KEY_5;
case KeyEvent.VK_6:
return KEY_6;
case KeyEvent.VK_7:
return KEY_7;
case KeyEvent.VK_8:
return KEY_8;
case KeyEvent.VK_9:
return KEY_9;
case KeyEvent.VK_0:
return KEY_0;
case KeyEvent.VK_MINUS:
return KEY_MINUS;
case KeyEvent.VK_EQUALS:
return KEY_EQUALS;
case KeyEvent.VK_BACK_SPACE:
return KEY_BACK;
case KeyEvent.VK_TAB:
return KEY_TAB;
case KeyEvent.VK_Q:
return KEY_Q;
case KeyEvent.VK_W:
return KEY_W;
case KeyEvent.VK_E:
return KEY_E;
case KeyEvent.VK_R:
return KEY_R;
case KeyEvent.VK_T:
return KEY_T;
case KeyEvent.VK_Y:
return KEY_Y;
case KeyEvent.VK_U:
return KEY_U;
case KeyEvent.VK_I:
return KEY_I;
case KeyEvent.VK_O:
return KEY_O;
case KeyEvent.VK_P:
return KEY_P;
case KeyEvent.VK_OPEN_BRACKET:
return KEY_LBRACKET;
case KeyEvent.VK_CLOSE_BRACKET:
return KEY_RBRACKET;
case KeyEvent.VK_ENTER:
return KEY_RETURN;
case KeyEvent.VK_CONTROL:
return KEY_LCONTROL;
case KeyEvent.VK_A:
return KEY_A;
case KeyEvent.VK_S:
return KEY_S;
case KeyEvent.VK_D:
return KEY_D;
case KeyEvent.VK_F:
return KEY_F;
case KeyEvent.VK_G:
return KEY_G;
case KeyEvent.VK_H:
return KEY_H;
case KeyEvent.VK_J:
return KEY_J;
case KeyEvent.VK_K:
return KEY_K;
case KeyEvent.VK_L:
return KEY_L;
case KeyEvent.VK_SEMICOLON:
return KEY_SEMICOLON;
case KeyEvent.VK_QUOTE:
return KEY_APOSTROPHE;
case KeyEvent.VK_DEAD_GRAVE:
return KEY_GRAVE;
case KeyEvent.VK_SHIFT:
return KEY_LSHIFT;
case KeyEvent.VK_BACK_SLASH:
return KEY_BACKSLASH;
case KeyEvent.VK_Z:
return KEY_Z;
case KeyEvent.VK_X:
return KEY_X;
case KeyEvent.VK_C:
return KEY_C;
case KeyEvent.VK_V:
return KEY_V;
case KeyEvent.VK_B:
return KEY_B;
case KeyEvent.VK_N:
return KEY_N;
case KeyEvent.VK_M:
return KEY_M;
case KeyEvent.VK_COMMA:
return KEY_COMMA;
case KeyEvent.VK_PERIOD:
return KEY_PERIOD;
case KeyEvent.VK_SLASH:
return KEY_SLASH;
case KeyEvent.VK_MULTIPLY:
return KEY_MULTIPLY;
case KeyEvent.VK_SPACE:
return KEY_SPACE;
case KeyEvent.VK_CAPS_LOCK:
return KEY_CAPITAL;
case KeyEvent.VK_F1:
return KEY_F1;
case KeyEvent.VK_F2:
return KEY_F2;
case KeyEvent.VK_F3:
return KEY_F3;
case KeyEvent.VK_F4:
return KEY_F4;
case KeyEvent.VK_F5:
return KEY_F5;
case KeyEvent.VK_F6:
return KEY_F6;
case KeyEvent.VK_F7:
return KEY_F7;
case KeyEvent.VK_F8:
return KEY_F8;
case KeyEvent.VK_F9:
return KEY_F9;
case KeyEvent.VK_F10:
return KEY_F10;
case KeyEvent.VK_NUM_LOCK:
return KEY_NUMLOCK;
case KeyEvent.VK_SCROLL_LOCK:
return KEY_SCROLL;
case KeyEvent.VK_NUMPAD7:
return KEY_NUMPAD7;
case KeyEvent.VK_NUMPAD8:
return KEY_NUMPAD8;
case KeyEvent.VK_NUMPAD9:
return KEY_NUMPAD9;
case KeyEvent.VK_SUBTRACT:
return KEY_SUBTRACT;
case KeyEvent.VK_NUMPAD4:
return KEY_NUMPAD4;
case KeyEvent.VK_NUMPAD5:
return KEY_NUMPAD5;
case KeyEvent.VK_NUMPAD6:
return KEY_NUMPAD6;
case KeyEvent.VK_ADD:
return KEY_ADD;
case KeyEvent.VK_NUMPAD1:
return KEY_NUMPAD1;
case KeyEvent.VK_NUMPAD2:
return KEY_NUMPAD2;
case KeyEvent.VK_NUMPAD3:
return KEY_NUMPAD3;
case KeyEvent.VK_NUMPAD0:
return KEY_NUMPAD0;
case KeyEvent.VK_DECIMAL:
return KEY_DECIMAL;
case KeyEvent.VK_F11:
return KEY_F11;
case KeyEvent.VK_F12:
return KEY_F12;
case KeyEvent.VK_F13:
return KEY_F13;
case KeyEvent.VK_F14:
return KEY_F14;
case KeyEvent.VK_F15:
return KEY_F15;
case KeyEvent.VK_KANA:
return KEY_KANA;
case KeyEvent.VK_CONVERT:
return KEY_CONVERT;
case KeyEvent.VK_NONCONVERT:
return KEY_NOCONVERT;
case KeyEvent.VK_CIRCUMFLEX:
return KEY_CIRCUMFLEX;
case KeyEvent.VK_AT:
return KEY_AT;
case KeyEvent.VK_COLON:
return KEY_COLON;
case KeyEvent.VK_UNDERSCORE:
return KEY_UNDERLINE;
case KeyEvent.VK_STOP:
return KEY_STOP;
case KeyEvent.VK_DIVIDE:
return KEY_DIVIDE;
case KeyEvent.VK_PAUSE:
return KEY_PAUSE;
case KeyEvent.VK_HOME:
return KEY_HOME;
case KeyEvent.VK_UP:
return KEY_UP;
case KeyEvent.VK_PAGE_UP:
return KEY_PRIOR;
case KeyEvent.VK_LEFT:
return KEY_LEFT;
case KeyEvent.VK_RIGHT:
return KEY_RIGHT;
case KeyEvent.VK_END:
return KEY_END;
case KeyEvent.VK_DOWN:
return KEY_DOWN;
case KeyEvent.VK_PAGE_DOWN:
return KEY_NEXT;
case KeyEvent.VK_INSERT:
return KEY_INSERT;
case KeyEvent.VK_DELETE:
return KEY_DELETE;
case KeyEvent.VK_ALT:
return KEY_LMENU; //Left vs. Right need to improve
case KeyEvent.VK_META:
return KEY_RCONTROL;
}
logger.log( Level.WARNING, "unsupported key:{0}", key);
if ( key >= 0x10000 ) {
return key - 0x10000;
}
return 0;
}
}

286
engine/src/jogl/com/jme3/input/jogl/NewtMouseInput.java
Unescape View File

@ -0,0 +1,286 @@
/*
* Copyright (c) 2009-2012 jMonkeyEngine
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.input.jogl;
import com.jme3.cursors.plugins.JmeCursor;
import com.jme3.input.MouseInput;
import com.jme3.input.RawInputListener;
import com.jme3.input.awt.AwtMouseInput;
import com.jme3.input.event.MouseButtonEvent;
import com.jme3.input.event.MouseMotionEvent;
import com.jogamp.newt.event.MouseEvent;
import com.jogamp.newt.event.MouseListener;
import com.jogamp.newt.opengl.GLWindow;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.media.nativewindow.util.Point;
public class NewtMouseInput implements MouseInput, MouseListener {
public static int WHEEL_AMP = 40; // arbitrary... Java's mouse wheel seems to report something a lot lower than lwjgl's
private static final Logger logger = Logger.getLogger(AwtMouseInput.class.getName());
private boolean visible = true;
private RawInputListener listener;
private GLWindow component;
private final ArrayList<MouseButtonEvent> eventQueue = new ArrayList<MouseButtonEvent>();
private final ArrayList<MouseButtonEvent> eventQueueCopy = new ArrayList<MouseButtonEvent>();
private int lastEventX;
private int lastEventY;
private int lastEventWheel;
private int wheelPos;
private Point location;
private Point centerLocation;
private Point centerLocationOnScreen;
private Point lastKnownLocation;
private boolean isRecentering;
private boolean cursorMoved;
private int eventsSinceRecenter;
public NewtMouseInput() {
location = new Point();
centerLocation = new Point();
centerLocationOnScreen = new Point();
lastKnownLocation = new Point();
}
public void setInputSource(GLWindow comp) {
if (component != null) {
component.removeMouseListener(this);
eventQueue.clear();
wheelPos = 0;
isRecentering = false;
eventsSinceRecenter = 0;
lastEventX = 0;
lastEventY = 0;
lastEventWheel = 0;
location = new Point();
centerLocation = new Point();
centerLocationOnScreen = new Point();
lastKnownLocation = new Point();
}
component = comp;
component.addMouseListener(this);
}
public void initialize() {
}
public void destroy() {
}
public boolean isInitialized() {
return true;
}
public void setInputListener(RawInputListener listener) {
this.listener = listener;
}
public long getInputTimeNanos() {
return System.nanoTime();
}
public void setCursorVisible(boolean visible) {
if (this.visible != visible) {
lastKnownLocation.setX(0);
lastKnownLocation.setY(0);
this.visible = visible;
component.setPointerVisible(visible);
if (!visible) {
recenterMouse(component);
}
}
}
public void update() {
if (cursorMoved) {
int newX = location.getX();
int newY = location.getY();
int newWheel = wheelPos;
// invert DY
int actualX = lastKnownLocation.getX();
int actualY = component.getHeight() - lastKnownLocation.getY();
MouseMotionEvent evt = new MouseMotionEvent(actualX, actualY,
newX - lastEventX,
lastEventY - newY,
wheelPos, lastEventWheel - wheelPos);
listener.onMouseMotionEvent(evt);
lastEventX = newX;
lastEventY = newY;
lastEventWheel = newWheel;
cursorMoved = false;
}
synchronized (eventQueue) {
eventQueueCopy.clear();
eventQueueCopy.addAll(eventQueue);
eventQueue.clear();
}
int size = eventQueueCopy.size();
for (int i = 0; i < size; i++) {
listener.onMouseButtonEvent(eventQueueCopy.get(i));
}
}
public int getButtonCount() {
return 3;
}
public void mouseClicked(MouseEvent awtEvt) {
// MouseButtonEvent evt = new MouseButtonEvent(getJMEButtonIndex(arg0), false);
// listener.onMouseButtonEvent(evt);
}
public void mousePressed(MouseEvent awtEvt) {
MouseButtonEvent evt = new MouseButtonEvent(getJMEButtonIndex(awtEvt), true, awtEvt.getX(), awtEvt.getY());
evt.setTime(awtEvt.getWhen());
synchronized (eventQueue) {
eventQueue.add(evt);
}
}
public void mouseReleased(MouseEvent awtEvt) {
MouseButtonEvent evt = new MouseButtonEvent(getJMEButtonIndex(awtEvt), false, awtEvt.getX(), awtEvt.getY());
evt.setTime(awtEvt.getWhen());
synchronized (eventQueue) {
eventQueue.add(evt);
}
}
public void mouseEntered(MouseEvent awtEvt) {
if (!visible) {
recenterMouse(component);
}
}
public void mouseExited(MouseEvent awtEvt) {
if (!visible) {
recenterMouse(component);
}
}
public void mouseWheelMoved(MouseEvent awtEvt) {
//FIXME not sure this is the right way to handle this case
int dwheel = awtEvt.getWheelRotation();
wheelPos += dwheel * WHEEL_AMP;
cursorMoved = true;
}
public void mouseDragged(MouseEvent awtEvt) {
mouseMoved(awtEvt);
}
public void mouseMoved(MouseEvent awtEvt) {
if (isRecentering) {
// MHenze (cylab) Fix Issue 35:
// As long as the MouseInput is in recentering mode, nothing is done until the mouse is entered in the component
// by the events generated by the robot. If this happens, the last known location is resetted.
if ((centerLocation.getX() == awtEvt.getX() && centerLocation.getY() == awtEvt.getY()) || eventsSinceRecenter++ == 5) {
lastKnownLocation.setX(awtEvt.getX());
lastKnownLocation.setY(awtEvt.getY());
isRecentering = false;
}
} else {
// MHenze (cylab) Fix Issue 35:
// Compute the delta and absolute coordinates and recenter the mouse if necessary
int dx = awtEvt.getX() - lastKnownLocation.getX();
int dy = awtEvt.getY() - lastKnownLocation.getY();
location.setX(location.getX() + dx);
location.setY(location.getY() + dy);
if (!visible) {
recenterMouse(component);
}
lastKnownLocation.setX(awtEvt.getX());
lastKnownLocation.setY(awtEvt.getY());
cursorMoved = true;
}
}
// MHenze (cylab) Fix Issue 35: A method to generate recenter the mouse to allow the InputSystem to "grab" the mouse
private void recenterMouse(final GLWindow component) {
eventsSinceRecenter = 0;
isRecentering = true;
centerLocation.setX(component.getWidth() / 2);
centerLocation.setY(component.getHeight() / 2);
centerLocationOnScreen.setX(centerLocation.getX());
centerLocationOnScreen.setY(centerLocation.getY());
component.warpPointer(centerLocationOnScreen.getX(), centerLocationOnScreen.getY());
}
private int getJMEButtonIndex(MouseEvent awtEvt) {
int index;
switch (awtEvt.getButton()) {
default:
case MouseEvent.BUTTON1: //left
index = MouseInput.BUTTON_LEFT;
break;
case MouseEvent.BUTTON2: //middle
index = MouseInput.BUTTON_MIDDLE;
break;
case MouseEvent.BUTTON3: //right
index = MouseInput.BUTTON_RIGHT;
break;
case MouseEvent.BUTTON4:
case MouseEvent.BUTTON5:
case MouseEvent.BUTTON6:
case MouseEvent.BUTTON7:
case MouseEvent.BUTTON8:
case MouseEvent.BUTTON9:
//FIXME
index = 0;
break;
}
return index;
}
public void setNativeCursor(JmeCursor cursor) {
}
}

16
engine/src/jogl/com/jme3/system/jogl/JoglAbstractDisplay.java
Unescape View File

@ -161,16 +161,20 @@ public abstract class JoglAbstractDisplay extends JoglContext implements GLEvent
@Override @Override
public KeyInput getKeyInput() { public KeyInput getKeyInput() {
AwtKeyInput awtKeyInput = new AwtKeyInput(); if (keyInput == null) {
awtKeyInput.setInputSource(canvas); keyInput = new AwtKeyInput();
return awtKeyInput; ((AwtKeyInput)keyInput).setInputSource(canvas);
}
return keyInput;
} }
@Override @Override
public MouseInput getMouseInput() { public MouseInput getMouseInput() {
AwtMouseInput awtMouseInput = new AwtMouseInput(); if (mouseInput == null) {
awtMouseInput.setInputSource(canvas); mouseInput = new AwtMouseInput();
return awtMouseInput; ((AwtMouseInput)mouseInput).setInputSource(canvas);
}
return mouseInput;
} }
public TouchInput getTouchInput() { public TouchInput getTouchInput() {

6
engine/src/jogl/com/jme3/system/jogl/JoglContext.java
Unescape View File

@ -35,8 +35,6 @@ package com.jme3.system.jogl;
import com.jme3.input.JoyInput; import com.jme3.input.JoyInput;
import com.jme3.input.KeyInput; import com.jme3.input.KeyInput;
import com.jme3.input.MouseInput; import com.jme3.input.MouseInput;
import com.jme3.input.awt.AwtKeyInput;
import com.jme3.input.awt.AwtMouseInput;
import com.jme3.renderer.Renderer; import com.jme3.renderer.Renderer;
import com.jme3.renderer.jogl.JoglRenderer; import com.jme3.renderer.jogl.JoglRenderer;
import com.jme3.system.AppSettings; import com.jme3.system.AppSettings;
@ -57,8 +55,8 @@ public abstract class JoglContext implements JmeContext {
protected Timer timer; protected Timer timer;
protected SystemListener listener; protected SystemListener listener;
protected AwtKeyInput keyInput; protected KeyInput keyInput;
protected AwtMouseInput mouseInput; protected MouseInput mouseInput;
public void setSystemListener(SystemListener listener){ public void setSystemListener(SystemListener listener){
this.listener = listener; this.listener = listener;

3
engine/src/jogl/com/jme3/system/jogl/JoglNewtDisplay.java
Unescape View File

@ -126,11 +126,10 @@ public class JoglNewtDisplay extends JoglNewtAbstractDisplay {
} }
ScreenMode currentScreenMode = screen.getCurrentScreenMode(); ScreenMode currentScreenMode = screen.getCurrentScreenMode();
//FIXME get "bits per pixel"
logger.log(Level.INFO, "Selected display mode: {0}x{1}x{2} @{3}", logger.log(Level.INFO, "Selected display mode: {0}x{1}x{2} @{3}",
new Object[]{currentScreenMode.getRotatedWidth(), new Object[]{currentScreenMode.getRotatedWidth(),
currentScreenMode.getRotatedHeight(), currentScreenMode.getRotatedHeight(),
-1, currentScreenMode.getMonitorMode().getSurfaceSize().getBitsPerPixel(),
currentScreenMode.getMonitorMode().getRefreshRate()}); currentScreenMode.getMonitorMode().getRefreshRate()});
} }

Write Preview
Loading…
Cancel
Save