diff options
Diffstat (limited to 'src')
27 files changed, 1547 insertions, 933 deletions
diff --git a/src/jogl/classes/com/sun/opengl/impl/x11/glx/GLXUtil.java b/src/jogl/classes/com/sun/opengl/impl/x11/glx/GLXUtil.java index b8968ee99..8ab99ac0a 100644 --- a/src/jogl/classes/com/sun/opengl/impl/x11/glx/GLXUtil.java +++ b/src/jogl/classes/com/sun/opengl/impl/x11/glx/GLXUtil.java @@ -51,40 +51,44 @@ public class GLXUtil { // Display connection for use by visual selection algorithm and by all offscreen surfaces private static boolean multisampleAvailable=false; - private static boolean isInit=false; + private static volatile boolean isInit=false; - private static void init() { + private static synchronized void init() { if (!isInit) { - NativeWindowFactory.getDefaultFactory().getToolkitLock().lock(); - try { - long staticDisplay = X11Util.getStaticDefaultDisplay(); - if(staticDisplay!=0) { - if (DEBUG) { - long display = staticDisplay; - int screen = X11Lib.DefaultScreen(display); - System.err.println("!!! GLX server vendor : " + - GLX.glXQueryServerString(display, screen, GLX.GLX_VENDOR)); - System.err.println("!!! GLX server version: " + - GLX.glXQueryServerString(display, screen, GLX.GLX_VERSION)); - System.err.println("!!! GLX client vendor : " + - GLX.glXGetClientString(display, GLX.GLX_VENDOR)); - System.err.println("!!! GLX client version: " + - GLX.glXGetClientString(display, GLX.GLX_VERSION)); + synchronized (GLXUtil.class) { + if (!isInit) { + NativeWindowFactory.getDefaultFactory().getToolkitLock().lock(); + try { + long staticDisplay = X11Util.getStaticDefaultDisplay(); + if(staticDisplay!=0) { + if (DEBUG) { + long display = staticDisplay; + int screen = X11Lib.DefaultScreen(display); + System.err.println("!!! GLX server vendor : " + + GLX.glXQueryServerString(display, screen, GLX.GLX_VENDOR)); + System.err.println("!!! GLX server version: " + + GLX.glXQueryServerString(display, screen, GLX.GLX_VERSION)); + System.err.println("!!! GLX client vendor : " + + GLX.glXGetClientString(display, GLX.GLX_VENDOR)); + System.err.println("!!! GLX client version: " + + GLX.glXGetClientString(display, GLX.GLX_VERSION)); + } + String vendor = GLX.glXGetClientString(staticDisplay, GLX.GLX_VENDOR); + if (vendor != null && vendor.startsWith("ATI")) { + isVendorATI = true; + } + String exts = GLX.glXGetClientString(staticDisplay, GLX.GLX_EXTENSIONS); + if (exts != null) { + multisampleAvailable = (exts.indexOf("GLX_ARB_multisample") >= 0); + } + isInit=true; + } else { + throw new GLException("Unable to open default display, needed for visual selection and offscreen surface handling"); + } + } finally { + NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock(); } - String vendor = GLX.glXGetClientString(staticDisplay, GLX.GLX_VENDOR); - if (vendor != null && vendor.startsWith("ATI")) { - isVendorATI = true; - } - String exts = GLX.glXGetClientString(staticDisplay, GLX.GLX_EXTENSIONS); - if (exts != null) { - multisampleAvailable = (exts.indexOf("GLX_ARB_multisample") >= 0); - } - isInit=true; - } else { - throw new GLException("Unable to open default display, needed for visual selection and offscreen surface handling"); } - } finally { - NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock(); } } } diff --git a/src/jogl/classes/javax/media/opengl/GLProfile.java b/src/jogl/classes/javax/media/opengl/GLProfile.java index 57f4fb46a..385006b75 100644 --- a/src/jogl/classes/javax/media/opengl/GLProfile.java +++ b/src/jogl/classes/javax/media/opengl/GLProfile.java @@ -104,13 +104,15 @@ public class GLProfile implements Cloneable { /** Returns a GLProfile object. * Verfifies the given profile and chooses an apropriate implementation. + * A generic value of <code>null</code> or <code>GL</code> will result in + * the default profile. * * @throws GLException if no implementation for the given profile is found. */ public static final GLProfile get(String profile) throws GLException { - if(null==profile) return getDefault(); + if(null==profile || profile.equals("GL")) return getDefault(); GLProfile glProfile = (GLProfile) mappedProfiles.get(profile); if(null==glProfile) { throw new GLException("No implementation for profile "+profile+" available"); diff --git a/src/nativewindow/classes/com/sun/nativewindow/impl/jawt/JAWTUtil.java b/src/nativewindow/classes/com/sun/nativewindow/impl/jawt/JAWTUtil.java index ae606a790..20e8cf966 100644 --- a/src/nativewindow/classes/com/sun/nativewindow/impl/jawt/JAWTUtil.java +++ b/src/nativewindow/classes/com/sun/nativewindow/impl/jawt/JAWTUtil.java @@ -43,21 +43,28 @@ import javax.media.nativewindow.*; import java.awt.GraphicsEnvironment; public class JAWTUtil { - static { - JAWTNativeLibLoader.loadAWTImpl(); - NativeLibLoaderBase.loadNativeWindow("awt"); - } - - // See whether we're running in headless mode - private static boolean headlessMode; static { + JAWTNativeLibLoader.loadAWTImpl(); + NativeLibLoaderBase.loadNativeWindow("awt"); + lockedStack = null; headlessMode = GraphicsEnvironment.isHeadless(); } + // See whether we're running in headless mode + private static final boolean headlessMode; + private static Exception lockedStack; + // Just a hook to let this class being initialized, + // ie loading the native libraries .. + public static void init() { } + + public static boolean isHeadlessMode() { + return headlessMode; + } + public static synchronized void lockToolkit() throws NativeWindowException { if (null!=lockedStack) { lockedStack.printStackTrace(); diff --git a/src/nativewindow/classes/com/sun/nativewindow/impl/x11/X11Util.java b/src/nativewindow/classes/com/sun/nativewindow/impl/x11/X11Util.java index 731bd3caf..38d0fb73d 100644 --- a/src/nativewindow/classes/com/sun/nativewindow/impl/x11/X11Util.java +++ b/src/nativewindow/classes/com/sun/nativewindow/impl/x11/X11Util.java @@ -73,18 +73,23 @@ public class X11Util { private static ThreadLocal currentDisplayAssociation = new ThreadLocal(); - private static long staticDefaultDisplay=0; + private static volatile long staticDefaultDisplay=0; private static boolean staticDefaultDisplayXineramaEnable=false; private static long fetchStaticDefaultDisplay() { if(0==staticDefaultDisplay) { synchronized (X11Util.class) { if(0==staticDefaultDisplay) { - staticDefaultDisplay = X11Lib.XOpenDisplay(null); - if(0==staticDefaultDisplay) { - throw new NativeWindowException("Unable to create a static default display connection"); + NativeWindowFactory.getDefaultFactory().getToolkitLock().lock(); + try { + staticDefaultDisplay = X11Lib.XOpenDisplay(null); + if(0==staticDefaultDisplay) { + throw new NativeWindowException("Unable to create a static default display connection"); + } + staticDefaultDisplayXineramaEnable = X11Lib.XineramaEnabled(staticDefaultDisplay); + } finally { + NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock(); } - staticDefaultDisplayXineramaEnable = X11Lib.XineramaEnabled(staticDefaultDisplay); } } } @@ -109,15 +114,20 @@ public class X11Util { public static long getThreadLocalDefaultDisplay() { Long dpyL = (Long) currentDisplayAssociation.get(); if(null==dpyL) { - long dpy = X11Lib.XOpenDisplay(null); - if(0==dpy) { - throw new NativeWindowException("Unable to create a default display connection on Thread "+Thread.currentThread().getName()); - } - dpyL = new Long(dpy); - currentDisplayAssociation.set( dpyL ); - if(DEBUG) { - Exception e = new Exception("Created new TLS display connection 0x"+Long.toHexString(dpy)+" for thread "+Thread.currentThread().getName()); - e.printStackTrace(); + NativeWindowFactory.getDefaultFactory().getToolkitLock().lock(); + try { + long dpy = X11Lib.XOpenDisplay(null); + if(0==dpy) { + throw new NativeWindowException("Unable to create a default display connection on Thread "+Thread.currentThread().getName()); + } + dpyL = new Long(dpy); + currentDisplayAssociation.set( dpyL ); + if(DEBUG) { + Exception e = new Exception("Created new TLS display connection 0x"+Long.toHexString(dpy)+" for thread "+Thread.currentThread().getName()); + e.printStackTrace(); + } + } finally { + NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock(); } } return dpyL.longValue(); diff --git a/src/newt/classes/com/sun/javafx/newt/Display.java b/src/newt/classes/com/sun/javafx/newt/Display.java index b5d3c8520..5032477c9 100755 --- a/src/newt/classes/com/sun/javafx/newt/Display.java +++ b/src/newt/classes/com/sun/javafx/newt/Display.java @@ -34,8 +34,11 @@ package com.sun.javafx.newt; import javax.media.nativewindow.*; +import com.sun.javafx.newt.impl.Debug; +import java.util.*; -public abstract class Display { +public abstract class Display implements Runnable { + public static final boolean DEBUG = Debug.debug("Display"); private static Class getDisplayClass(String type) throws ClassNotFoundException @@ -57,14 +60,93 @@ public abstract class Display { return displayClass; } + private static ThreadLocal currentDisplayMap = new ThreadLocal(); + + /** Returns the thread local display map */ + public static Map getCurrentDisplayMap() { + Map displayMap = (Map) currentDisplayMap.get(); + if(null==displayMap) { + displayMap = new HashMap(); + currentDisplayMap.set( displayMap ); + } + return displayMap; + } + + /** maps the given display to the thread local display map + * and notifies all threads synchronized to this display map. */ + protected static Display setCurrentDisplay(Display display) { + Map displayMap = getCurrentDisplayMap(); + Display oldDisplay = null; + synchronized(displayMap) { + String name = display.getName(); + if(null==name) name="nil"; + oldDisplay = (Display) displayMap.put(name, display); + displayMap.notifyAll(); + } + return oldDisplay; + } + + /** removes the mapping of the given name from the thread local display map + * and notifies all threads synchronized to this display map. */ + protected static Display removeCurrentDisplay(String name) { + if(null==name) name="nil"; + Map displayMap = getCurrentDisplayMap(); + Display oldDisplay = null; + synchronized(displayMap) { + oldDisplay = (Display) displayMap.remove(name); + displayMap.notifyAll(); + } + return oldDisplay; + } + + /** Returns the thread local display mapped to the given name */ + public static Display getCurrentDisplay(String name) { + if(null==name) name="nil"; + Map displayMap = getCurrentDisplayMap(); + Display display = (Display) displayMap.get(name); + return display; + } + + private static void dumpDisplayMap(String prefix) { + Map displayMap = getCurrentDisplayMap(); + Set entrySet = displayMap.entrySet(); + Iterator i = entrySet.iterator(); + System.err.println(prefix+" DisplayMap["+entrySet.size()+"] "+Thread.currentThread().getName()); + for(int j=0; i.hasNext(); j++) { + Map.Entry entry = (Map.Entry) i.next(); + System.err.println(" ["+j+"] "+entry.getKey()+" -> "+entry.getValue()); + } + } + + /** Returns the thread local display collection */ + public static Collection getCurrentDisplays() { + return getCurrentDisplayMap().values(); + } + + /** Make sure to reuse a Display with the same name */ protected static Display create(String type, String name) { try { - Class displayClass = getDisplayClass(type); - Display display = (Display) displayClass.newInstance(); - display.name=name; - display.createNative(); - if(null==display.aDevice) { - throw new RuntimeException("Display.createNative() failed to instanciate an AbstractGraphicsDevice"); + Display display = getCurrentDisplay(name); + if(null==display) { + Class displayClass = getDisplayClass(type); + display = (Display) displayClass.newInstance(); + display.name=name; + display.refCount=1; + display.createNative(); + if(null==display.aDevice) { + throw new RuntimeException("Display.createNative() failed to instanciate an AbstractGraphicsDevice"); + } + setCurrentDisplay(display); + if(DEBUG) { + System.err.println("Display.create("+name+") NEW: "+display+" "+Thread.currentThread().getName()); + } + } else { + synchronized(display) { + display.refCount++; + if(DEBUG) { + System.err.println("Display.create("+name+") REUSE: refCount "+display.refCount+", "+display+" "+Thread.currentThread().getName()); + } + } } return display; } catch (Exception e) { @@ -73,7 +155,18 @@ public abstract class Display { } public synchronized void destroy() { - closeNative(); + refCount--; + if(0==refCount) { + removeCurrentDisplay(name); + if(DEBUG) { + System.err.println("Display.destroy("+name+") REMOVE: "+this+" "+Thread.currentThread().getName()); + } + closeNative(); + } else { + if(DEBUG) { + System.err.println("Display.destroy("+name+") KEEP: refCount "+refCount+", "+this+" "+Thread.currentThread().getName()); + } + } } protected static Display wrapHandle(String type, String name, AbstractGraphicsDevice aDevice) { @@ -103,7 +196,36 @@ public abstract class Display { return aDevice; } + public synchronized void pumpMessages() { + dispatchMessages(); + } + + /** calls {@link #pumpMessages} */ + public void run() { + pumpMessages(); + } + + public static interface Action { + public void run(Display display); + } + + /** Calls {@link Display.Action#run(Display)} on all Display's + bound to the current thread. */ + public static void runCurrentThreadDisplaysAction(Display.Action action) { + Iterator iter = getCurrentDisplays().iterator(); // Thread local .. no sync necessary + while(iter.hasNext()) { + action.run((Display) iter.next()); + } + } + + public String toString() { + return "NEWT-Display["+name+", refCount "+refCount+", "+aDevice+"]"; + } + + protected abstract void dispatchMessages(); + protected String name; + protected int refCount; protected AbstractGraphicsDevice aDevice; } diff --git a/src/newt/classes/com/sun/javafx/newt/DisplayActionThread.java b/src/newt/classes/com/sun/javafx/newt/DisplayActionThread.java new file mode 100644 index 000000000..8f02148a2 --- /dev/null +++ b/src/newt/classes/com/sun/javafx/newt/DisplayActionThread.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * - Redistribution of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistribution 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 Sun Microsystems, Inc. or the names of + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. ALL + * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, + * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, + * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF + * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + */ +package com.sun.javafx.newt; + +import javax.media.nativewindow.*; +import com.sun.javafx.newt.impl.Debug; +import java.util.*; + +public class DisplayActionThread extends Thread { + private Object taskWorkerLock=new Object(); + private boolean isRunning = false; + private boolean shouldStop = false; + private List/*DisplayAction*/ displayActions = new ArrayList(); + + public synchronized void addAction(Display.Action da) { + List newListeners = (List) ((ArrayList) displayActions).clone(); + newListeners.add(da); + displayActions = newListeners; + } + + public synchronized void removeAction(Display.Action da) { + List newListeners = (List) ((ArrayList) displayActions).clone(); + newListeners.remove(da); + displayActions = newListeners; + } + + public boolean isRunning() { + synchronized(taskWorkerLock) { + return isRunning; + } + } + + public void exit() { + synchronized(taskWorkerLock) { + if(isRunning) { + shouldStop = true; + taskWorkerLock.notifyAll(); + } + } + Map displayMap = Display.getCurrentDisplayMap(); + synchronized(displayMap) { + displayMap.notifyAll(); + } + } + + public void start() { + synchronized(taskWorkerLock) { + if(!isRunning) { + shouldStop = false; + taskWorkerLock.notifyAll(); + super.start(); + } + } + } + + public void run() { + synchronized(taskWorkerLock) { + isRunning = true; + taskWorkerLock.notifyAll(); + } + while(!shouldStop) { + Map displayMap = Display.getCurrentDisplayMap(); + // wait for something todo .. + synchronized(displayMap) { + while(!shouldStop && displayMap.size()==0) { + try { + displayMap.wait(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + + Iterator iter = Display.getCurrentDisplays().iterator(); + while(iter.hasNext()) { + Display display = (Display) iter.next(); + Iterator iterDA = displayActions.iterator(); + while(iterDA.hasNext()) { + ((Display.Action)iterDA.next()).run(display); + } + } + } + synchronized(taskWorkerLock) { + isRunning = false; + taskWorkerLock.notifyAll(); + } + } +} diff --git a/src/newt/classes/com/sun/javafx/newt/Window.java b/src/newt/classes/com/sun/javafx/newt/Window.java index 68cb97834..36eafd32d 100755 --- a/src/newt/classes/com/sun/javafx/newt/Window.java +++ b/src/newt/classes/com/sun/javafx/newt/Window.java @@ -137,27 +137,6 @@ public abstract class Window implements NativeWindow return screen; } - /** - * eventMask is a bitfield of EventListener event flags - */ - public void pumpMessages(int eventMask) { - if(this.eventMask!=eventMask && eventMask>0) { - this.eventMask=eventMask; - eventMask*=-1; - } - dispatchMessages(eventMask); - } - - public void pumpMessages() { - int em = 0; - if(windowListeners.size()>0) em |= EventListener.WINDOW; - if(mouseListeners.size()>0) em |= EventListener.MOUSE; - if(keyListeners.size()>0) em |= EventListener.KEY; - pumpMessages(em); - } - - protected abstract void dispatchMessages(int eventMask); - public String toString() { StringBuffer sb = new StringBuffer(); @@ -438,6 +417,9 @@ public abstract class Window implements NativeWindow protected void sendMouseEvent(int eventType, int modifiers, int x, int y, int button, int rotation) { + if(x<0||y<0||x>=width||y>=height) { + return; // .. invalid .. + } if(DEBUG_MOUSE_EVENT) { System.out.println("sendMouseEvent: "+MouseEvent.getEventTypeString(eventType)+ ", mod "+modifiers+", pos "+x+"/"+y+", button "+button); diff --git a/src/newt/classes/com/sun/javafx/newt/awt/AWTDisplay.java b/src/newt/classes/com/sun/javafx/newt/awt/AWTDisplay.java index 099125630..19f3ed1a8 100644 --- a/src/newt/classes/com/sun/javafx/newt/awt/AWTDisplay.java +++ b/src/newt/classes/com/sun/javafx/newt/awt/AWTDisplay.java @@ -33,10 +33,12 @@ package com.sun.javafx.newt.awt; -import java.awt.*; -import com.sun.javafx.newt.*; +import java.awt.event.*; +import com.sun.javafx.newt.Display; +import com.sun.javafx.newt.Window; import javax.media.nativewindow.*; import javax.media.nativewindow.awt.*; +import java.util.*; public class AWTDisplay extends Display { public AWTDisplay() { @@ -51,4 +53,116 @@ public class AWTDisplay extends Display { } protected void closeNative() { } + + public void dispatchMessages() { + AWTEventWrapper w; + do { + synchronized(this) { + if (!events.isEmpty()) { + w = (AWTEventWrapper) events.removeFirst(); + } else { + w = null; + } + } + if (w != null) { + switch (w.getType()) { + case com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_RESIZED: + case com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_MOVED: + case com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_DESTROY_NOTIFY: + w.getWindow().sendWindowEvent(w.getType()); + break; + + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_CLICKED: + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_ENTERED: + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_EXITED: + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_PRESSED: + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_RELEASED: + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_MOVED: + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_DRAGGED: + case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_WHEEL_MOVED: + { + MouseEvent e = (MouseEvent) w.getEvent(); + int rotation = 0; + if (e instanceof MouseWheelEvent) { + rotation = ((MouseWheelEvent)e).getWheelRotation(); + } + w.getWindow().sendMouseEvent(w.getType(), convertModifiers(e), + e.getX(), e.getY(), convertButton(e), + rotation); + } + break; + + case com.sun.javafx.newt.KeyEvent.EVENT_KEY_PRESSED: + case com.sun.javafx.newt.KeyEvent.EVENT_KEY_RELEASED: + case com.sun.javafx.newt.KeyEvent.EVENT_KEY_TYPED: + { + KeyEvent e = (KeyEvent) w.getEvent(); + w.getWindow().sendKeyEvent(w.getType(), convertModifiers(e), + e.getKeyCode(), e.getKeyChar()); + } + break; + + default: + throw new NativeWindowException("Unknown event type " + w.getType()); + } + if(Window.DEBUG_MOUSE_EVENT) { + System.out.println("dispatchMessages: "+w.getWindow()+" in event:"+w.getEvent()); + } + } + } while (w != null); + } + + protected void enqueueEvent(AWTWindow w, int type, InputEvent e) { + AWTEventWrapper wrapper = new AWTEventWrapper(w, type, e); + synchronized(this) { + events.add(wrapper); + } + } + + private LinkedList/*<AWTEventWrapper>*/ events = new LinkedList(); + + static class AWTEventWrapper { + AWTWindow window; + int type; + InputEvent e; + + AWTEventWrapper(AWTWindow w, int type, InputEvent e) { + this.window = w; + this.type = type; + this.e = e; + } + + public AWTWindow getWindow() { + return window; + } + + public int getType() { + return type; + } + + public InputEvent getEvent() { + return e; + } + } + + private static int convertModifiers(InputEvent e) { + int newtMods = 0; + int mods = e.getModifiers(); + if ((mods & InputEvent.SHIFT_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.SHIFT_MASK; + if ((mods & InputEvent.CTRL_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.CTRL_MASK; + if ((mods & InputEvent.META_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.META_MASK; + if ((mods & InputEvent.ALT_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.ALT_MASK; + if ((mods & InputEvent.ALT_GRAPH_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.ALT_GRAPH_MASK; + return newtMods; + } + + private static int convertButton(MouseEvent e) { + switch (e.getButton()) { + case MouseEvent.BUTTON1: return com.sun.javafx.newt.MouseEvent.BUTTON1; + case MouseEvent.BUTTON2: return com.sun.javafx.newt.MouseEvent.BUTTON2; + case MouseEvent.BUTTON3: return com.sun.javafx.newt.MouseEvent.BUTTON3; + } + return 0; + } + } diff --git a/src/newt/classes/com/sun/javafx/newt/awt/AWTWindow.java b/src/newt/classes/com/sun/javafx/newt/awt/AWTWindow.java index 3742a0e57..a425386a3 100644 --- a/src/newt/classes/com/sun/javafx/newt/awt/AWTWindow.java +++ b/src/newt/classes/com/sun/javafx/newt/awt/AWTWindow.java @@ -63,7 +63,6 @@ public class AWTWindow extends Window { private Frame frame; private AWTCanvas canvas; - private LinkedList/*<AWTEventWrapper>*/ events = new LinkedList(); // non fullscreen dimensions .. private int nfs_width, nfs_height, nfs_x, nfs_y; @@ -80,13 +79,15 @@ public class AWTWindow extends Window { protected void createNative(final Capabilities caps) { + final AWTWindow awtWindow = this; + runOnEDT(true, new Runnable() { public void run() { frame = new Frame(getTitle()); frame.setUndecorated(isUndecorated()); frame.setLayout(new BorderLayout()); canvas = new AWTCanvas(caps); - Listener listener = new Listener(); + Listener listener = new Listener(awtWindow); canvas.addMouseListener(listener); canvas.addMouseMotionListener(listener); canvas.addKeyListener(listener); @@ -94,8 +95,8 @@ public class AWTWindow extends Window { frame.add(canvas, BorderLayout.CENTER); frame.setSize(width, height); frame.setLocation(x, y); - frame.addComponentListener(new MoveListener()); - frame.addWindowListener(new WindowEventListener()); + frame.addComponentListener(new MoveListener(awtWindow)); + frame.addWindowListener(new WindowEventListener(awtWindow)); } }); } @@ -216,84 +217,17 @@ public class AWTWindow extends Window { return canvas; } - public void dispatchMessages(int eventMask) { - AWTEventWrapper w; - do { - synchronized(this) { - if (!events.isEmpty()) { - w = (AWTEventWrapper) events.removeFirst(); - } else { - w = null; - } - } - if (w != null) { - switch (w.getType()) { - case com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_RESIZED: - case com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_MOVED: - case com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_DESTROY_NOTIFY: - if ((eventMask & com.sun.javafx.newt.EventListener.WINDOW) != 0) { - sendWindowEvent(w.getType()); - } - break; - - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_CLICKED: - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_ENTERED: - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_EXITED: - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_PRESSED: - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_RELEASED: - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_MOVED: - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_DRAGGED: - case com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_WHEEL_MOVED: - if ((eventMask & com.sun.javafx.newt.EventListener.MOUSE) != 0) { - MouseEvent e = (MouseEvent) w.getEvent(); - int rotation = 0; - if (e instanceof MouseWheelEvent) { - rotation = ((MouseWheelEvent)e).getWheelRotation(); - } - sendMouseEvent(w.getType(), convertModifiers(e), - e.getX(), e.getY(), convertButton(e), - rotation); - } - break; - - case com.sun.javafx.newt.KeyEvent.EVENT_KEY_PRESSED: - case com.sun.javafx.newt.KeyEvent.EVENT_KEY_RELEASED: - case com.sun.javafx.newt.KeyEvent.EVENT_KEY_TYPED: - if ((eventMask & com.sun.javafx.newt.EventListener.KEY) != 0) { - KeyEvent e = (KeyEvent) w.getEvent(); - sendKeyEvent(w.getType(), convertModifiers(e), - e.getKeyCode(), e.getKeyChar()); - } - break; - - default: - throw new NativeWindowException("Unknown event type " + w.getType()); - } - if(Window.DEBUG_MOUSE_EVENT) { - System.out.println("dispatchMessages: in event:"+w.getEvent()); - } - } - } while (w != null); + protected void sendWindowEvent(int eventType) { + super.sendWindowEvent(eventType); } - private static int convertModifiers(InputEvent e) { - int newtMods = 0; - int mods = e.getModifiers(); - if ((mods & InputEvent.SHIFT_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.SHIFT_MASK; - if ((mods & InputEvent.CTRL_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.CTRL_MASK; - if ((mods & InputEvent.META_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.META_MASK; - if ((mods & InputEvent.ALT_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.ALT_MASK; - if ((mods & InputEvent.ALT_GRAPH_MASK) != 0) newtMods |= com.sun.javafx.newt.InputEvent.ALT_GRAPH_MASK; - return newtMods; + protected void sendKeyEvent(int eventType, int modifiers, int keyCode, char keyChar) { + super.sendKeyEvent(eventType, modifiers, keyCode, keyChar); } - private static int convertButton(MouseEvent e) { - switch (e.getButton()) { - case MouseEvent.BUTTON1: return com.sun.javafx.newt.MouseEvent.BUTTON1; - case MouseEvent.BUTTON2: return com.sun.javafx.newt.MouseEvent.BUTTON2; - case MouseEvent.BUTTON3: return com.sun.javafx.newt.MouseEvent.BUTTON3; - } - return 0; + protected void sendMouseEvent(int eventType, int modifiers, + int x, int y, int button, int rotation) { + super.sendMouseEvent(eventType, modifiers, x, y, button, rotation); } private static void runOnEDT(boolean wait, Runnable r) { @@ -312,43 +246,26 @@ public class AWTWindow extends Window { } } - private void enqueueEvent(int type, InputEvent e) { - AWTEventWrapper wrapper = new AWTEventWrapper(type, e); - synchronized(this) { - events.add(wrapper); - } - } - private static final int WINDOW_EVENT = 1; private static final int KEY_EVENT = 2; private static final int MOUSE_EVENT = 3; - static class AWTEventWrapper { - int type; - InputEvent e; - - AWTEventWrapper(int type, InputEvent e) { - this.type = type; - this.e = e; - } - - public int getType() { - return type; - } + class MoveListener implements ComponentListener { + private AWTWindow window; + private AWTDisplay display; - public InputEvent getEvent() { - return e; + public MoveListener(AWTWindow w) { + window = w; + display = (AWTDisplay)window.getScreen().getDisplay(); } - } - class MoveListener implements ComponentListener { public void componentResized(ComponentEvent e) { } public void componentMoved(ComponentEvent e) { x = frame.getX(); y = frame.getY(); - enqueueEvent(com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_MOVED, null); + display.enqueueEvent(window, com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_MOVED, null); } public void componentShown(ComponentEvent e) { @@ -360,10 +277,18 @@ public class AWTWindow extends Window { } class Listener implements ComponentListener, MouseListener, MouseMotionListener, KeyListener { + private AWTWindow window; + private AWTDisplay display; + + public Listener(AWTWindow w) { + window = w; + display = (AWTDisplay)window.getScreen().getDisplay(); + } + public void componentResized(ComponentEvent e) { width = canvas.getWidth(); height = canvas.getHeight(); - enqueueEvent(com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_RESIZED, null); + display.enqueueEvent(window, com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_RESIZED, null); } public void componentMoved(ComponentEvent e) { @@ -381,49 +306,57 @@ public class AWTWindow extends Window { } public void mouseEntered(MouseEvent e) { - enqueueEvent(com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_ENTERED, e); + display.enqueueEvent(window, com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_ENTERED, e); } public void mouseExited(MouseEvent e) { - enqueueEvent(com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_EXITED, e); + display.enqueueEvent(window, com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_EXITED, e); } public void mousePressed(MouseEvent e) { - enqueueEvent(com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_PRESSED, e); + display.enqueueEvent(window, com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_PRESSED, e); } public void mouseReleased(MouseEvent e) { - enqueueEvent(com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_RELEASED, e); + display.enqueueEvent(window, com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_RELEASED, e); } public void mouseMoved(MouseEvent e) { - enqueueEvent(com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_MOVED, e); + display.enqueueEvent(window, com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_MOVED, e); } public void mouseDragged(MouseEvent e) { - enqueueEvent(com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_DRAGGED, e); + display.enqueueEvent(window, com.sun.javafx.newt.MouseEvent.EVENT_MOUSE_DRAGGED, e); } public void keyPressed(KeyEvent e) { - enqueueEvent(com.sun.javafx.newt.KeyEvent.EVENT_KEY_PRESSED, e); + display.enqueueEvent(window, com.sun.javafx.newt.KeyEvent.EVENT_KEY_PRESSED, e); } public void keyReleased(KeyEvent e) { - enqueueEvent(com.sun.javafx.newt.KeyEvent.EVENT_KEY_RELEASED, e); + display.enqueueEvent(window, com.sun.javafx.newt.KeyEvent.EVENT_KEY_RELEASED, e); } public void keyTyped(KeyEvent e) { - enqueueEvent(com.sun.javafx.newt.KeyEvent.EVENT_KEY_TYPED, e); + display.enqueueEvent(window, com.sun.javafx.newt.KeyEvent.EVENT_KEY_TYPED, e); } } class WindowEventListener implements WindowListener { + private AWTWindow window; + private AWTDisplay display; + + public WindowEventListener(AWTWindow w) { + window = w; + display = (AWTDisplay)window.getScreen().getDisplay(); + } + public void windowActivated(WindowEvent e) { } public void windowClosed(WindowEvent e) { } public void windowClosing(WindowEvent e) { - enqueueEvent(com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_DESTROY_NOTIFY, null); + display.enqueueEvent(window, com.sun.javafx.newt.WindowEvent.EVENT_WINDOW_DESTROY_NOTIFY, null); } public void windowDeactivated(WindowEvent e) { } diff --git a/src/newt/classes/com/sun/javafx/newt/macosx/MacDisplay.java b/src/newt/classes/com/sun/javafx/newt/macosx/MacDisplay.java index 29b7151f4..63b7fe78c 100755 --- a/src/newt/classes/com/sun/javafx/newt/macosx/MacDisplay.java +++ b/src/newt/classes/com/sun/javafx/newt/macosx/MacDisplay.java @@ -33,17 +33,55 @@ package com.sun.javafx.newt.macosx; -import com.sun.javafx.newt.*; import javax.media.nativewindow.*; import javax.media.nativewindow.macosx.*; +import com.sun.javafx.newt.*; +import com.sun.javafx.newt.impl.*; +import com.sun.javafx.newt.util.MainThread; public class MacDisplay extends Display { + static { + initSingleton(); + } + + private static volatile boolean isInit = false; + + public static synchronized void initSingleton() { + if(isInit) return; + isInit=true; + + NativeLibLoader.loadNEWT(); + + if(!initNSApplication()) { + throw new NativeWindowException("Failed to initialize native Application hook"); + } + if(!MacWindow.initIDs()) { + throw new NativeWindowException("Failed to initialize jmethodIDs"); + } + if(DEBUG) System.out.println("MacDisplay.init App and IDs OK "+Thread.currentThread().getName()); + } + public MacDisplay() { } + class DispatchAction implements Runnable { + public void run() { + dispatchMessages0(); + } + } + private DispatchAction dispatchAction = new DispatchAction(); + + public void dispatchMessages() { + MainThread.invoke(false, dispatchAction); + } + protected void createNative() { aDevice = new MacOSXGraphicsDevice(); } protected void closeNative() { } + + private static native boolean initNSApplication(); + protected native void dispatchMessages0(); } + diff --git a/src/newt/classes/com/sun/javafx/newt/macosx/MacScreen.java b/src/newt/classes/com/sun/javafx/newt/macosx/MacScreen.java index 06ef8aacd..8983b8803 100755 --- a/src/newt/classes/com/sun/javafx/newt/macosx/MacScreen.java +++ b/src/newt/classes/com/sun/javafx/newt/macosx/MacScreen.java @@ -37,14 +37,20 @@ import com.sun.javafx.newt.*; import javax.media.nativewindow.*; public class MacScreen extends Screen { + static { + MacDisplay.initSingleton(); + } + public MacScreen() { - MacWindow.initSingleton(); } protected void createNative(int index) { aScreen = new DefaultGraphicsScreen(getDisplay().getGraphicsDevice(), index); - setScreenSize(MacWindow.getScreenWidth(getIndex()), MacWindow.getScreenHeight(getIndex())); + setScreenSize(getWidthImpl(getIndex()), getHeightImpl(getIndex())); } protected void closeNative() { } + + private static native int getWidthImpl(int scrn_idx); + private static native int getHeightImpl(int scrn_idx); } diff --git a/src/newt/classes/com/sun/javafx/newt/macosx/MacWindow.java b/src/newt/classes/com/sun/javafx/newt/macosx/MacWindow.java index 2c1ca7c89..704b578c4 100755 --- a/src/newt/classes/com/sun/javafx/newt/macosx/MacWindow.java +++ b/src/newt/classes/com/sun/javafx/newt/macosx/MacWindow.java @@ -41,8 +41,6 @@ import com.sun.javafx.newt.impl.*; public class MacWindow extends Window { - private static native boolean initIDs(); - // Window styles private static final int NSBorderlessWindowMask = 0; private static final int NSTitledWindowMask = 1 << 0; @@ -129,31 +127,14 @@ public class MacWindow extends Window { private static final int NSHelpFunctionKey = 0xF746; private static final int NSModeSwitchFunctionKey = 0xF747; - // sync the MacOSX resources .. NSView, ie toggle fullscreen, window create - private Object nsViewLock = new Object(); - private volatile long surfaceHandle; // non fullscreen dimensions .. private int nfs_width, nfs_height, nfs_x, nfs_y; static { - initSingleton(); + MacDisplay.initSingleton(); } - private static volatile boolean isInit = false; - - public static synchronized void initSingleton() { - if(isInit) return; - isInit=true; - - NativeLibLoader.loadNEWT(); - - if(!initIDs()) { - throw new NativeWindowException("Failed to initialize jmethodIDs"); - } - if(DEBUG_IMPLEMENTATION) System.out.println("MacWindow.initIDs OK "+Thread.currentThread().getName()); - } - public MacWindow() { } @@ -166,12 +147,15 @@ public class MacWindow extends Window { class CloseAction implements Runnable { public void run() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { if(DEBUG_IMPLEMENTATION) System.out.println("MacWindow.CloseAction "+Thread.currentThread().getName()); if (windowHandle != 0) { close0(windowHandle); windowHandle = 0; } + } finally { + nsViewLock.unlock(); } } } @@ -182,20 +166,70 @@ public class MacWindow extends Window { } public long getWindowHandle() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { return windowHandle; + } finally { + nsViewLock.unlock(); } } public long getSurfaceHandle() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { return surfaceHandle; + } finally { + nsViewLock.unlock(); } } + private ToolkitLock nsViewLock = new ToolkitLock() { + private Thread owner; + private int recursionCount; + + public synchronized void lock() { + Thread cur = Thread.currentThread(); + if (owner == cur) { + ++recursionCount; + return; + } + while (owner != null) { + try { + wait(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + owner = cur; + } + + public synchronized void unlock() { + if (owner != Thread.currentThread()) { + throw new RuntimeException("Not owner"); + } + if (recursionCount > 0) { + --recursionCount; + return; + } + owner = null; + notifyAll(); + } + }; + + public synchronized int lockSurface() throws NativeWindowException { + nsViewLock.lock(); + return super.lockSurface(); + } + + public void unlockSurface() { + super.unlockSurface(); + nsViewLock.unlock(); + } + class VisibleAction implements Runnable { public void run() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { if(DEBUG_IMPLEMENTATION) System.out.println("MacWindow.VisibleAction "+visible+" "+Thread.currentThread().getName()); if (visible) { createWindow(false); @@ -204,6 +238,8 @@ public class MacWindow extends Window { orderOut(windowHandle); } } + } finally { + nsViewLock.unlock(); } } } @@ -216,10 +252,13 @@ public class MacWindow extends Window { class TitleAction implements Runnable { public void run() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { if (windowHandle != 0) { setTitle0(windowHandle, title); } + } finally { + nsViewLock.unlock(); } } } @@ -232,10 +271,13 @@ public class MacWindow extends Window { class FocusAction implements Runnable { public void run() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { if (windowHandle != 0) { makeKey(windowHandle); } + } finally { + nsViewLock.unlock(); } } } @@ -248,10 +290,13 @@ public class MacWindow extends Window { class SizeAction implements Runnable { public void run() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { if (windowHandle != 0) { setContentSize(windowHandle, width, height); } + } finally { + nsViewLock.unlock(); } } } @@ -269,10 +314,13 @@ public class MacWindow extends Window { class PositionAction implements Runnable { public void run() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { if (windowHandle != 0) { setFrameTopLeftPoint(windowHandle, x, y); } + } finally { + nsViewLock.unlock(); } } } @@ -288,26 +336,16 @@ public class MacWindow extends Window { MainThread.invoke(true, positionAction); } - class DispatchAction implements Runnable { - public void run() { - dispatchMessages0(windowHandle, eventMask); - } - } - private DispatchAction dispatchAction = new DispatchAction(); - private int eventMask; - - public void dispatchMessages(int eventMask) { - this.eventMask=eventMask; - MainThread.invoke(false, dispatchAction); - } - class FullscreenAction implements Runnable { public void run() { - synchronized(nsViewLock) { + nsViewLock.lock(); + try { if(DEBUG_IMPLEMENTATION || DEBUG_WINDOW_EVENT) { System.err.println("MacWindow fs: "+fullscreen+" "+x+"/"+y+" "+width+"x"+height); } createWindow(true); + } finally { + nsViewLock.unlock(); } } } @@ -495,6 +533,7 @@ public class MacWindow extends Window { sendWindowEvent(WindowEvent.EVENT_WINDOW_GAINED_FOCUS); } + protected static native boolean initIDs(); private native long createWindow0(int x, int y, int w, int h, boolean fullscreen, int windowStyle, int backingStoreType, @@ -504,11 +543,8 @@ public class MacWindow extends Window { private native void orderOut(long window); private native void close0(long window); private native void setTitle0(long window, String title); - protected native void dispatchMessages0(long window, int eventMask); private native long contentView(long window); private native long changeContentView(long window, long view); private native void setContentSize(long window, int w, int h); private native void setFrameTopLeftPoint(long window, int x, int y); - protected static native int getScreenWidth(int scrn_idx); - protected static native int getScreenHeight(int scrn_idx); } diff --git a/src/newt/classes/com/sun/javafx/newt/opengl/GLWindow.java b/src/newt/classes/com/sun/javafx/newt/opengl/GLWindow.java index 5d50792db..8ecfe6216 100644 --- a/src/newt/classes/com/sun/javafx/newt/opengl/GLWindow.java +++ b/src/newt/classes/com/sun/javafx/newt/opengl/GLWindow.java @@ -37,6 +37,7 @@ import com.sun.javafx.newt.*; import javax.media.nativewindow.*; import javax.media.opengl.*; import com.sun.opengl.impl.GLDrawableHelper; +import java.util.*; /** * An implementation of {@link Window} which is customized for OpenGL @@ -44,13 +45,20 @@ import com.sun.opengl.impl.GLDrawableHelper; * javax.media.opengl.GLAutoDrawable} interface. For convenience, this * window class guarantees that its OpenGL context is current inside * the various EventListeners' callbacks (MouseListener, KeyListener, - * etc.). + * etc.).<P> + * + * Best performance is currently achieved with default settings, + * {@link #setEventHandlerMode} to {@link #EVENT_HANDLER_GL_NONE} + * and one thread per GLWindow. To ensure compatibility with the + * underlying platform, window shall also be created within your + * working thread. See comment at {@link #setRunPumpMessages}. */ public class GLWindow extends Window implements GLAutoDrawable { /** * Event handling mode: EVENT_HANDLER_GL_NONE. * No GL context is current, while calling the EventListener. * This might be inconvenient, but don't impact the performance. + * Also * * @see com.sun.javafx.newt.GLWindow#setEventHandlerMode(int) */ @@ -68,7 +76,10 @@ public class GLWindow extends Window implements GLAutoDrawable { */ public static final int EVENT_HANDLER_GL_CURRENT = (1 << 0); + private static List/*GLWindow*/ glwindows = new ArrayList(); + private Window window; + private boolean runPumpMessages = true; /** Constructor. Do not call this directly -- use {@link create()} instead. */ @@ -94,6 +105,10 @@ public class GLWindow extends Window implements GLAutoDrawable { sendDestroy = true; } }); + + List newglw = (List) ((ArrayList) glwindows).clone(); + newglw.add(this); + glwindows=newglw; } /** Creates a new GLWindow on the local display, screen 0, with a @@ -132,10 +147,11 @@ public class GLWindow extends Window implements GLAutoDrawable { caps = new GLCapabilities(null); // default .. } + Display display; boolean ownerOfDisplayAndScreen=false; if (window == null) { ownerOfDisplayAndScreen = true; - Display display = NewtFactory.createDisplay(null); // local display + display = NewtFactory.createDisplay(null); // local display Screen screen = NewtFactory.createScreen(display, 0); // screen 0 window = NewtFactory.createWindow(screen, caps, undecorated); } @@ -143,6 +159,24 @@ public class GLWindow extends Window implements GLAutoDrawable { return new GLWindow(window, ownerOfDisplayAndScreen); } + /** + * EXPERIMENTAL<br> + * Enable or disables running the {@link Display#pumpMessages} in the {@link #display()} call.<br> + * The default behavior is to run {@link Display#pumpMessages}.<P> + * + * The idea was that in a single threaded environment with one {@link Display} and many {@link Window}'s, + * a performance benefit was expected while disabling the implicit {@link Display#pumpMessages} and + * do it once via {@link GLWindow#runCurrentThreadPumpMessage()} <br> + * This could not have been verified. No measurable difference could have been recognized.<P> + * + * Best performance has been achieved with one GLWindow per thread.<br> + * + * @deprecated EXPERIMENTAL, semantic is about to be removed after further verification. + */ + public void setRunPumpMessages(boolean onoff) { + runPumpMessages = onoff; + } + protected void createNative(Capabilities caps) { shouldNotCallThis(); } @@ -202,6 +236,10 @@ public class GLWindow extends Window implements GLAutoDrawable { e1.printStackTrace(); } + List newglw = (List) ((ArrayList) glwindows).clone(); + newglw.remove(this); + glwindows=newglw; + dispose(false); Screen _screen = null; @@ -251,57 +289,7 @@ public class GLWindow extends Window implements GLAutoDrawable { public int getEventHandlerMode() { return eventHandlerMode; } - - public void pumpMessages(int eventMask) { - if( 0 == (eventHandlerMode & EVENT_HANDLER_GL_CURRENT) ) { - window.pumpMessages(eventMask); - } else { - pumpMessagesWithEventMaskAction.eventMask = eventMask; - pumpMessagesImpl(pumpMessagesWithEventMaskAction); - } - } - - public void pumpMessages() { - if( 0 == (eventHandlerMode & EVENT_HANDLER_GL_CURRENT) ) { - window.pumpMessages(); - } else { - pumpMessagesImpl(pumpMessagesAction); - } - } - - class PumpMessagesWithEventMaskAction implements Runnable { - private int eventMask; - - public void run() { - window.pumpMessages(eventMask); - } - } - private PumpMessagesWithEventMaskAction pumpMessagesWithEventMaskAction = new PumpMessagesWithEventMaskAction(); - - class PumpMessagesAction implements Runnable { - public void run() { - window.pumpMessages(); - } - } - private PumpMessagesAction pumpMessagesAction = new PumpMessagesAction(); - - private void pumpMessagesImpl(Runnable pumpMessagesAction) { - // pumpMessagesAction.run(); - - boolean autoSwapBuffer = helper.getAutoSwapBufferMode(); - helper.setAutoSwapBufferMode(false); - try { - helper.invokeGL(drawable, context, pumpMessagesAction, initAction); - } finally { - helper.setAutoSwapBufferMode(autoSwapBuffer); - } - - } - - protected void dispatchMessages(int eventMask) { - shouldNotCallThis(); - } - + public void setVisible(boolean visible) { window.setVisible(visible); if (visible && context == null) { @@ -423,7 +411,8 @@ public class GLWindow extends Window implements GLAutoDrawable { // OpenGL-related methods and state // - private int eventHandlerMode = EVENT_HANDLER_GL_CURRENT; + private static int eventHandlerMode = EVENT_HANDLER_GL_CURRENT; + private static boolean autoSwapBufferMode = true; private GLDrawableFactory factory; private GLDrawable drawable; private GLContext context; @@ -466,9 +455,69 @@ public class GLWindow extends Window implements GLAutoDrawable { helper.removeGLEventListener(listener); } + class DisplayPumpMessage implements Display.Action { + public void run(Display display) { + if( 0 == (eventHandlerMode & EVENT_HANDLER_GL_CURRENT) ) { + display.run(); + } else { + helper.setAutoSwapBufferMode(false); + try { + helper.invokeGL(drawable, context, display, initAction); + } finally { + helper.setAutoSwapBufferMode(autoSwapBufferMode); + } + } + } + } + private DisplayPumpMessage displayPumpMessage = new DisplayPumpMessage(); + + static class DisplayPumpMessageStatic implements Display.Action { + public void run(Display display) { + display.run(); + } + } + private static DisplayPumpMessageStatic displayPumpMessageStatic = new DisplayPumpMessageStatic(); + + /** + * @see #setRunPumpMessages + * @deprecated EXPERIMENTAL, semantic is about to be removed after further verification. + */ + public static void runCurrentThreadPumpMessage() { + Exception safedE = null; + + if( 0 != (eventHandlerMode & EVENT_HANDLER_GL_CURRENT) ) { + // for all: setup / init / makeCurrent + for(Iterator i = glwindows.iterator(); i.hasNext(); ) { + GLWindow glw = (GLWindow) i.next(); + glw.helper.setAutoSwapBufferMode(false); + glw.helper.invokeGL(glw.drawable, glw.context, null, glw.initAction); + } + } + + try { + Display.runCurrentThreadDisplaysAction(displayPumpMessageStatic); + } catch (Exception e) { + safedE=e; + } + + if( 0 != (eventHandlerMode & EVENT_HANDLER_GL_CURRENT) ) { + // for all: reset + for(Iterator i = glwindows.iterator(); i.hasNext(); ) { + GLWindow glw = (GLWindow) i.next(); + glw.helper.setAutoSwapBufferMode(autoSwapBufferMode); + } + } + + if(null!=safedE) { + throw new GLException(safedE); + } + } + public void display() { if(getSurfaceHandle()!=0) { - pumpMessages(); + if(runPumpMessages) { + displayPumpMessage.run(window.getScreen().getDisplay()); + } if(window.hasDeviceChanged() && GLAutoDrawable.SCREEN_CHANGE_ACTION_ENABLED) { dispose(true); } @@ -487,12 +536,14 @@ public class GLWindow extends Window implements GLAutoDrawable { } } + /** This implementation uses a static value */ public void setAutoSwapBufferMode(boolean onOrOff) { - helper.setAutoSwapBufferMode(onOrOff); + autoSwapBufferMode = onOrOff; } + /** This implementation uses a static value */ public boolean getAutoSwapBufferMode() { - return helper.getAutoSwapBufferMode(); + return autoSwapBufferMode; } public void swapBuffers() { @@ -555,6 +606,7 @@ public class GLWindow extends Window implements GLAutoDrawable { } } } + private DisplayAction displayAction = new DisplayAction(); public long getStartTime() { return startTime; } public long getCurrentTime() { return curTime; } @@ -567,14 +619,11 @@ public class GLWindow extends Window implements GLAutoDrawable { private int totalFrames = 0, lastFrames = 0; private boolean ownerOfDisplayAndScreen; - private DisplayAction displayAction = new DisplayAction(); - class SwapBuffersAction implements Runnable { public void run() { drawable.swapBuffers(); } } - private SwapBuffersAction swapBuffersAction = new SwapBuffersAction(); //---------------------------------------------------------------------- diff --git a/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDDisplay.java b/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDDisplay.java index a13a95586..64d640d11 100755 --- a/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDDisplay.java +++ b/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDDisplay.java @@ -40,10 +40,25 @@ import javax.media.nativewindow.*; import javax.media.nativewindow.egl.*; public class KDDisplay extends Display { + static { + initSingleton(); + } + + private static volatile boolean isInit = false; + + public static synchronized void initSingleton() { + if(isInit) return; + isInit=true; + NativeLibLoader.loadNEWT(); + + if (!KDWindow.initIDs()) { + throw new NativeWindowException("Failed to initialize KDWindow jmethodIDs"); + } } + public KDDisplay() { } @@ -64,5 +79,11 @@ public class KDDisplay extends Display { EGL.eglTerminate(aDevice.getHandle()); } } + + protected void dispatchMessages() { + DispatchMessages(); + } + + private native void DispatchMessages(); } diff --git a/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDScreen.java b/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDScreen.java index 752a55752..1767c1240 100755 --- a/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDScreen.java +++ b/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDScreen.java @@ -37,6 +37,10 @@ import com.sun.javafx.newt.*; import javax.media.nativewindow.*; public class KDScreen extends Screen { + static { + KDDisplay.initSingleton(); + } + public KDScreen() { } diff --git a/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDWindow.java b/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDWindow.java index 587bf185e..df0134c8e 100755 --- a/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDWindow.java +++ b/src/newt/classes/com/sun/javafx/newt/opengl/kd/KDWindow.java @@ -47,11 +47,7 @@ public class KDWindow extends Window { private int nfs_width, nfs_height, nfs_x, nfs_y; static { - NativeLibLoader.loadNEWT(); - - if (!initIDs()) { - throw new NativeWindowException("Failed to initialize jmethodIDs"); - } + KDDisplay.initSingleton(); } public KDWindow() { @@ -67,8 +63,7 @@ public class KDWindow extends Window { int[] eglAttribs = EGLGraphicsConfiguration.GLCapabilities2AttribList(eglCaps, EGL.EGL_WINDOW_BIT); windowHandle = 0; - windowID = ++_windowID; - eglWindowHandle = CreateWindow(windowID, getDisplayHandle(), eglAttribs); + eglWindowHandle = CreateWindow(getDisplayHandle(), eglAttribs); if (eglWindowHandle == 0) { throw new NativeWindowException("Error creating egl window: "+config); } @@ -78,7 +73,8 @@ public class KDWindow extends Window { protected void closeNative() { if(0!=windowHandleClose) { - CloseWindow(windowHandleClose); + CloseWindow(windowHandleClose, windowUserData); + windowUserData=0; } } @@ -118,22 +114,21 @@ public class KDWindow extends Window { return true; } - protected void dispatchMessages(int eventMask) { - DispatchMessages(windowID, eglWindowHandle, eventMask); - } - //---------------------------------------------------------------------- // Internals only // - private static native boolean initIDs(); - private native long CreateWindow(int owner, long displayHandle, int[] attributes); + protected static native boolean initIDs(); + private native long CreateWindow(long displayHandle, int[] attributes); private native long RealizeWindow(long eglWindowHandle); - private native int CloseWindow(long eglWindowHandle); + private native int CloseWindow(long eglWindowHandle, long userData); private native void setVisible0(long eglWindowHandle, boolean visible); private native void setSize0(long eglWindowHandle, int width, int height); private native void setFullScreen0(long eglWindowHandle, boolean fullscreen); - private native void DispatchMessages(int owner, long eglWindowHandle, int eventMask); + + private void windowCreated(long userData) { + windowUserData=userData; + } private void sizeChanged(int newWidth, int newHeight) { width = newWidth; @@ -149,6 +144,5 @@ public class KDWindow extends Window { private long eglWindowHandle; private long windowHandleClose; - private int windowID; - private static int _windowID = 0; + private long windowUserData; } diff --git a/src/newt/classes/com/sun/javafx/newt/util/MainThread.java b/src/newt/classes/com/sun/javafx/newt/util/MainThread.java index 01604476d..bb3718a83 100644 --- a/src/newt/classes/com/sun/javafx/newt/util/MainThread.java +++ b/src/newt/classes/com/sun/javafx/newt/util/MainThread.java @@ -44,7 +44,7 @@ import javax.media.nativewindow.*; import com.sun.javafx.newt.*; import com.sun.javafx.newt.impl.*; -import com.sun.javafx.newt.macosx.MacWindow; +import com.sun.javafx.newt.macosx.MacDisplay; import com.sun.nativewindow.impl.NWReflection; /** @@ -167,7 +167,7 @@ public class MainThread { mainAction = new MainAction(mainClassName, mainClassArgs); if(NativeWindowFactory.getNativeWindowType(false)==NativeWindowFactory.TYPE_MACOSX) { - MacWindow.initSingleton(); + MacDisplay.initSingleton(); } if ( USE_MAIN_THREAD ) { diff --git a/src/newt/classes/com/sun/javafx/newt/windows/WindowsDisplay.java b/src/newt/classes/com/sun/javafx/newt/windows/WindowsDisplay.java index 436101a35..975281c95 100755 --- a/src/newt/classes/com/sun/javafx/newt/windows/WindowsDisplay.java +++ b/src/newt/classes/com/sun/javafx/newt/windows/WindowsDisplay.java @@ -33,11 +33,35 @@ package com.sun.javafx.newt.windows; -import com.sun.javafx.newt.*; import javax.media.nativewindow.*; import javax.media.nativewindow.windows.*; +import com.sun.javafx.newt.*; +import com.sun.javafx.newt.impl.*; public class WindowsDisplay extends Display { + + protected static final String WINDOW_CLASS_NAME = "NewtWindowClass"; + private static int windowClassAtom; + private static long hInstance; + + static { + initSingleton(); + } + + private static volatile boolean isInit = false; + + public static synchronized void initSingleton() { + if(isInit) return; + isInit=true; + + NativeLibLoader.loadNEWT(); + + if (!WindowsWindow.initIDs()) { + throw new NativeWindowException("Failed to initialize WindowsWindow jmethodIDs"); + } + } + + public WindowsDisplay() { } @@ -45,5 +69,42 @@ public class WindowsDisplay extends Display { aDevice = new WindowsGraphicsDevice(); } - protected void closeNative() { } + protected void closeNative() { + // Can't do .. only at application shutdown + // UnregisterWindowClass(getWindowClassAtom(), getHInstance()); + } + + protected void dispatchMessages() { + DispatchMessages(); + } + + protected static synchronized int getWindowClassAtom() { + if(0 == windowClassAtom) { + windowClassAtom = RegisterWindowClass(WINDOW_CLASS_NAME, getHInstance()); + if (0 == windowClassAtom) { + throw new NativeWindowException("Error while registering window class"); + } + } + return windowClassAtom; + } + + protected static synchronized long getHInstance() { + if(0 == hInstance) { + hInstance = LoadLibraryW("newt"); + if (0 == hInstance) { + throw new NativeWindowException("Error finding HINSTANCE for \"newt\""); + } + } + return hInstance; + } + + //---------------------------------------------------------------------- + // Internals only + // + private static native long LoadLibraryW(String libraryName); + private static native int RegisterWindowClass(String windowClassName, long hInstance); + private static native void UnregisterWindowClass(int wndClassAtom, long hInstance); + + private static native void DispatchMessages(); } + diff --git a/src/newt/classes/com/sun/javafx/newt/windows/WindowsScreen.java b/src/newt/classes/com/sun/javafx/newt/windows/WindowsScreen.java index 828cf4ca0..87ae1b49d 100755 --- a/src/newt/classes/com/sun/javafx/newt/windows/WindowsScreen.java +++ b/src/newt/classes/com/sun/javafx/newt/windows/WindowsScreen.java @@ -39,19 +39,20 @@ import javax.media.nativewindow.*; public class WindowsScreen extends Screen { static { - NativeLibLoader.loadNEWT(); + WindowsDisplay.initSingleton(); } + public WindowsScreen() { } protected void createNative(int index) { aScreen = new DefaultGraphicsScreen(getDisplay().getGraphicsDevice(), index); - setScreenSize(getScreenWidth(getIndex()), getScreenHeight(getIndex())); + setScreenSize(getWidthImpl(getIndex()), getHeightImpl(getIndex())); } protected void closeNative() { } - private native int getScreenWidth(int scrn_idx); - private native int getScreenHeight(int scrn_idx); + private native int getWidthImpl(int scrn_idx); + private native int getHeightImpl(int scrn_idx); } diff --git a/src/newt/classes/com/sun/javafx/newt/windows/WindowsWindow.java b/src/newt/classes/com/sun/javafx/newt/windows/WindowsWindow.java index 273be6653..c42aaa6d9 100755 --- a/src/newt/classes/com/sun/javafx/newt/windows/WindowsWindow.java +++ b/src/newt/classes/com/sun/javafx/newt/windows/WindowsWindow.java @@ -47,11 +47,7 @@ public class WindowsWindow extends Window { private int nfs_width, nfs_height, nfs_x, nfs_y; static { - NativeLibLoader.loadNEWT(); - - if (!initIDs()) { - throw new NativeWindowException("Failed to initialize jmethodIDs"); - } + WindowsDisplay.initSingleton(); } public WindowsWindow() { @@ -96,11 +92,13 @@ public class WindowsWindow extends Window { } protected void createNative(Capabilities caps) { - config = GraphicsConfigurationFactory.getFactory(getScreen().getDisplay().getGraphicsDevice()).chooseGraphicsConfiguration(caps, null, getScreen().getGraphicsScreen()); + WindowsScreen screen = (WindowsScreen) getScreen(); + WindowsDisplay display = (WindowsDisplay) screen.getDisplay(); + config = GraphicsConfigurationFactory.getFactory(display.getGraphicsDevice()).chooseGraphicsConfiguration(caps, null, screen.getGraphicsScreen()); if (config == null) { throw new NativeWindowException("Error choosing GraphicsConfiguration creating window: "+this); } - windowHandle = CreateWindow(getWindowClassAtom(), WINDOW_CLASS_NAME, getHInstance(), 0, undecorated, x, y, width, height); + windowHandle = CreateWindow(display.getWindowClassAtom(), display.WINDOW_CLASS_NAME, display.getHInstance(), 0, undecorated, x, y, width, height); if (windowHandle == 0) { throw new NativeWindowException("Error creating window"); } @@ -121,7 +119,6 @@ public class WindowsWindow extends Window { } protected void windowDestroyed() { - // singleton ATOM CleanupWindowResources(getWindowClassAtom(), getHInstance()); windowHandleClose = 0; super.windowDestroyed(); } @@ -200,50 +197,19 @@ public class WindowsWindow extends Window { } } - protected void dispatchMessages(int eventMask) { - DispatchMessages(windowHandle, eventMask); - } - //---------------------------------------------------------------------- // Internals only // - private static final String WINDOW_CLASS_NAME = "NewtWindowClass"; - - private static int windowClassAtom = 0; - private static synchronized int getWindowClassAtom() { - if(0 == windowClassAtom) { - windowClassAtom = RegisterWindowClass(WINDOW_CLASS_NAME, getHInstance()); - if (windowClassAtom == 0) { - throw new NativeWindowException("Error while registering window class"); - } - } - return windowClassAtom; - } - private static long hInstance; - private static synchronized long getHInstance() { - if (hInstance == 0) { - hInstance = LoadLibraryW("newt"); - if (hInstance == 0) { - throw new NativeWindowException("Error finding HINSTANCE for \"newt\""); - } - } - return hInstance; - } - - private static native boolean initIDs(); - private static native long LoadLibraryW(String libraryName); - private static native int RegisterWindowClass(String windowClassName, long hInstance); + protected static native boolean initIDs(); private native long CreateWindow(int wndClassAtom, String wndName, long hInstance, long visualID, boolean isUndecorated, int x, int y, int width, int height); - private native void CleanupWindowResources(int wndClassAtom, long hInstance); private native void DestroyWindow(long windowHandle); private native long GetDC(long windowHandle); private native void ReleaseDC(long windowHandle, long hdc); private native long MonitorFromWindow(long windowHandle); private static native void setVisible0(long windowHandle, boolean visible); - private static native void DispatchMessages(long windowHandle, int eventMask); private native void setSize0(long windowHandle, int width, int height); private native void setPosition(long windowHandle, int x, int y); private native void setFullscreen0(long windowHandle, int x, int y, int width, int height, boolean isUndecorated, boolean on); diff --git a/src/newt/classes/com/sun/javafx/newt/x11/X11Display.java b/src/newt/classes/com/sun/javafx/newt/x11/X11Display.java index 2371b20e8..99c0f599c 100755 --- a/src/newt/classes/com/sun/javafx/newt/x11/X11Display.java +++ b/src/newt/classes/com/sun/javafx/newt/x11/X11Display.java @@ -40,25 +40,65 @@ import javax.media.nativewindow.x11.*; public class X11Display extends Display { static { + initSingleton(); + } + + private static volatile boolean isInit = false; + + public static synchronized void initSingleton() { + if(isInit) return; + isInit=true; + NativeLibLoader.loadNEWT(); + + if (!initIDs()) { + throw new NativeWindowException("Failed to initialize X11Display jmethodIDs"); + } + + if (!X11Window.initIDs()) { + throw new NativeWindowException("Failed to initialize X11Window jmethodIDs"); + } } + public X11Display() { } protected void createNative() { - long handle = CreateDisplay(name); + long handle= CreateDisplay(name); if (handle == 0 ) { throw new RuntimeException("Error creating display: "+name); } aDevice = new X11GraphicsDevice(handle); } - protected void closeNative() { } + protected void closeNative() { + DestroyDisplay(getHandle()); + } + + protected void dispatchMessages() { + DispatchMessages(getHandle(), javaObjectAtom, windowDeleteAtom); + } + + protected long getJavaObjectAtom() { return javaObjectAtom; } + protected long getWindowDeleteAtom() { return windowDeleteAtom; } //---------------------------------------------------------------------- // Internals only // + private static native boolean initIDs(); private native long CreateDisplay(String name); + private native void DestroyDisplay(long handle); + + private native void DispatchMessages(long display, long javaObjectAtom, long windowDeleteAtom); + + private void displayCreated(long javaObjectAtom, long windowDeleteAtom) { + this.javaObjectAtom=javaObjectAtom; + this.windowDeleteAtom=windowDeleteAtom; + } + + private long windowDeleteAtom; + private long javaObjectAtom; } + diff --git a/src/newt/classes/com/sun/javafx/newt/x11/X11Screen.java b/src/newt/classes/com/sun/javafx/newt/x11/X11Screen.java index 36d9d8baf..cee576e2c 100755 --- a/src/newt/classes/com/sun/javafx/newt/x11/X11Screen.java +++ b/src/newt/classes/com/sun/javafx/newt/x11/X11Screen.java @@ -39,10 +39,12 @@ import javax.media.nativewindow.*; import javax.media.nativewindow.x11.*; public class X11Screen extends Screen { + static { - NativeLibLoader.loadNEWT(); + X11Display.initSingleton(); } + public X11Screen() { } diff --git a/src/newt/classes/com/sun/javafx/newt/x11/X11Window.java b/src/newt/classes/com/sun/javafx/newt/x11/X11Window.java index 3badcce16..bd6bb42c2 100755 --- a/src/newt/classes/com/sun/javafx/newt/x11/X11Window.java +++ b/src/newt/classes/com/sun/javafx/newt/x11/X11Window.java @@ -44,34 +44,34 @@ public class X11Window extends Window { private int nfs_width, nfs_height, nfs_x, nfs_y; static { - NativeLibLoader.loadNEWT(); - - if (!initIDs()) { - throw new NativeWindowException("Failed to initialize jmethodIDs"); - } + X11Display.initSingleton(); } public X11Window() { } protected void createNative(Capabilities caps) { - config = GraphicsConfigurationFactory.getFactory(getScreen().getDisplay().getGraphicsDevice()).chooseGraphicsConfiguration(caps, null, getScreen().getGraphicsScreen()); + X11Screen screen = (X11Screen) getScreen(); + X11Display display = (X11Display) screen.getDisplay(); + config = GraphicsConfigurationFactory.getFactory(display.getGraphicsDevice()).chooseGraphicsConfiguration(caps, null, screen.getGraphicsScreen()); if (config == null) { throw new NativeWindowException("Error choosing GraphicsConfiguration creating window: "+this); } X11GraphicsConfiguration x11config = (X11GraphicsConfiguration) config; long visualID = x11config.getVisualID(); - long w = CreateWindow(getDisplayHandle(), getScreenIndex(), visualID, x, y, width, height); + long w = CreateWindow(display.getHandle(), screen.getIndex(), visualID, + display.getJavaObjectAtom(), display.getWindowDeleteAtom(), x, y, width, height); if (w == 0 || w!=windowHandle) { throw new NativeWindowException("Error creating window: "+w); } windowHandleClose = windowHandle; - displayHandleClose = getDisplayHandle(); + displayHandleClose = display.getHandle(); } protected void closeNative() { if(0!=displayHandleClose && 0!=windowHandleClose) { - CloseWindow(displayHandleClose, windowHandleClose); + X11Display display = (X11Display) getScreen().getDisplay(); + CloseWindow(displayHandleClose, windowHandleClose, display.getJavaObjectAtom()); windowHandleClose = 0; displayHandleClose = 0; } @@ -91,6 +91,10 @@ public class X11Window extends Window { } } + public void requestFocus() { + super.requestFocus(); + } + public void setSize(int width, int height) { if(!fullscreen) { nfs_width=width; @@ -129,20 +133,15 @@ public class X11Window extends Window { return fullscreen; } - protected void dispatchMessages(int eventMask) { - DispatchMessages(getDisplayHandle(), windowHandle, eventMask, windowDeleteAtom); - } - //---------------------------------------------------------------------- // Internals only // - private static native boolean initIDs(); + protected static native boolean initIDs(); private native long CreateWindow(long display, int screen_index, - long visualID, int x, int y, int width, int height); - private native void CloseWindow(long display, long windowHandle); + long visualID, long javaObjectAtom, long windowDeleteAtom, int x, int y, int width, int height); + private native void CloseWindow(long display, long windowHandle, long javaObjectAtom); private native void setVisible0(long display, long windowHandle, boolean visible); - private native void DispatchMessages(long display, long windowHandle, int eventMask, long windowDeleteAtom); private native void setSize0(long display, int screen_index, long windowHandle, int x, int y, int width, int height, int decorationToggle, boolean isVisible); private native void setPosition0(long display, long windowHandle, int x, int y); @@ -167,12 +166,10 @@ public class X11Window extends Window { sendWindowEvent(WindowEvent.EVENT_WINDOW_MOVED); } - private void windowCreated(long windowHandle, long windowDeleteAtom) { + private void windowCreated(long windowHandle) { this.windowHandle = windowHandle; - this.windowDeleteAtom=windowDeleteAtom; } private long windowHandleClose; private long displayHandleClose; - private long windowDeleteAtom; } diff --git a/src/newt/native/KDWindow.c b/src/newt/native/KDWindow.c index d08d5411c..682edff24 100755 --- a/src/newt/native/KDWindow.c +++ b/src/newt/native/KDWindow.c @@ -81,16 +81,121 @@ #endif #endif -/** - * Window - */ - +#define JOGL_KD_USERDATA_MAGIC 0xDEADBEEF +typedef struct { + long magic; + KDWindow * kdWindow; + jobject javaWindow; +} JOGLKDUserdata; + +static jmethodID windowCreatedID = NULL; static jmethodID sizeChangedID = NULL; static jmethodID windowDestroyNotifyID = NULL; static jmethodID windowDestroyedID = NULL; static jmethodID sendMouseEventID = NULL; static jmethodID sendKeyEventID = NULL; +/** + * Display + */ + +JNIEXPORT void JNICALL Java_com_sun_javafx_newt_kd_KDDisplay_DispatchMessages + (JNIEnv *env, jobject obj) +{ + const KDEvent * evt; + int numEvents = 0; + + // Periodically take a break + while( numEvents<100 && NULL!=(evt=kdWaitEvent(0)) ) { + KDWindow *kdWindow; + jobject javaWindow; + JOGLKDUserdata * userData = (JOGLKDUserdata *)(intptr_t)evt->userptr; + if(NULL == userData || userData->magic!=JOGL_KD_USERDATA_MAGIC) { + DBG_PRINT( "event unrelated: evt type: 0x%X\n", evt->type); + continue; + } + kdWindow = userData->kdWindow; + javaWindow = userData->javaWindow; + DBG_PRINT( "[DispatchMessages]: userData %p, evt type: 0x%X\n", userData, evt->type); + + numEvents++; + + // FIXME: support resize and window re-positioning events + + switch(evt->type) { + case KD_EVENT_WINDOW_FOCUS: + { + KDboolean hasFocus; + kdGetWindowPropertybv(kdWindow, KD_WINDOWPROPERTY_FOCUS, &hasFocus); + DBG_PRINT( "event window focus : src: %p\n", userData); + } + break; + case KD_EVENT_WINDOW_CLOSE: + { + DBG_PRINT( "event window close : src: %p\n", userData); + (*env)->CallVoidMethod(env, javaWindow, windowDestroyNotifyID); + // Called by Window.java: DestroyWindow(wnd); + // (*env)->CallVoidMethod(env, javaWindow, windowDestroyedID); + } + break; + case KD_EVENT_WINDOWPROPERTY_CHANGE: + { + const KDEventWindowProperty* prop = &evt->data.windowproperty; + switch (prop->pname) { + case KD_WINDOWPROPERTY_SIZE: + { + KDint32 v[2]; + if(!kdGetWindowPropertyiv(kdWindow, KD_WINDOWPROPERTY_SIZE, v)) { + DBG_PRINT( "event window size change : src: %p %dx%d\n", userData, v[0], v[1]); + (*env)->CallVoidMethod(env, javaWindow, sizeChangedID, (jint) v[0], (jint) v[1]); + } else { + DBG_PRINT( "event window size change error: src: %p %dx%d\n", userData, v[0], v[1]); + } + } + break; + case KD_WINDOWPROPERTY_FOCUS: + DBG_PRINT( "event window focus: src: %p\n", userData); + break; + case KD_WINDOWPROPERTY_VISIBILITY: + { + KDboolean visible; + kdGetWindowPropertybv(kdWindow, KD_WINDOWPROPERTY_VISIBILITY, &visible); + DBG_PRINT( "event window visibility: src: %p, v:%d\n", userData, visible); + } + break; + default: + break; + } + } + break; + case KD_EVENT_INPUT_POINTER: + { + const KDEventInputPointer* ptr = &(evt->data.inputpointer); + // button idx: evt->data.input.index + // pressed = ev->data.input.value.i + // time = ev->timestamp + if(KD_INPUT_POINTER_SELECT==ptr->index) { + DBG_PRINT( "event mouse click: src: %p, s:%d, (%d,%d)\n", userData, ptr->select, ptr->x, ptr->y); + (*env)->CallVoidMethod(env, javaWindow, sendMouseEventID, + (ptr->select==0) ? (jint) EVENT_MOUSE_RELEASED : (jint) EVENT_MOUSE_PRESSED, + (jint) 0, + (jint) ptr->x, (jint) ptr->y, 1, 0); + } else { + DBG_PRINT( "event mouse: src: %d, s:%p, i:0x%X (%d,%d)\n", userData, ptr->select, ptr->index, ptr->x, ptr->y); + (*env)->CallVoidMethod(env, javaWindow, sendMouseEventID, (jint) EVENT_MOUSE_MOVED, + 0, + (jint) ptr->x, (jint) ptr->y, 0, 0); + } + } + break; + } + } +} + +/** + * Window + */ + JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_kd_KDWindow_initIDs (JNIEnv *env, jclass clazz) { @@ -100,12 +205,14 @@ JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_kd_KDWindow_initIDs _wfreopen(TEXT(STDERR_FILE),L"w",stderr); #endif #endif + windowCreatedID = (*env)->GetMethodID(env, clazz, "windowCreated", "(J)V"); sizeChangedID = (*env)->GetMethodID(env, clazz, "sizeChanged", "(II)V"); windowDestroyNotifyID = (*env)->GetMethodID(env, clazz, "windowDestroyNotify", "()V"); windowDestroyedID = (*env)->GetMethodID(env, clazz, "windowDestroyed", "()V"); sendMouseEventID = (*env)->GetMethodID(env, clazz, "sendMouseEvent", "(IIIIII)V"); sendKeyEventID = (*env)->GetMethodID(env, clazz, "sendKeyEvent", "(IIIC)V"); - if (sizeChangedID == NULL || + if (windowCreatedID == NULL || + sizeChangedID == NULL || windowDestroyNotifyID == NULL || windowDestroyedID == NULL || sendMouseEventID == NULL || @@ -118,15 +225,13 @@ JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_kd_KDWindow_initIDs } JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_kd_KDWindow_CreateWindow - (JNIEnv *env, jobject obj, jint owner, jlong display, jintArray jAttrs) + (JNIEnv *env, jobject obj, jlong display, jintArray jAttrs) { jint * attrs = NULL; jsize attrsLen; EGLDisplay dpy = (EGLDisplay)(intptr_t)display; KDWindow *window = 0; - DBG_PRINT( "[CreateWindow]: owner %d\n", owner); - if(dpy==NULL) { fprintf(stderr, "[CreateWindow] invalid display connection..\n"); return 0; @@ -143,15 +248,21 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_kd_KDWindow_CreateWindow return 0; } - /* passing the KDWindow instance for the eventuserptr */ - window = kdCreateWindow(dpy, attrs, (void *)(intptr_t)owner); + JOGLKDUserdata * userData = kdMalloc(sizeof(JOGLKDUserdata)); + userData->magic = JOGL_KD_USERDATA_MAGIC; + window = kdCreateWindow(dpy, attrs, (void *)userData); (*env)->ReleaseIntArrayElements(env, jAttrs, attrs, 0); if(NULL==window) { + kdFree(userData); fprintf(stderr, "[CreateWindow] failed: 0x%X\n", kdGetError()); + } else { + userData->javaWindow = (*env)->NewGlobalRef(env, obj); + userData->kdWindow = window; + (*env)->CallVoidMethod(env, obj, windowCreatedID, (jlong) (intptr_t) userData); + DBG_PRINT( "[CreateWindow] ok: %p, userdata %p\n", window, userData); } - DBG_PRINT( "[CreateWindow] ok: %p, owner %d\n", window, (void *)(intptr_t)owner); return (jlong) (intptr_t) window; } @@ -171,10 +282,13 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_kd_KDWindow_RealizeWindow } JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_kd_KDWindow_CloseWindow - (JNIEnv *env, jobject obj, jlong window) + (JNIEnv *env, jobject obj, jlong window, jlong juserData) { KDWindow *w = (KDWindow*) (intptr_t) window; + JOGLKDUserdata * userData = (JOGLKDUserdata*) (intptr_t) juserData; int res = kdDestroyWindow(w); + (*env)->DeleteGlobalRef(env, userData->javaWindow); + kdFree(userData); DBG_PRINT( "[CloseWindow] res: %d\n", res); return res; @@ -194,120 +308,6 @@ JNIEXPORT void JNICALL Java_com_sun_javafx_newt_kd_KDWindow_setVisible0 DBG_PRINT( "[setVisible] v=%d\n", visible); } -JNIEXPORT void JNICALL Java_com_sun_javafx_newt_kd_KDWindow_DispatchMessages - (JNIEnv *env, jobject obj, jint owner, jlong window, jint eventMask) -{ - KDWindow *w = (KDWindow*) (intptr_t) window; - const KDEvent * evt; - - // Periodically take a break - while( NULL!=(evt=kdWaitEvent(0)) ) { - jint src_owner = (jint)(intptr_t)evt->userptr; - if(src_owner != owner) { - DBG_PRINT( "event unrelated: src: %d, caller: %d, evt type: 0x%X\n", src_owner, owner, evt->type); - continue; - } - DBG_PRINT( "[DispatchMessages]: caller %d, evt type: 0x%X\n", owner, evt->type); - - switch(evt->type) { - case KD_EVENT_INPUT_POINTER: - if( ! ( eventMask & EVENT_MOUSE ) ) { - DBG_PRINT( "event mouse ignored: src: %d\n", owner); - continue; - } - break; - /* - case KeyPress: - case KeyRelease: - if( ! ( eventMask & EVENT_KEY ) ) { - DBG_PRINT( "event key ignored: src: %d\n", owner); - continue; - } - break; - */ - case KD_EVENT_WINDOW_FOCUS: - case KD_EVENT_WINDOW_CLOSE: - case KD_EVENT_WINDOWPROPERTY_CHANGE: - case KD_EVENT_WINDOW_REDRAW: - if( ! ( eventMask & EVENT_WINDOW ) ) { - DBG_PRINT( "event window ignored: src: %d\n", owner); - continue; - } - break; - } - - // FIXME: support resize and window re-positioning events - - switch(evt->type) { - case KD_EVENT_WINDOW_FOCUS: - { - KDboolean hasFocus; - kdGetWindowPropertybv(w, KD_WINDOWPROPERTY_FOCUS, &hasFocus); - DBG_PRINT( "event window focus : src: %d\n", owner); - } - break; - case KD_EVENT_WINDOW_CLOSE: - { - DBG_PRINT( "event window close : src: %d\n", owner); - (*env)->CallVoidMethod(env, obj, windowDestroyNotifyID); - // Called by Window.java: DestroyWindow(wnd); - // (*env)->CallVoidMethod(env, obj, windowDestroyedID); - } - break; - case KD_EVENT_WINDOWPROPERTY_CHANGE: - { - const KDEventWindowProperty* prop = &evt->data.windowproperty; - switch (prop->pname) { - case KD_WINDOWPROPERTY_SIZE: - { - KDint32 v[2]; - if(!kdGetWindowPropertyiv(w, KD_WINDOWPROPERTY_SIZE, v)) { - DBG_PRINT( "event window size change : src: %d %dx%d\n", owner, v[0], v[1]); - (*env)->CallVoidMethod(env, obj, sizeChangedID, (jint) v[0], (jint) v[1]); - } else { - DBG_PRINT( "event window size change error: src: %d %dx%d\n", owner, v[0], v[1]); - } - } - break; - case KD_WINDOWPROPERTY_FOCUS: - DBG_PRINT( "event window focus: src: %d\n", owner); - break; - case KD_WINDOWPROPERTY_VISIBILITY: - { - KDboolean visible; - kdGetWindowPropertybv(w, KD_WINDOWPROPERTY_VISIBILITY, &visible); - DBG_PRINT( "event window visibility: src: %d, v:%d\n", owner, visible); - } - break; - default: - break; - } - } - break; - case KD_EVENT_INPUT_POINTER: - { - const KDEventInputPointer* ptr = &(evt->data.inputpointer); - // button idx: evt->data.input.index - // pressed = ev->data.input.value.i - // time = ev->timestamp - if(KD_INPUT_POINTER_SELECT==ptr->index) { - DBG_PRINT( "event mouse click: src: %d, s:%d, (%d,%d)\n", owner, ptr->select, ptr->x, ptr->y); - (*env)->CallVoidMethod(env, obj, sendMouseEventID, - (ptr->select==0) ? (jint) EVENT_MOUSE_RELEASED : (jint) EVENT_MOUSE_PRESSED, - (jint) 0, - (jint) ptr->x, (jint) ptr->y, 1, 0); - } else { - DBG_PRINT( "event mouse: src: %d, s:%d, i:0x%X (%d,%d)\n", owner, ptr->select, ptr->index, ptr->x, ptr->y); - (*env)->CallVoidMethod(env, obj, sendMouseEventID, (jint) EVENT_MOUSE_MOVED, - 0, - (jint) ptr->x, (jint) ptr->y, 0, 0); - } - } - break; - } - } -} - JNIEXPORT void JNICALL Java_com_sun_javafx_newt_kd_KDWindow_setFullScreen0 (JNIEnv *env, jobject obj, jlong window, jboolean fullscreen) { diff --git a/src/newt/native/MacWindow.m b/src/newt/native/MacWindow.m index f39a9f401..008a2417c 100644 --- a/src/newt/native/MacWindow.m +++ b/src/newt/native/MacWindow.m @@ -85,6 +85,7 @@ NS_ENDHANDLER if(NULL!=newView) { jobject globJavaWindowObject = (*env)->NewGlobalRef(env, javaWindowObject); [newView setJavaWindowObject: globJavaWindowObject]; + [newView setJNIEnv: env]; } [win setContentView: newView]; @@ -92,11 +93,11 @@ NS_ENDHANDLER } /* - * Class: com_sun_javafx_newt_macosx_MacWindow + * Class: com_sun_javafx_newt_macosx_MacDisplay * Method: initIDs * Signature: ()Z */ -JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_initIDs +JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_macosx_MacDisplay_initNSApplication (JNIEnv *env, jclass clazz) { static int initialized = 0; @@ -122,6 +123,109 @@ JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_initIDs // printf("Going to sleep for 10 seconds\n"); // sleep(10); + return (jboolean) JNI_TRUE; +} + +/* + * Class: com_sun_javafx_newt_macosx_MacDisplay + * Method: dispatchMessages0 + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_com_sun_javafx_newt_macosx_MacDisplay_dispatchMessages0 + (JNIEnv *env, jobject unused, jlong window, jint eventMask) +{ + NSEvent* event = NULL; + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + +NS_DURING + + NSWindow* win = NULL; + NewtView* view = NULL; + int num_events = 0; + + // Periodically take a break + do { + // FIXME: ignoring event mask for the time being + event = [NSApp nextEventMatchingMask: NSAnyEventMask + untilDate: [NSDate distantPast] + inMode: NSDefaultRunLoopMode + dequeue: YES]; + if (event != NULL) { + [NSApp sendEvent: event]; + + num_events++; + } + } while (num_events<100 && event != NULL); + +NS_HANDLER + + // just ignore it .. + +NS_ENDHANDLER + + [pool release]; +} + +/* + * Class: com_sun_javafx_newt_macosx_MacScreen + * Method: getWidthImpl + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_macosx_MacScreen_getWidthImpl + (JNIEnv *env, jclass clazz, jint screen_idx) +{ + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + + NSArray *screens = [NSScreen screens]; + if(screen_idx<0) screen_idx=0; + if(screen_idx>=[screens count]) screen_idx=0; + NSScreen *screen = (NSScreen *) [screens objectAtIndex: screen_idx]; + NSRect rect = [screen frame]; + + [pool release]; + + return (jint) (rect.size.width); +} + +/* + * Class: com_sun_javafx_newt_macosx_MacScreen + * Method: getHeightImpl + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_macosx_MacScreen_getHeightImpl + (JNIEnv *env, jclass clazz, jint screen_idx) +{ + NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; + + NSArray *screens = [NSScreen screens]; + if(screen_idx<0) screen_idx=0; + if(screen_idx>=[screens count]) screen_idx=0; + NSScreen *screen = (NSScreen *) [screens objectAtIndex: screen_idx]; + NSRect rect = [screen frame]; + + [pool release]; + + return (jint) (rect.size.height); +} + +/* + * Class: com_sun_javafx_newt_macosx_MacWindow + * Method: initIDs + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_initIDs + (JNIEnv *env, jclass clazz) +{ + static int initialized = 0; + + if(initialized) return JNI_TRUE; + initialized = 1; + + // Need this when debugging, as it is necessary to attach gdb to + // the running java process -- "gdb java" doesn't work + // printf("Going to sleep for 10 seconds\n"); + // sleep(10); + return (jboolean) [NewtMacWindow initNatives: env forClass: clazz]; } @@ -280,51 +384,6 @@ JNIEXPORT void JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_setTitle0 /* * Class: com_sun_javafx_newt_macosx_MacWindow - * Method: dispatchMessages0 - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_dispatchMessages0 - (JNIEnv *env, jobject unused, jlong window, jint eventMask) -{ - NSEvent* event = NULL; - NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; - -NS_DURING - - NSWindow* win = (NSWindow *) ((intptr_t) window); - - if(NULL != win) { - NewtView* view = (NewtView *) [win contentView]; - [view setJNIEnv: env]; - - do { - // FIXME: ignoring event mask for the time being - event = [NSApp nextEventMatchingMask: NSAnyEventMask - untilDate: [NSDate distantPast] - inMode: NSDefaultRunLoopMode - dequeue: YES]; - if (event != NULL) { - win = (NSWindow*) [event window]; - view = (NewtView *) [win contentView]; - [view setJNIEnv: env]; - - [NSApp sendEvent: event]; - } - } while (event != NULL); - } - -NS_HANDLER - - // just ignore it .. - -NS_ENDHANDLER - - - [pool release]; -} - -/* - * Class: com_sun_javafx_newt_macosx_MacWindow * Method: contentView * Signature: (J)J */ @@ -386,45 +445,3 @@ JNIEXPORT void JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_setFrameTopLeft [pool release]; } -/* - * Class: com_sun_javafx_newt_macosx_MacWindow - * Method: getScreenWidth - * Signature: (I)I - */ -JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_getScreenWidth - (JNIEnv *env, jclass clazz, jint screen_idx) -{ - NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; - - NSArray *screens = [NSScreen screens]; - if(screen_idx<0) screen_idx=0; - if(screen_idx>=[screens count]) screen_idx=0; - NSScreen *screen = (NSScreen *) [screens objectAtIndex: screen_idx]; - NSRect rect = [screen frame]; - - [pool release]; - - return (jint) (rect.size.width); -} - -/* - * Class: com_sun_javafx_newt_macosx_MacWindow - * Method: getScreenHeight - * Signature: (I)I - */ -JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_macosx_MacWindow_getScreenHeight - (JNIEnv *env, jclass clazz, jint screen_idx) -{ - NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init]; - - NSArray *screens = [NSScreen screens]; - if(screen_idx<0) screen_idx=0; - if(screen_idx>=[screens count]) screen_idx=0; - NSScreen *screen = (NSScreen *) [screens objectAtIndex: screen_idx]; - NSRect rect = [screen frame]; - - [pool release]; - - return (jint) (rect.size.height); -} - diff --git a/src/newt/native/WindowsWindow.c b/src/newt/native/WindowsWindow.c index 908eb2ac0..67fbd3f07 100755 --- a/src/newt/native/WindowsWindow.c +++ b/src/newt/native/WindowsWindow.c @@ -778,61 +778,34 @@ static LRESULT CALLBACK wndProc(HWND wnd, UINT message, } /* - * Class: com_sun_javafx_newt_windows_WindowsScreen - * Method: getScreenWidth - * Signature: (I)I - */ -JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_windows_WindowsScreen_getScreenWidth - (JNIEnv *env, jobject obj, jint scrn_idx) -{ - return (jint)GetSystemMetrics(SM_CXSCREEN); -} - -/* - * Class: com_sun_javafx_newt_windows_WindowsScreen - * Method: getScreenWidth - * Signature: (I)I - */ -JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_windows_WindowsScreen_getScreenHeight - (JNIEnv *env, jobject obj, jint scrn_idx) -{ - return (jint)GetSystemMetrics(SM_CYSCREEN); -} - -/* - * Class: com_sun_javafx_newt_windows_WindowsWindow - * Method: initIDs - * Signature: ()Z + * Class: com_sun_javafx_newt_windows_WindowsDisplay + * Method: DispatchMessages + * Signature: ()V */ -JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_initIDs +JNIEXPORT void JNICALL Java_com_sun_javafx_newt_windows_WindowsDisplay_DispatchMessages (JNIEnv *env, jclass clazz) { - sizeChangedID = (*env)->GetMethodID(env, clazz, "sizeChanged", "(II)V"); - positionChangedID = (*env)->GetMethodID(env, clazz, "positionChanged", "(II)V"); - focusChangedID = (*env)->GetMethodID(env, clazz, "focusChanged", "(JZ)V"); - windowDestroyNotifyID = (*env)->GetMethodID(env, clazz, "windowDestroyNotify", "()V"); - windowDestroyedID = (*env)->GetMethodID(env, clazz, "windowDestroyed", "()V"); - sendMouseEventID = (*env)->GetMethodID(env, clazz, "sendMouseEvent", "(IIIIII)V"); - sendKeyEventID = (*env)->GetMethodID(env, clazz, "sendKeyEvent", "(IIIC)V"); - if (sizeChangedID == NULL || - positionChangedID == NULL || - focusChangedID == NULL || - windowDestroyNotifyID == NULL || - windowDestroyedID == NULL || - sendMouseEventID == NULL || - sendKeyEventID == NULL) { - return JNI_FALSE; - } - BuildDynamicKeyMapTable(); - return JNI_TRUE; + int i = 0; + MSG msg; + BOOL gotOne; + + // Periodically take a break + do { + gotOne = PeekMessage(&msg, (HWND) NULL, 0, 0, PM_REMOVE); + if (gotOne) { + ++i; + TranslateMessage(&msg); + DispatchMessage(&msg); + } + } while (gotOne && i < 100); } /* - * Class: com_sun_javafx_newt_windows_WindowsWindow + * Class: com_sun_javafx_newt_windows_WindowsDisplay * Method: LoadLibraryW * Signature: (Ljava/lang/String;)J */ -JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_LoadLibraryW +JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_windows_WindowsDisplay_LoadLibraryW (JNIEnv *env, jclass clazz, jstring dllName) { jchar* _dllName = GetNullTerminatedStringChars(env, dllName); @@ -842,11 +815,11 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_LoadLibra } /* - * Class: com_sun_javafx_newt_windows_WindowsWindow + * Class: com_sun_javafx_newt_windows_WindowsDisplay * Method: RegisterWindowClass * Signature: (Ljava/lang/String;J)I */ -JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_RegisterWindowClass +JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_windows_WindowsDisplay_RegisterWindowClass (JNIEnv *env, jclass clazz, jstring wndClassName, jlong hInstance) { ATOM res; @@ -882,17 +855,67 @@ JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_RegisterWi } /* - * Class: com_sun_javafx_newt_windows_WindowsWindow + * Class: com_sun_javafx_newt_windows_WindowsDisplay * Method: CleanupWindowResources * Signature: (java/lang/String;J)V */ -JNIEXPORT void JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_CleanupWindowResources - (JNIEnv *env, jobject obj, jint wndClassAtom, jlong hInstance) +JNIEXPORT void JNICALL Java_com_sun_javafx_newt_windows_WindowsDisplay_UnregisterWindowClass + (JNIEnv *env, jclass clazz, jint wndClassAtom, jlong hInstance) { UnregisterClass(MAKEINTATOM(wndClassAtom), (HINSTANCE) hInstance); } /* + * Class: com_sun_javafx_newt_windows_WindowsScreen + * Method: getWidthImpl + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_windows_WindowsScreen_getWidthImpl + (JNIEnv *env, jobject obj, jint scrn_idx) +{ + return (jint)GetSystemMetrics(SM_CXSCREEN); +} + +/* + * Class: com_sun_javafx_newt_windows_WindowsScreen + * Method: getWidthImpl + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_windows_WindowsScreen_getHeightImpl + (JNIEnv *env, jobject obj, jint scrn_idx) +{ + return (jint)GetSystemMetrics(SM_CYSCREEN); +} + +/* + * Class: com_sun_javafx_newt_windows_WindowsWindow + * Method: initIDs + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_initIDs + (JNIEnv *env, jclass clazz) +{ + sizeChangedID = (*env)->GetMethodID(env, clazz, "sizeChanged", "(II)V"); + positionChangedID = (*env)->GetMethodID(env, clazz, "positionChanged", "(II)V"); + focusChangedID = (*env)->GetMethodID(env, clazz, "focusChanged", "(JZ)V"); + windowDestroyNotifyID = (*env)->GetMethodID(env, clazz, "windowDestroyNotify", "()V"); + windowDestroyedID = (*env)->GetMethodID(env, clazz, "windowDestroyed", "()V"); + sendMouseEventID = (*env)->GetMethodID(env, clazz, "sendMouseEvent", "(IIIIII)V"); + sendKeyEventID = (*env)->GetMethodID(env, clazz, "sendKeyEvent", "(IIIC)V"); + if (sizeChangedID == NULL || + positionChangedID == NULL || + focusChangedID == NULL || + windowDestroyNotifyID == NULL || + windowDestroyedID == NULL || + sendMouseEventID == NULL || + sendKeyEventID == NULL) { + return JNI_FALSE; + } + BuildDynamicKeyMapTable(); + return JNI_TRUE; +} + +/* * Class: com_sun_javafx_newt_windows_WindowsWindow * Method: CreateWindow * Signature: (ILjava/lang/String;JJZIIII)J @@ -1017,91 +1040,6 @@ JNIEXPORT void JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_setVisible /* * Class: com_sun_javafx_newt_windows_WindowsWindow - * Method: DispatchMessages - * Signature: (JI)V - */ -JNIEXPORT void JNICALL Java_com_sun_javafx_newt_windows_WindowsWindow_DispatchMessages - (JNIEnv *env, jclass clazz, jlong window, jint eventMask) -{ - int i = 0; - MSG msg; - BOOL gotOne; - WindowUserData * wud; - -#if defined(UNDER_CE) || _MSC_VER <= 1200 - wud = (WindowUserData *) GetWindowLong((HWND)window, GWL_USERDATA); -#else - wud = (WindowUserData *) GetWindowLongPtr((HWND)window, GWLP_USERDATA); -#endif - if(NULL==wud) { - fprintf(stderr, "INTERNAL ERROR in WindowsWindow::DispatchMessages window userdata NULL\n"); - exit(1); - } - - wud->jenv = env; - - if(eventMask<0) { - eventMask *= -1; - /* FIXME: re-select input mask - long xevent_mask_key = 0; - long xevent_mask_ptr = 0; - long xevent_mask_win = 0; - if( 0 != ( eventMask & EVENT_MOUSE ) ) { - xevent_mask_ptr |= ButtonPressMask|ButtonReleaseMask|PointerMotionMask; - } - if( 0 != ( eventMask & EVENT_KEY ) ) { - xevent_mask_key |= KeyPressMask|KeyReleaseMask; - } - if( 0 != ( eventMask & EVENT_WINDOW ) ) { - xevent_mask_win |= ExposureMask; - } - - XSelectInput(dpy, w, xevent_mask_win|xevent_mask_key|xevent_mask_ptr); - */ - } - - // Periodically take a break - do { - gotOne = PeekMessage(&msg, (HWND) window, 0, 0, PM_REMOVE); - if (gotOne) { - ++i; - switch (msg.message) { - case WM_CLOSE: - case WM_DESTROY: - case WM_SIZE: - if( ! ( eventMask & EVENT_WINDOW ) ) { - continue; - } - break; - - case WM_CHAR: - case WM_KEYDOWN: - case WM_KEYUP: - if( ! ( eventMask & EVENT_KEY ) ) { - continue; - } - break; - - case WM_LBUTTONDOWN: - case WM_LBUTTONUP: - case WM_MBUTTONDOWN: - case WM_MBUTTONUP: - case WM_RBUTTONDOWN: - case WM_RBUTTONUP: - case WM_MOUSEMOVE: - if( ! ( eventMask & EVENT_MOUSE ) ) { - continue; - } - break; - } - TranslateMessage(&msg); - DispatchMessage(&msg); - } - } while (gotOne && i < 100); -} - -/* - * Class: com_sun_javafx_newt_windows_WindowsWindow * Method: setSize0 * Signature: (JII)V */ diff --git a/src/newt/native/X11Window.c b/src/newt/native/X11Window.c index c3d446f09..7ca3afe72 100755 --- a/src/newt/native/X11Window.c +++ b/src/newt/native/X11Window.c @@ -34,6 +34,8 @@ #include <stdlib.h> #include <stdio.h> #include <string.h> +#include <stdarg.h> +#include <stdint.h> #include <unistd.h> #include <X11/Xlib.h> #include <X11/Xutil.h> @@ -48,7 +50,7 @@ // #define VERBOSE_ON 1 #ifdef VERBOSE_ON - #define DBG_PRINT(args...) fprintf(stderr, args) + #define DBG_PRINT(args...) fprintf(stderr, args); fflush(stderr); #define DUMP_VISUAL_INFO(a,b) _dumpVisualInfo((a),(b)) @@ -121,12 +123,89 @@ static jint X11KeySym2NewtVKey(KeySym keySym) { return keySym; } +static const char * const ClazzNameRuntimeException = + "java/lang/RuntimeException"; +static jclass runtimeExceptionClz=NULL; + +static const char * const ClazzNameNewtWindow = + "com/sun/javafx/newt/Window"; +static jclass newtWindowClz=NULL; + +static jmethodID sizeChangedID = NULL; +static jmethodID positionChangedID = NULL; +static jmethodID windowDestroyNotifyID = NULL; +static jmethodID windowDestroyedID = NULL; +static jmethodID windowCreatedID = NULL; +static jmethodID sendMouseEventID = NULL; +static jmethodID sendKeyEventID = NULL; + +static jmethodID displayCreatedID = NULL; + +static void _throwNewRuntimeException(JNIEnv *env, const char* msg, ...) +{ + char buffer[512]; + va_list ap; + + va_start(ap, msg); + vsnprintf(buffer, sizeof(buffer), msg, ap); + va_end(ap); + + (*env)->ThrowNew(env, runtimeExceptionClz, buffer); +} + /** * Display */ /* * Class: com_sun_javafx_newt_x11_X11Display + * Method: initIDs + * Signature: ()Z + */ +JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_x11_X11Display_initIDs + (JNIEnv *env, jclass clazz) +{ + jclass c; + + displayCreatedID = (*env)->GetMethodID(env, clazz, "displayCreated", "(JJ)V"); + if (displayCreatedID == NULL) { + return JNI_FALSE; + } + + if(NULL==newtWindowClz) { + c = (*env)->FindClass(env, ClazzNameNewtWindow); + if(NULL==c) { + fprintf(stderr, "FatalError: NEWT X11Window: can't find %s\n", ClazzNameNewtWindow); + return JNI_FALSE; + } + newtWindowClz = (jclass)(*env)->NewGlobalRef(env, c); + (*env)->DeleteLocalRef(env, c); + if(NULL==newtWindowClz) { + fprintf(stderr, "FatalError: NEWT X11Window: can't use %s\n", ClazzNameNewtWindow); + return JNI_FALSE; + } + } + + if(NULL==runtimeExceptionClz) { + c = (*env)->FindClass(env, ClazzNameRuntimeException); + if(NULL==c) { + fprintf(stderr, "FatalError: NEWT X11Window: can't find %s\n", ClazzNameRuntimeException); + return JNI_FALSE; + } + runtimeExceptionClz = (jclass)(*env)->NewGlobalRef(env, c); + (*env)->DeleteLocalRef(env, c); + if(NULL==runtimeExceptionClz) { + fprintf(stderr, "FatalError: NEWT X11Window: can't use %s\n", ClazzNameRuntimeException); + return JNI_FALSE; + } + } + + return JNI_TRUE; +} + + +/* + * Class: com_sun_javafx_newt_x11_X11Display * Method: CreateDisplay * Signature: (Ljava/lang/String;)J */ @@ -138,16 +217,229 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Display_CreateDisplay if(displayName!=0) { _displayName = (*env)->GetStringUTFChars(env, displayName, 0); } + DBG_PRINT("open display connection for %s ..\n", ((NULL==_displayName)?"NULL":_displayName)); dpy = XOpenDisplay(_displayName); + if(dpy==NULL) { + _throwNewRuntimeException(env, "couldn't open display connection for %s\n", ((NULL==_displayName)?"NULL":_displayName)); + } if(_displayName!=0) { (*env)->ReleaseStringChars(env, displayName, (const jchar *)_displayName); } - if(dpy==NULL) { - fprintf(stderr, "couldn't open display connection..\n"); + + jlong javaObjectAtom = (jlong) XInternAtom(dpy, "JOGL_JAVA_OBJECT", False); + if(None==javaObjectAtom) { + XCloseDisplay(dpy); + _throwNewRuntimeException(env, "could not create Atom JOGL_JAVA_OBJECT, bail out!\n"); + return 0; } + + jlong windowDeleteAtom = (jlong) XInternAtom(dpy, "WM_DELETE_WINDOW", False); + if(None==windowDeleteAtom) { + XCloseDisplay(dpy); + _throwNewRuntimeException(env, "could not create Atom WM_DELETE_WINDOW, bail out!\n"); + return 0; + } + + DBG_PRINT("X11Display_CreateDisplay dpy %p\n", dpy); + + (*env)->CallVoidMethod(env, obj, displayCreatedID, javaObjectAtom, windowDeleteAtom); + return (jlong) (intptr_t) dpy; } +/* + * Class: com_sun_javafx_newt_x11_X11Display + * Method: DestroyDisplay + * Signature: (J)V + */ +JNIEXPORT void JNICALL Java_com_sun_javafx_newt_x11_X11Display_DestroyDisplay + (JNIEnv *env, jobject obj, jlong display) +{ + Display * dpy = (Display *)(intptr_t)display; + DBG_PRINT("X11Display_DestroyDisplay dpy %p\n", dpy); + XCloseDisplay(dpy); +} + +static int putPtrIn32Long(unsigned long * dst, uintptr_t src) { + int i=0; + dst[i++] = (unsigned long) ( ( src >> 0 ) & 0xFFFFFFFF ) ; + if(sizeof(uintptr_t) == 8) { + dst[i++] = (unsigned long) ( ( src >> 32 ) & 0xFFFFFFFF ) ; + } + return i; +} + +static uintptr_t getPtrOut32Long(unsigned long * src) { + uintptr_t res = ( (uintptr_t) ( src[0] & 0xFFFFFFFF ) ) << 0 ; + if(sizeof(uintptr_t) == 8) { + res |= ( (uintptr_t) ( src[1] & 0xFFFFFFFF ) ) << 32 ; + } + return res; +} + +static void setJavaWindowProperty(JNIEnv *env, Display *dpy, Window window, jlong javaObjectAtom, jobject jwindow) { + unsigned long jogl_java_object_data[2]; + int nitems_32 = putPtrIn32Long( jogl_java_object_data, (uintptr_t) jwindow); + + { + jobject test = (jobject) getPtrOut32Long(jogl_java_object_data); + if( ! (jwindow==test) ) { + _throwNewRuntimeException(env, "Internal Error .. Encoded Window ref not the same %p != %p !\n", jwindow, test); + } + } + + XChangeProperty( dpy, window, (Atom)javaObjectAtom, (Atom)javaObjectAtom, 32, PropModeReplace, + (unsigned char *)&jogl_java_object_data, nitems_32); +} + +static jobject getJavaWindowProperty(JNIEnv *env, Display *dpy, Window window, jlong javaObjectAtom) { + Atom actual_type_return; + int actual_format_return; + int nitems_32 = ( sizeof(uintptr_t) == 8 ) ? 2 : 1 ; + unsigned char * jogl_java_object_data_pp = NULL; + jobject jwindow; + + { + unsigned long nitems_return = 0; + unsigned long bytes_after_return = 0; + jobject jwindow = NULL; + int res; + + res = XGetWindowProperty(dpy, window, (Atom)javaObjectAtom, 0, nitems_32, False, + (Atom)javaObjectAtom, &actual_type_return, &actual_format_return, + &nitems_return, &bytes_after_return, &jogl_java_object_data_pp); + + if ( Success != res ) { + _throwNewRuntimeException(env, "could not fetch Atom JOGL_JAVA_OBJECT window property (res %d) nitems_return %ld, bytes_after_return %ld, bail out!\n", + res, nitems_return, bytes_after_return); + return NULL; + } + + if(actual_type_return!=(Atom)javaObjectAtom || nitems_return<nitems_32 || NULL==jogl_java_object_data_pp) { + XFree(jogl_java_object_data_pp); + _throwNewRuntimeException(env, "could not fetch Atom JOGL_JAVA_OBJECT window property (res %d) nitems_return %ld, bytes_after_return %ld, actual_type_return %ld, JOGL_JAVA_OBJECT %ld, bail out!\n", + res, nitems_return, bytes_after_return, (long)actual_type_return, javaObjectAtom); + return NULL; + } + } + jwindow = (jobject) getPtrOut32Long( (unsigned long *) jogl_java_object_data_pp ) ; + XFree(jogl_java_object_data_pp); + +#ifdef VERBOSE_ON + if(JNI_FALSE == (*env)->IsInstanceOf(env, jwindow, newtWindowClz)) { + _throwNewRuntimeException(env, "fetched Atom JOGL_JAVA_OBJECT window is not a NEWT Window: javaWindow 0x%X !\n", jwindow); + } +#endif + return jwindow; +} + +/* + * Class: com_sun_javafx_newt_x11_X11Display + * Method: DispatchMessages + * Signature: (JIJJ)V + */ +JNIEXPORT void JNICALL Java_com_sun_javafx_newt_x11_X11Display_DispatchMessages + (JNIEnv *env, jobject obj, jlong display, jlong javaObjectAtom, jlong wmDeleteAtom) +{ + Display * dpy = (Display *) (intptr_t) display; + int num_events = 0; + + // Periodically take a break + while( num_events<100 && XPending(dpy)>0 ) { + jobject jwindow = NULL; + XEvent evt; + KeySym keySym; + char keyChar; + char text[255]; + + XNextEvent(dpy, &evt); + num_events++; + + if( 0==evt.xany.window ) { + _throwNewRuntimeException(env, "event window NULL, bail out!\n"); + } + + if(dpy!=evt.xany.display) { + _throwNewRuntimeException(env, "wrong display"); + continue; + } + jwindow = getJavaWindowProperty(env, dpy, evt.xany.window, javaObjectAtom); + if(NULL==jwindow) { + // just leave .. _throwNewRuntimeException(env, "could not fetch Java Window object, bail out!\n"); + return; + } + + // FIXME: support resize and window re-positioning events + + switch(evt.type) { + case ButtonPress: + (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_PRESSED, + (jint) evt.xbutton.state, + (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/); + break; + case ButtonRelease: + (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_RELEASED, + (jint) evt.xbutton.state, + (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/); + break; + case MotionNotify: + (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_MOVED, + (jint) evt.xmotion.state, + (jint) evt.xmotion.x, (jint) evt.xmotion.y, (jint) 0, 0 /*rotation*/); + break; + case KeyPress: + if(XLookupString(&evt.xkey,text,255,&keySym,0)==1) { + keyChar=text[0]; + } else { + keyChar=0; + } + (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_PRESSED, + (jint) evt.xkey.state, + X11KeySym2NewtVKey(keySym), (jchar) keyChar); + break; + case KeyRelease: + if(XLookupString(&evt.xkey,text,255,&keySym,0)==1) { + keyChar=text[0]; + } else { + keyChar=0; + } + (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_RELEASED, + (jint) evt.xkey.state, + X11KeySym2NewtVKey(keySym), (jchar) keyChar); + break; + case FocusIn: + case FocusOut: + break; + case DestroyNotify: + DBG_PRINT( "event . DestroyNotify call 0x%X\n", evt.xdestroywindow.window); + (*env)->CallVoidMethod(env, jwindow, windowDestroyedID); + break; + case CreateNotify: + DBG_PRINT( "event . CreateNotify call 0x%X\n", evt.xcreatewindow.window); + (*env)->CallVoidMethod(env, jwindow, windowCreatedID); + break; + case VisibilityNotify: + DBG_PRINT( "event . VisibilityNotify call 0x%X\n", evt.xvisibility.window); + break; + case Expose: + DBG_PRINT( "event . Expose call 0x%X\n", evt.xexpose.window); + /* FIXME: Might want to send a repaint event .. */ + break; + case UnmapNotify: + DBG_PRINT( "event . UnmapNotify call 0x%X\n", evt.xunmap.window); + break; + case ClientMessage: + if (evt.xclient.send_event==True && evt.xclient.data.l[0]==(Atom)wmDeleteAtom) { + DBG_PRINT( "event . ClientMessage call 0x%X type 0x%X !!!\n", evt.xclient.window, evt.xclient.message_type); + (*env)->CallVoidMethod(env, jwindow, windowDestroyNotifyID); + // Called by Window.java: CloseWindow(); + } + break; + } + } +} + + /** * Screen */ @@ -195,14 +487,6 @@ JNIEXPORT jint JNICALL Java_com_sun_javafx_newt_x11_X11Screen_getHeight0 * Window */ -static jmethodID sizeChangedID = NULL; -static jmethodID positionChangedID = NULL; -static jmethodID windowDestroyNotifyID = NULL; -static jmethodID windowDestroyedID = NULL; -static jmethodID windowCreatedID = NULL; -static jmethodID sendMouseEventID = NULL; -static jmethodID sendKeyEventID = NULL; - /* * Class: com_sun_javafx_newt_x11_X11Window * Method: initIDs @@ -215,9 +499,10 @@ JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_x11_X11Window_initIDs positionChangedID = (*env)->GetMethodID(env, clazz, "positionChanged", "(II)V"); windowDestroyNotifyID = (*env)->GetMethodID(env, clazz, "windowDestroyNotify", "()V"); windowDestroyedID = (*env)->GetMethodID(env, clazz, "windowDestroyed", "()V"); - windowCreatedID = (*env)->GetMethodID(env, clazz, "windowCreated", "(JJ)V"); + windowCreatedID = (*env)->GetMethodID(env, clazz, "windowCreated", "(J)V"); sendMouseEventID = (*env)->GetMethodID(env, clazz, "sendMouseEvent", "(IIIIII)V"); sendKeyEventID = (*env)->GetMethodID(env, clazz, "sendKeyEvent", "(IIIC)V"); + if (sizeChangedID == NULL || positionChangedID == NULL || windowDestroyNotifyID == NULL || @@ -237,7 +522,8 @@ JNIEXPORT jboolean JNICALL Java_com_sun_javafx_newt_x11_X11Window_initIDs */ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Window_CreateWindow (JNIEnv *env, jobject obj, jlong display, jint screen_index, - jlong visualID, + jlong visualID, + jlong javaObjectAtom, jlong windowDeleteAtom, jint x, jint y, jint width, jint height) { Display * dpy = (Display *)(intptr_t)display; @@ -283,11 +569,11 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Window_CreateWindow XFree(pVisualQuery); pVisualQuery=NULL; } - DBG_PRINT( "trying given (screen %d, visualID: %d) found: %p\n", scrn_idx, (int)visualID, visual); + DBG_PRINT( "[CreateWindow] trying given (dpy %p, screen %d, visualID: %d) found: %p\n", dpy, scrn_idx, (int)visualID, visual); if (visual==NULL) { - fprintf(stderr, "could not query Visual by given VisualID, bail out!\n"); + _throwNewRuntimeException(env, "could not query Visual by given VisualID, bail out!\n"); return 0; } @@ -320,12 +606,31 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Window_CreateWindow visual, attrMask, &xswa); - Atom wm_delete_window = XInternAtom(dpy, "WM_DELETE_WINDOW", False); - XSetWMProtocols(dpy, window, &wm_delete_window, 1); + + Atom wm_delete_atom = (Atom)windowDeleteAtom; + XSetWMProtocols(dpy, window, &wm_delete_atom, 1); + + setJavaWindowProperty(env, dpy, window, javaObjectAtom, (*env)->NewGlobalRef(env, obj)); + XClearWindow(dpy, window); XSync(dpy, False); - (*env)->CallVoidMethod(env, obj, windowCreatedID, (jlong) window, (jlong)wm_delete_window); + { + long xevent_mask = 0; + xevent_mask |= ButtonPressMask|ButtonReleaseMask|PointerMotionMask; + xevent_mask |= KeyPressMask|KeyReleaseMask; + xevent_mask |= ExposureMask | StructureNotifyMask | SubstructureNotifyMask | VisibilityNotify ; + XSelectInput(dpy, window, xevent_mask); + + /** + XGrabPointer(dpy, window, True, ButtonPressMask|ButtonReleaseMask|PointerMotionMask, + GrabModeAsync, GrabModeAsync, window, None, CurrentTime); + XGrabKeyboard(dpy, window, True, GrabModeAsync, GrabModeAsync, CurrentTime); + */ + } + + DBG_PRINT( "[CreateWindow] created window %p on display %p\n", window, dpy); + (*env)->CallVoidMethod(env, obj, windowCreatedID, (jlong) window); return (jlong) window; } @@ -336,10 +641,21 @@ JNIEXPORT jlong JNICALL Java_com_sun_javafx_newt_x11_X11Window_CreateWindow * Signature: (JJ)V */ JNIEXPORT void JNICALL Java_com_sun_javafx_newt_x11_X11Window_CloseWindow - (JNIEnv *env, jobject obj, jlong display, jlong window) + (JNIEnv *env, jobject obj, jlong display, jlong window, jlong javaObjectAtom) { Display * dpy = (Display *) (intptr_t) display; Window w = (Window)window; + jobject jwindow; + + jwindow = getJavaWindowProperty(env, dpy, w, javaObjectAtom); + if(NULL==jwindow) { + _throwNewRuntimeException(env, "could not fetch Java Window object, bail out!\n"); + return; + } + if ( JNI_FALSE == (*env)->IsSameObject(env, jwindow, obj) ) { + _throwNewRuntimeException(env, "Internal Error .. Window global ref not the same!\n"); + } + (*env)->DeleteGlobalRef(env, jwindow); XSync(dpy, False); /** @@ -383,176 +699,6 @@ JNIEXPORT void JNICALL Java_com_sun_javafx_newt_x11_X11Window_setVisible0 } } -/* - * Class: com_sun_javafx_newt_x11_X11Window - * Method: DispatchMessages - * Signature: (JJI)V - */ -JNIEXPORT void JNICALL Java_com_sun_javafx_newt_x11_X11Window_DispatchMessages - (JNIEnv *env, jobject obj, jlong display, jlong window, jint eventMask, jlong wmDeleteAtom) -{ - Display * dpy = (Display *) (intptr_t) display; - Window w = (Window)window; - Atom wm_delete_window = (Atom)wmDeleteAtom; - - if(eventMask<0) { - long xevent_mask_key = 0; - long xevent_mask_ptr = 0; - long xevent_mask_win = 0; - eventMask *= -1; - if( 0 != ( eventMask & EVENT_MOUSE ) ) { - xevent_mask_ptr |= ButtonPressMask|ButtonReleaseMask|PointerMotionMask; - } - if( 0 != ( eventMask & EVENT_KEY ) ) { - xevent_mask_key |= KeyPressMask|KeyReleaseMask; - } - if( 0 != ( eventMask & EVENT_WINDOW ) ) { - xevent_mask_win |= ExposureMask | StructureNotifyMask | SubstructureNotifyMask | VisibilityNotify ; - } - - XSelectInput(dpy, w, xevent_mask_win|xevent_mask_key|xevent_mask_ptr); - - /** - if(0!=xevent_mask_ptr) { - XGrabPointer(dpy, w, True, xevent_mask_ptr, - GrabModeAsync, GrabModeAsync, w, None, CurrentTime); - } - if(0!=xevent_mask_key) { - XGrabKeyboard(dpy, w, True, GrabModeAsync, GrabModeAsync, CurrentTime); - } */ - - } - - // Periodically take a break - while( XPending(dpy)>0 ) { - XEvent evt; - KeySym keySym; - char keyChar; - char text[255]; - - XNextEvent(dpy, &evt); - - switch(evt.type) { - case ButtonPress: - case ButtonRelease: - case MotionNotify: - if( ! ( eventMask & EVENT_MOUSE ) ) { - continue; - } - break; - case KeyPress: - case KeyRelease: - if( ! ( eventMask & EVENT_KEY ) ) { - continue; - } - break; - case FocusIn: - case FocusOut: - break; - case DestroyNotify: - case CreateNotify: - case VisibilityNotify: - case Expose: - case UnmapNotify: - if( ! ( eventMask & EVENT_WINDOW ) ) { - continue; - } - break; - } - - // FIXME: support resize and window re-positioning events - - switch(evt.type) { - case ButtonPress: - if(evt.xbutton.window==w) { - (*env)->CallVoidMethod(env, obj, sendMouseEventID, (jint) EVENT_MOUSE_PRESSED, - (jint) evt.xbutton.state, - (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/); - } - break; - case ButtonRelease: - if(evt.xbutton.window==w) { - (*env)->CallVoidMethod(env, obj, sendMouseEventID, (jint) EVENT_MOUSE_RELEASED, - (jint) evt.xbutton.state, - (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/); - } - break; - case MotionNotify: - if(evt.xmotion.window==w) { - (*env)->CallVoidMethod(env, obj, sendMouseEventID, (jint) EVENT_MOUSE_MOVED, - (jint) evt.xmotion.state, - (jint) evt.xmotion.x, (jint) evt.xmotion.y, (jint) 0, 0 /*rotation*/); - } - break; - case KeyPress: - if(evt.xkey.window==w) { - if(XLookupString(&evt.xkey,text,255,&keySym,0)==1) { - keyChar=text[0]; - } else { - keyChar=0; - } - (*env)->CallVoidMethod(env, obj, sendKeyEventID, (jint) EVENT_KEY_PRESSED, - (jint) evt.xkey.state, - X11KeySym2NewtVKey(keySym), (jchar) keyChar); - } - break; - case KeyRelease: - if(evt.xkey.window==w) { - if(XLookupString(&evt.xkey,text,255,&keySym,0)==1) { - keyChar=text[0]; - } else { - keyChar=0; - } - (*env)->CallVoidMethod(env, obj, sendKeyEventID, (jint) EVENT_KEY_RELEASED, - (jint) evt.xkey.state, - X11KeySym2NewtVKey(keySym), (jchar) keyChar); - } - break; - case FocusIn: - case FocusOut: - if(evt.xfocus.window==w) { - } - break; - case DestroyNotify: - if(evt.xdestroywindow.window==w) { - DBG_PRINT( "event . DestroyNotify call 0x%X\n", evt.xdestroywindow.window); - (*env)->CallVoidMethod(env, obj, windowDestroyedID); - } - break; - case CreateNotify: - if(evt.xcreatewindow.window==w) { - DBG_PRINT( "event . DestroyNotify call 0x%X\n", evt.xcreatewindow.window); - (*env)->CallVoidMethod(env, obj, windowCreatedID); - } - break; - case VisibilityNotify: - if(evt.xvisibility.window==w) { - DBG_PRINT( "event . VisibilityNotify call 0x%X\n", evt.xvisibility.window); - } - break; - case Expose: - if(evt.xexpose.window==w) { - DBG_PRINT( "event . Expose call 0x%X\n", evt.xexpose.window); - /* FIXME: Might want to send a repaint event .. */ - } - break; - case UnmapNotify: - if(evt.xunmap.window==w) { - DBG_PRINT( "event . UnmapNotify call 0x%X\n", evt.xunmap.window); - } - break; - case ClientMessage: - if (evt.xclient.window==w && evt.xclient.send_event==True && evt.xclient.data.l[0]==wm_delete_window) { - DBG_PRINT( "event . ClientMessage call 0x%X type 0x%X !!!\n", evt.xclient.window, evt.xclient.message_type); - (*env)->CallVoidMethod(env, obj, windowDestroyNotifyID); - // Called by Window.java: CloseWindow(); - } - break; - - } - } -} - #define MWM_FULLSCREEN 1 #ifdef MWM_FULLSCREEN @@ -612,7 +758,13 @@ JNIEXPORT void JNICALL Java_com_sun_javafx_newt_x11_X11Window_setSize0 XSync(dpy, False); /** if(isVisible==JNI_TRUE) { + // this .. XSetInputFocus(dpy, w, RevertToNone, CurrentTime); + + // or this .. + unsigned long wmleader[1] = { (unsigned long) w}; + Atom prop = XInternAtom( dpy, "WM_CLIENT_LEADER", False ); + XChangeProperty( dpy, w, prop, prop, 32, PropModeReplace, (unsigned char *)&wmleader, 1); } */ DBG_PRINT( "setSize0 . sizeChangedID call\n"); |