package org.simantics.g3d.jme.system; import java.util.ArrayList; import java.util.List; import java.util.logging.Level; import java.util.logging.Logger; import org.eclipse.swt.SWT; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.KeyListener; import org.eclipse.swt.events.MouseEvent; import org.eclipse.swt.events.MouseListener; import org.eclipse.swt.events.MouseMoveListener; import org.eclipse.swt.events.MouseTrackListener; import org.eclipse.swt.events.MouseWheelListener; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.opengl.GLCanvas; import org.eclipse.swt.opengl.GLData; import org.eclipse.swt.widgets.Composite; import org.lwjgl.LWJGLException; import org.lwjgl.Sys; import org.lwjgl.input.Keyboard; import org.lwjgl.input.Mouse; import org.lwjgl.opengl.GLContext; import org.lwjgl.opengl.Pbuffer; import org.lwjgl.opengl.PixelFormat; import com.jme3.cursors.plugins.JmeCursor; import com.jme3.input.JoyInput; import com.jme3.input.KeyInput; import com.jme3.input.MouseInput; import com.jme3.input.RawInputListener; import com.jme3.input.event.InputEvent; import com.jme3.input.event.KeyInputEvent; import com.jme3.input.event.MouseButtonEvent; import com.jme3.input.event.MouseMotionEvent; import com.jme3.system.AppSettings; import com.jme3.system.JmeSystem; import com.jme3.system.Platform; import com.jme3.system.lwjgl.LwjglAbstractDisplay; import com.jme3.system.lwjgl.LwjglDisplay; import com.jme3.system.lwjgl.LwjglTimer; /** * SWT OpenGL canvas for jME * * Note: this class is experimental, and contains questionable code. * * * @author Marko Luukkainen * */ public class SWTCanvas extends LwjglAbstractDisplay { protected static final boolean USE_SHARED_CONTEXT = false; private static final Logger logger = Logger.getLogger(LwjglDisplay.class.getName()); GLCanvas canvas; private int width; private int height; private boolean runningFirstTime = true; private boolean mouseWasGrabbed = false; private boolean mouseWasCreated = false; private boolean keyboardWasCreated = false; private Pbuffer pbuffer; private PixelFormat pbufferFormat; private PixelFormat canvasFormat; private boolean disposed = false; public SWTCanvas(Composite parent) { parent.setLayout(new FillLayout()); GLData data = new GLData(); data.doubleBuffer = true; data.blueSize = 8; data.redSize = 8; data.greenSize = 8; data.depthSize = 32; data.alphaSize = 8; data.stencilSize = 8; data.stereo = false; data.accumAlphaSize = 0; data.accumBlueSize = 0; data.accumGreenSize = 0; data.accumRedSize = 0; canvas = new GLCanvas(parent, SWT.EMBEDDED|SWT.NO_REDRAW_RESIZE, data); //canvas = new GLCanvas(parent, SWT.NONE, data); } public void dispose() { if (disposed) return; setCurrent(); deinitInThread(); // pauseCanvas(); canvas.dispose(); disposed = true; } public boolean isDisposed() { return disposed; } @Override public Type getType() { return Type.Canvas; // TODO : is Canvas Correct? } @Override public void setTitle(String title) { // do nothing } @Override public void restart() { frameRate = settings.getFrameRate(); } private boolean c = false; public void create(boolean waitFor){ if (c) return; c = true; setCurrent(); initInThread(); renderable.set(true); //restoreCanvas(); // canvas.addPaintListener(new PaintListener() { // // @Override // public void paintControl(PaintEvent arg0) { // repaint(); // } // }); org.eclipse.swt.widgets.Display.getCurrent().asyncExec(new Runnable() { @Override public void run() { if (canvas.isDisposed()) return; repaint(); org.eclipse.swt.widgets.Display.getCurrent().asyncExec(this); } }); } @Override protected void runLoop() { if (renderable.get()){ Point size = canvas.getSize(); //System.out.println("Render " + size); int newWidth = Math.max(size.x, 1); int newHeight = Math.max(size.y, 1); if (width != newWidth || height != newHeight){ System.out.println("Render resize " + size); width = newWidth; height = newHeight; if (listener != null){ listener.reshape(width, height); } } } if (!created.get()) throw new IllegalStateException(); listener.update(); if (renderable.get()){ assert checkGLError(); // calls swap buffers, etc. try { canvas.swapBuffers(); // Display.processMessages(); // if (autoFlush){ // Display.update(false); // }else{ // Display.processMessages(); // Thread.sleep(50); // // add a small wait // // to reduce CPU usage // } } catch (Throwable ex){ listener.handleError("Error while swapping buffers", ex); } } // if (frameRate > 0) // Display.sync(frameRate); // if (renderable.get()){ // if (autoFlush){ // // check input after we synchronize with framerate. // // this reduces input lag. // Display.processMessages(); // } // } } public void repaint() { setCurrent(); // if (renderable.get()){ // if (Display.isCloseRequested()) // listener.requestClose(false); // if (wasActive != Display.isActive()) { // if (!wasActive) { // listener.gainFocus(); // timer.reset(); // wasActive = true; // } else { // listener.loseFocus(); // wasActive = false; // } // } // } runLoop(); } @Override public void run() { // do nothing //super.run(); } @Override protected void destroyContext() { try { // invalidate the state so renderer can resume operation if (!USE_SHARED_CONTEXT){ renderer.cleanup(); } //if (Display.isCreated()){ if (!canvas.isDisposed()) { /* FIXES: * org.lwjgl.LWJGLException: X Error * BadWindow (invalid Window parameter) request_code: 2 minor_code: 0 * * Destroying keyboard early prevents the error above, triggered * by destroying keyboard in by Display.destroy() or Display.setParent(null). * Therefore Keyboard.destroy() should precede any of these calls. */ if (Keyboard.isCreated()){ // Should only happen if called in // LwjglAbstractDisplay.deinitInThread(). Keyboard.destroy(); } //try { // NOTE: On Windows XP, not calling setParent(null) // freezes the application. // On Mac it freezes the application. // On Linux it fixes a crash with X Window System. if (JmeSystem.getPlatform() == Platform.Windows32 || JmeSystem.getPlatform() == Platform.Windows64){ //Display.setParent(null); } //} catch (LWJGLException ex) { // logger.log(Level.SEVERE, "Encountered exception when setting parent to null", ex); //} // Display.destroy(); } // The canvas is no longer visible, // but the context thread is still running. if (!needClose.get()){ // MUST make sure there's still a context current here .. // Display is dead, make pbuffer available to the system makePbufferAvailable(); renderer.invalidateState(); }else{ // The context thread is no longer running. // Destroy pbuffer. destroyPbuffer(); } } catch (LWJGLException ex) { listener.handleError("Failed make pbuffer available", ex); } } public void setFocus() { canvas.setFocus(); } public void setCurrent(GLCanvas canvas) { // delegate to the GLContext canvas.setCurrent(); try { GLContext.useContext(canvas); } catch (LWJGLException e) { e.printStackTrace(); } } public void setCurrent() { setCurrent(canvas); } private void pauseCanvas(){ if (Mouse.isCreated()){ if (Mouse.isGrabbed()){ Mouse.setGrabbed(false); mouseWasGrabbed = true; } mouseWasCreated = true; Mouse.destroy(); } if (Keyboard.isCreated()){ keyboardWasCreated = true; Keyboard.destroy(); } renderable.set(false); destroyContext(); } /** * Called to restore the canvas. */ private void restoreCanvas(){ setCurrent(); logger.log(Level.INFO, "OGL: Waiting for canvas to become displayable.."); while (!canvas.getVisible()){ try { Thread.sleep(10); } catch (InterruptedException ex) { logger.log(Level.SEVERE, "OGL: Interrupted! ", ex); } } logger.log(Level.INFO, "OGL: Creating display context .."); // Set renderable to true, since canvas is now displayable. renderable.set(true); createContext(settings); logger.log(Level.INFO, "OGL: Display is active!"); try { if (mouseWasCreated){ Mouse.create(); if (mouseWasGrabbed){ Mouse.setGrabbed(true); mouseWasGrabbed = false; } } if (keyboardWasCreated){ Keyboard.create(); keyboardWasCreated = false; } } catch (LWJGLException ex){ logger.log(Level.SEVERE, "Encountered exception when restoring input", ex); } } /** * It seems it is best to use one pixel format for all shared contexts. * @see http://developer.apple.com/library/mac/#qa/qa1248/_index.html */ protected PixelFormat acquirePixelFormat(boolean forPbuffer){ if (forPbuffer){ // Use 0 samples for pbuffer format, prevents // crashes on bad drivers if (pbufferFormat == null){ pbufferFormat = new PixelFormat(settings.getBitsPerPixel(), 0, settings.getDepthBits(), settings.getStencilBits(), 0); } return pbufferFormat; }else{ if (canvasFormat == null){ int samples = getNumSamplesToUse(); canvasFormat = new PixelFormat(settings.getBitsPerPixel(), 0, settings.getDepthBits(), settings.getStencilBits(), samples); } return canvasFormat; } } /** * Makes sure the pbuffer is available and ready for use */ protected void makePbufferAvailable() throws LWJGLException{ if (pbuffer != null && pbuffer.isBufferLost()){ logger.log(Level.WARNING, "PBuffer was lost!"); pbuffer.destroy(); pbuffer = null; } if (pbuffer == null) { pbuffer = new Pbuffer(1, 1, acquirePixelFormat(true), null); pbuffer.makeCurrent(); logger.log(Level.INFO, "OGL: Pbuffer has been created"); // Any created objects are no longer valid if (!runningFirstTime){ renderer.resetGLObjects(); } } pbuffer.makeCurrent(); if (!pbuffer.isCurrent()){ throw new LWJGLException("Pbuffer cannot be made current"); } } protected void destroyPbuffer(){ if (pbuffer != null){ if (!pbuffer.isBufferLost()){ pbuffer.destroy(); } pbuffer = null; } } @Override protected void createContext(AppSettings settings) { setCurrent(); // In case canvas is not visible, we still take framerate // from settings to prevent "100% CPU usage" frameRate = settings.getFrameRate(); try { if (renderable.get()){ if (!runningFirstTime){ // because the display is a different opengl context // must reset the context state. if (!USE_SHARED_CONTEXT){ renderer.cleanup(); } } // if the pbuffer is currently active, // make sure to deactivate it destroyPbuffer(); if (Keyboard.isCreated()){ Keyboard.destroy(); } try { Thread.sleep(1000); } catch (InterruptedException ex) { } // Display.setVSyncEnabled(settings.isVSync()); //Display.setParent(canvas); // if (USE_SHARED_CONTEXT){ // Display.create(acquirePixelFormat(false), pbuffer); // }else{ // Display.create(acquirePixelFormat(false)); // } renderer.invalidateState(); }else{ // First create the pbuffer, if it is needed. makePbufferAvailable(); } // At this point, the OpenGL context is active. if (runningFirstTime){ // THIS is the part that creates the renderer. // It must always be called, now that we have the pbuffer workaround. initContextFirstTime(); runningFirstTime = false; } } catch (LWJGLException ex) { listener.handleError("Failed to initialize OpenGL context", ex); // TODO: Fix deadlock that happens after the error (throw runtime exception?) } } public JoyInput getJoyInput() { return null; } SWTMouseInput mouseInput; public MouseInput getMouseInput() { if (mouseInput == null){ mouseInput = new SWTMouseInput(this); } return mouseInput; } SWTKeyInput keyInput; public KeyInput getKeyInput() { if (keyInput == null){ keyInput = new SWTKeyInput(this); } return keyInput; } public class SWTMouseInput implements MouseInput, MouseListener, MouseMoveListener, MouseWheelListener, MouseTrackListener { SWTCanvas canvas; boolean init = false; RawInputListener listener; public SWTMouseInput(SWTCanvas canvas) { this.canvas = canvas; } @Override public void destroy() { this.canvas.canvas.removeMouseListener(this); this.canvas.canvas.removeMouseMoveListener(this); this.canvas.canvas.removeMouseWheelListener(this); this.canvas.canvas.removeMouseTrackListener(this); } @Override public void initialize() { this.canvas.canvas.addMouseListener(this); this.canvas.canvas.addMouseMoveListener(this); this.canvas.canvas.addMouseWheelListener(this); this.canvas.canvas.addMouseTrackListener(this); init = true; } @Override public int getButtonCount() { return 3; } @Override public boolean isInitialized() { return init; } @Override public void setInputListener(RawInputListener listener) { this.listener = listener; } public long getInputTimeNanos() { return Sys.getTime() * LwjglTimer.LWJGL_TIME_TO_NANOS; } @Override public void setCursorVisible(boolean visible) { } @Override public void setNativeCursor(JmeCursor cursor) { } @Override public void update() { if (listener == null || events.size() == 0) return; listener.beginInput(); for (InputEvent e : events) { if (e instanceof MouseButtonEvent) listener.onMouseButtonEvent((MouseButtonEvent)e); else listener.onMouseMotionEvent((MouseMotionEvent)e); } events.clear(); listener.endInput(); } private List events = new ArrayList(); @Override public void mouseDoubleClick(MouseEvent e) { //events.add(new MouseButtonEvent(e.button,true, e.x, e.y)); } @Override public void mouseDown(MouseEvent e) { events.add(new MouseButtonEvent(e.button,true, e.x, e.y)); } @Override public void mouseUp(MouseEvent e) { events.add(new MouseButtonEvent(e.button,false, e.x, e.y)); } int px = 0; int py = 0; @Override public void mouseMove(MouseEvent e) { events.add(new MouseMotionEvent(e.x, e.y, e.x - px, e.y - py, 0, 0)); px = e.x; py = e.y; } @Override public void mouseScrolled(MouseEvent e) { events.add(new MouseMotionEvent(e.x, e.y, 0, 0, e.button, e.count)); } @Override public void mouseEnter(MouseEvent e) { px = e.x; py = e.y; } @Override public void mouseExit(MouseEvent e) { } @Override public void mouseHover(MouseEvent e) { } } public class SWTKeyInput implements KeyInput, KeyListener { SWTCanvas canvas; boolean init = false; RawInputListener listener; public SWTKeyInput(SWTCanvas canvas) { this.canvas = canvas; } @Override public void destroy() { this.canvas.canvas.removeKeyListener(this); } @Override public void initialize() { this.canvas.canvas.addKeyListener(this); init = true; } @Override public boolean isInitialized() { return init; } @Override public void setInputListener(RawInputListener listener) { this.listener = listener; } public long getInputTimeNanos() { return Sys.getTime() * LwjglTimer.LWJGL_TIME_TO_NANOS; } private List events = new ArrayList(); KeyInputEvent prevEvent = new KeyInputEvent(0, (char)0, false, false); @Override public void update() { if (listener == null || events.size() == 0) return; listener.beginInput(); for (KeyInputEvent e : events) { //System.out.println("Key " + e.getKeyCode() + " " + e.getKeyChar() + " " + e.isPressed() + " " + e.isRepeating()); // SWT reports wrong key code in released event for a key, if multiple keys are down at the same time // example: // press 'a' -> event press a // press 'b' -> event press b // release 'a' -> event release b // keep 'b' pressed -> event press b (with slight pause before events starts coming by) // release 'b' -> event release b // press 'a' -> event press a // press 'b' -> event press b // release 'b' -> event release b // keep 'a' pressed -> nothing happens. // release 'a' -> nothing happens if (e.isPressed()) { if (e.getKeyCode() != prevEvent.getKeyCode() && prevEvent.isPressed()) { listener.onKeyEvent(new KeyInputEvent(prevEvent.getKeyCode(), prevEvent.getKeyChar(), false, false)); } } listener.onKeyEvent(e); prevEvent = e; } events.clear(); listener.endInput(); } @Override public void keyPressed(KeyEvent e) { events.add(new KeyInputEvent(getLWJGLKeyCode(e.keyCode), e.character, true, false)); } @Override public void keyReleased(KeyEvent e) { events.add(new KeyInputEvent(getLWJGLKeyCode(e.keyCode), e.character, false, false)); } private int getLWJGLKeyCode(int swtKeyCode) { // TODO : LWJGL uses mapping/layout of US keyboard, these have to be checked if(swtKeyCode > 1024) { int keyCode = 0; switch (swtKeyCode) { case SWT.CTRL: keyCode = Keyboard.KEY_LCONTROL; break; case SWT.ALT: keyCode = Keyboard.KEY_LMETA; break; case SWT.SHIFT: keyCode = Keyboard.KEY_LSHIFT; break; case SWT.ARROW_LEFT: keyCode = Keyboard.KEY_LEFT; break; case SWT.ARROW_RIGHT: keyCode = Keyboard.KEY_RIGHT; break; case SWT.ARROW_UP: keyCode = Keyboard.KEY_UP; break; case SWT.ARROW_DOWN: keyCode = Keyboard.KEY_DOWN; break; case SWT.KEYPAD_0: keyCode = Keyboard.KEY_NUMPAD0; break; case SWT.KEYPAD_1: keyCode = Keyboard.KEY_NUMPAD1; break; case SWT.KEYPAD_2: keyCode = Keyboard.KEY_NUMPAD2; break; case SWT.KEYPAD_3: keyCode = Keyboard.KEY_NUMPAD3; break; case SWT.KEYPAD_4: keyCode = Keyboard.KEY_NUMPAD4; break; case SWT.KEYPAD_5: keyCode = Keyboard.KEY_NUMPAD5; break; case SWT.KEYPAD_6: keyCode = Keyboard.KEY_NUMPAD6; break; case SWT.KEYPAD_7: keyCode = Keyboard.KEY_NUMPAD7; break; case SWT.KEYPAD_8: keyCode = Keyboard.KEY_NUMPAD8; break; case SWT.KEYPAD_9: keyCode = Keyboard.KEY_NUMPAD9; break; case SWT.KEYPAD_CR: keyCode = Keyboard.KEY_NUMPADENTER; break; case SWT.NUM_LOCK: keyCode = Keyboard.KEY_NUMLOCK; break; case SWT.SCROLL_LOCK: keyCode = Keyboard.KEY_SCROLL; break; case SWT.CAPS_LOCK: keyCode = Keyboard.KEY_CAPITAL; break; case SWT.INSERT: keyCode = Keyboard.KEY_INSERT; break; case SWT.HOME: keyCode = Keyboard.KEY_HOME; break; case SWT.END: keyCode = Keyboard.KEY_END; break; case SWT.PAGE_UP: keyCode = Keyboard.KEY_NEXT; break; case SWT.PAGE_DOWN: keyCode = Keyboard.KEY_PRIOR; break; case SWT.PAUSE: keyCode = Keyboard.KEY_PAUSE; break; case SWT.BREAK: keyCode = Keyboard.KEY_PAUSE; break; case SWT.PRINT_SCREEN: keyCode = Keyboard.KEY_SYSRQ; break; case SWT.HELP: keyCode = 0; break; case SWT.KEYPAD_MULTIPLY: keyCode = Keyboard.KEY_MULTIPLY; break; case SWT.KEYPAD_DIVIDE: keyCode = Keyboard.KEY_DIVIDE; break; case SWT.KEYPAD_DECIMAL: keyCode = Keyboard.KEY_DECIMAL; break; case SWT.F1: keyCode = Keyboard.KEY_F1; break; case SWT.F2: keyCode = Keyboard.KEY_F2; break; case SWT.F3: keyCode = Keyboard.KEY_F3; break; case SWT.F4: keyCode = Keyboard.KEY_F4; break; case SWT.F5: keyCode = Keyboard.KEY_F5; break; case SWT.F6: keyCode = Keyboard.KEY_F6; break; case SWT.F7: keyCode = Keyboard.KEY_F7; break; case SWT.F8: keyCode = Keyboard.KEY_F8; break; case SWT.F9: keyCode = Keyboard.KEY_F9; break; case SWT.F10: keyCode = Keyboard.KEY_F10; break; case SWT.F11: keyCode = Keyboard.KEY_F11; break; case SWT.F12: keyCode = Keyboard.KEY_F12; break; default : keyCode = Keyboard.KEY_NONE; break; } return keyCode; } else if (swtKeyCode == 8) { return Keyboard.KEY_BACK; } else if (swtKeyCode == SWT.ESC) { return Keyboard.KEY_ESCAPE; } else if (swtKeyCode == SWT.SPACE) { return Keyboard.KEY_SPACE; } else if (swtKeyCode >= 49 && swtKeyCode < 58) { // 1 - 9 return swtKeyCode - 47; } else if (swtKeyCode == 48) { return Keyboard.KEY_0; } else if (swtKeyCode == SWT.TAB) { return Keyboard.KEY_TAB; } else if (swtKeyCode == 46) { return Keyboard.KEY_PERIOD; } else if (swtKeyCode == 44) { return Keyboard.KEY_COMMA; } else if (swtKeyCode == 39) { // '/* on SWE/FI keyboard return Keyboard.KEY_SLASH; } else if (swtKeyCode == 45) { return Keyboard.KEY_MINUS; } else if (swtKeyCode == 43) { return Keyboard.KEY_EQUALS; // +/? on SWE/FI keyboard } else if (swtKeyCode == SWT.DEL) { return Keyboard.KEY_DELETE; } else if (swtKeyCode == SWT.CR) { return Keyboard.KEY_RETURN; } else if (swtKeyCode == 167) { // § on SWE/FI keyboard return Keyboard.KEY_BACKSLASH; } else if (swtKeyCode >= 97 ) swtKeyCode -= 32; if (swtKeyCode >= 65 && swtKeyCode <= 90) { switch (swtKeyCode) { case 65: return Keyboard.KEY_A; case 66: return Keyboard.KEY_B; case 67: return Keyboard.KEY_C; case 68: return Keyboard.KEY_D; case 69: return Keyboard.KEY_E; case 70: return Keyboard.KEY_F; case 71: return Keyboard.KEY_G; case 72: return Keyboard.KEY_H; case 73: return Keyboard.KEY_I; case 74: return Keyboard.KEY_J; case 75: return Keyboard.KEY_K; case 76: return Keyboard.KEY_L; case 77: return Keyboard.KEY_M; case 78: return Keyboard.KEY_N; case 79: return Keyboard.KEY_O; case 80: return Keyboard.KEY_P; case 81: return Keyboard.KEY_Q; case 82: return Keyboard.KEY_R; case 83: return Keyboard.KEY_S; case 84: return Keyboard.KEY_T; case 85: return Keyboard.KEY_U; case 86: return Keyboard.KEY_V; case 87: return Keyboard.KEY_W; case 88: return Keyboard.KEY_X; case 89: return Keyboard.KEY_Y; case 90: return Keyboard.KEY_Z; } } return Keyboard.KEY_UNLABELED; } private int getAWTKeyCode(int swtKeyCode) { if(swtKeyCode > 1024) { int keyCode = 0; switch (swtKeyCode) { case SWT.CTRL: keyCode = java.awt.event.KeyEvent.VK_CONTROL; break; case SWT.ALT: keyCode = java.awt.event.KeyEvent.VK_ALT; break; case SWT.SHIFT: keyCode = java.awt.event.KeyEvent.VK_SHIFT; break; case SWT.ARROW_LEFT: keyCode = java.awt.event.KeyEvent.VK_LEFT; break; case SWT.ARROW_RIGHT: keyCode = java.awt.event.KeyEvent.VK_RIGHT; break; case SWT.ARROW_UP: keyCode = java.awt.event.KeyEvent.VK_UP; break; case SWT.ARROW_DOWN: keyCode = java.awt.event.KeyEvent.VK_DOWN; break; case SWT.KEYPAD_0: keyCode = java.awt.event.KeyEvent.VK_NUMPAD0; break; case SWT.KEYPAD_1: keyCode = java.awt.event.KeyEvent.VK_NUMPAD1; break; case SWT.KEYPAD_2: keyCode = java.awt.event.KeyEvent.VK_NUMPAD2; break; case SWT.KEYPAD_3: keyCode = java.awt.event.KeyEvent.VK_NUMPAD3; break; case SWT.KEYPAD_4: keyCode = java.awt.event.KeyEvent.VK_NUMPAD4; break; case SWT.KEYPAD_5: keyCode = java.awt.event.KeyEvent.VK_NUMPAD5; break; case SWT.KEYPAD_6: keyCode = java.awt.event.KeyEvent.VK_NUMPAD6; break; case SWT.KEYPAD_7: keyCode = java.awt.event.KeyEvent.VK_NUMPAD7; break; case SWT.KEYPAD_8: keyCode = java.awt.event.KeyEvent.VK_NUMPAD8; break; case SWT.KEYPAD_9: keyCode = java.awt.event.KeyEvent.VK_NUMPAD9; break; case SWT.KEYPAD_CR: keyCode = java.awt.event.KeyEvent.VK_ENTER; break; case SWT.NUM_LOCK: keyCode = java.awt.event.KeyEvent.VK_NUM_LOCK; break; case SWT.SCROLL_LOCK: keyCode = java.awt.event.KeyEvent.VK_SCROLL_LOCK; break; case SWT.CAPS_LOCK: keyCode = java.awt.event.KeyEvent.VK_CAPS_LOCK; break; case SWT.INSERT: keyCode = java.awt.event.KeyEvent.VK_INSERT; break; case SWT.HOME: keyCode = java.awt.event.KeyEvent.VK_HOME; break; case SWT.END: keyCode = java.awt.event.KeyEvent.VK_END; break; case SWT.PAGE_UP: keyCode = java.awt.event.KeyEvent.VK_PAGE_UP; break; case SWT.PAGE_DOWN: keyCode = java.awt.event.KeyEvent.VK_PAGE_DOWN; break; case SWT.PAUSE: keyCode = java.awt.event.KeyEvent.VK_PAUSE; break; case SWT.BREAK: keyCode = java.awt.event.KeyEvent.VK_PAUSE; break; case SWT.PRINT_SCREEN: keyCode = java.awt.event.KeyEvent.VK_PRINTSCREEN; break; case SWT.HELP: keyCode = java.awt.event.KeyEvent.VK_HELP; break; default : keyCode = 0; break; } return keyCode; } else if (swtKeyCode == 8) { return java.awt.event.KeyEvent.VK_BACK_SPACE; } else if (swtKeyCode >= 97 ) return swtKeyCode - 32; else return swtKeyCode; } } }