NEWT Multi-Monitor 1/2: Allow negative window position; Validate Screen-Index;

- Allow negative window position, using flag 'autoPosition' to mark a custom user position.
  This impacts Windows and X11 window creation code, which supports native auto positioning.

- Screen: Validate Screen-Index.
  In 'big-desktop' mode the Screen index is always 0. This is true for X11 with
  Xinerama enabled and MS-Windows in general.
  Platforms w/o multiple Screen support always use index 0.

- X11: Separate X11 Display/Screen/Window native code in their respective C files

- Windows test scripts: use '%*' to catch all arguments

- Add missing (c)

29 files changed, 1560 insertions, 1190 deletions

diff --git a/src/newt/classes/jogamp/newt/ScreenImpl.java b/src/newt/classes/jogamp/newt/ScreenImpl.java
index c520d0d63..3c46814d2 100644
--- a/src/newt/classes/jogamp/newt/ScreenImpl.java
+++ b/src/newt/classes/jogamp/newt/ScreenImpl.java
@@ -100,7 +100,7 @@ public abstract class ScreenImpl extends Screen implements ScreenModeListener {
         return (Class<? extends Screen>)screenClass;
     }
 
-    public static Screen create(Display display, final int idx) {
+    public static Screen create(Display display, int idx) {
         try {
             if(usrWidth<0 || usrHeight<0) {
                 synchronized (Screen.class) {
@@ -114,18 +114,20 @@ public abstract class ScreenImpl extends Screen implements ScreenModeListener {
                 }
             }
             synchronized(screenList) {
+                Class<? extends Screen> screenClass = getScreenClass(display.getType());
+                ScreenImpl screen  = (ScreenImpl) screenClass.newInstance();
+                screen.display = (DisplayImpl) display;
+                idx = screen.validateScreenIndex(idx);
                 {
                     Screen screen0 = ScreenImpl.getLastScreenOf(display, idx, -1);
                     if(null != screen0) {
                         if(DEBUG) {
                             System.err.println("Screen.create() REUSE: "+screen0+" "+Display.getThreadName());
                         }
+                        screen = null;
                         return screen0;
                     }
                 }
-                Class<? extends Screen> screenClass = getScreenClass(display.getType());
-                ScreenImpl screen  = (ScreenImpl) screenClass.newInstance();
-                screen.display = (DisplayImpl) display;
                 screen.screen_idx = idx;
                 screen.fqname = (display.getFQName()+idx).intern();
                 screen.hashCode = screen.fqname.hashCode();
@@ -238,7 +240,8 @@ public abstract class ScreenImpl extends Screen implements ScreenModeListener {
 
     protected abstract void createNativeImpl();
     protected abstract void closeNativeImpl();
-
+    protected abstract int validateScreenIndex(int idx);
+    
     public final String getFQName() {
         return fqname;
     }
diff --git a/src/newt/classes/jogamp/newt/WindowImpl.java b/src/newt/classes/jogamp/newt/WindowImpl.java
index a8e93d428..7c811c66a 100644
--- a/src/newt/classes/jogamp/newt/WindowImpl.java
+++ b/src/newt/classes/jogamp/newt/WindowImpl.java
@@ -92,7 +92,8 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     protected CapabilitiesChooser capabilitiesChooser = null; // default null -> default
     protected boolean fullscreen = false, hasFocus = false;    
     protected int width = 128, height = 128; // client-area size w/o insets, default: may be overwritten by user
-    protected int x = -1, y = -1; // client-area pos w/o insets, default: undefined (allow WM to choose if not set by user)
+    protected int x = 64, y = 64; // client-area pos w/o insets
+    protected boolean autoPosition = true; // default: true (allow WM to choose if not set by user)
     protected Insets insets = new Insets(); // insets of decoration (if top-level && decorated)
         
     protected int nfs_width, nfs_height, nfs_x, nfs_y; // non fullscreen client-area size/pos w/o insets
@@ -276,8 +277,8 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
             NativeSurface.LOCK_SURFACE_NOT_READY >= parentWindow.lockSurface() ) {
             throw new NativeWindowException("Parent surface lock: not ready: "+parentWindow);
         }        
-        if( ( 0>x || 0>y ) && ( isUndecorated() || null != parentWindow ) ) {
-            // default child/undecorated window position is 0/0, if not set by user
+        if( ( 0>x || 0>y ) && null != parentWindow ) {
+            // min. child window position is 0/0
             x = 0; y = 0;
         }
         try {
@@ -1643,6 +1644,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     }
 
     public void setPosition(int x, int y) {
+        autoPosition = false;
         runOnEDTIfAvail(true, new SetPositionActionImpl(x, y));
     }
     
@@ -2349,6 +2351,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
     
     /** Triggered by implementation's WM events to update the position. */ 
     protected void positionChanged(boolean defer, int newX, int newY) {
+        autoPosition = false;
         if ( x != newX || y != newY ) {
             if(DEBUG_IMPLEMENTATION) {
                 System.err.println("Window.positionChanged: ("+getThreadName()+"): (defer: "+defer+") "+x+"/"+y+" -> "+newX+"/"+newY+" - windowHandle "+toHexString(windowHandle)+" parentWindowHandle "+toHexString(parentWindowHandle));
@@ -2414,8 +2417,6 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
      * Triggered by implementation's WM events to update the content
      */ 
     protected void windowRepaint(boolean defer, int x, int y, int width, int height) {
-        x = ( 0 > x ) ? this.x : x;
-        y = ( 0 > y ) ? this.y : y;
         width = ( 0 >= width ) ? this.width : width;
         height = ( 0 >= height ) ? this.height : height;
         if(DEBUG_IMPLEMENTATION) {
diff --git a/src/newt/classes/jogamp/newt/driver/android/AndroidScreen.java b/src/newt/classes/jogamp/newt/driver/android/AndroidScreen.java
index ce6a9c594..79bf744fe 100644
--- a/src/newt/classes/jogamp/newt/driver/android/AndroidScreen.java
+++ b/src/newt/classes/jogamp/newt/driver/android/AndroidScreen.java
@@ -74,6 +74,10 @@ public class AndroidScreen extends jogamp.newt.ScreenImpl {
         return ScreenModeUtil.streamIn(props, 0);
     }
     
+    protected int validateScreenIndex(int idx) {
+        return 0; // FIXME: only one screen available ? 
+    }
+    
     //----------------------------------------------------------------------
     // Internals only
     //
diff --git a/src/newt/classes/jogamp/newt/driver/awt/AWTScreen.java b/src/newt/classes/jogamp/newt/driver/awt/AWTScreen.java
index 644c96391..a8aa2844d 100644
--- a/src/newt/classes/jogamp/newt/driver/awt/AWTScreen.java
+++ b/src/newt/classes/jogamp/newt/driver/awt/AWTScreen.java
@@ -62,4 +62,9 @@ public class AWTScreen extends ScreenImpl {
     }
 
     protected void closeNativeImpl() { }
+    
+    protected int validateScreenIndex(int idx) {
+        return idx; // FIXME: ??? 
+    }    
+    
 }
diff --git a/src/newt/classes/jogamp/newt/driver/awt/AWTWindow.java b/src/newt/classes/jogamp/newt/driver/awt/AWTWindow.java
index ca280fa8b..1cd98b068 100644
--- a/src/newt/classes/jogamp/newt/driver/awt/AWTWindow.java
+++ b/src/newt/classes/jogamp/newt/driver/awt/AWTWindow.java
@@ -188,11 +188,6 @@ public class AWTWindow extends WindowImpl {
             container.setVisible(0 != ( FLAG_IS_VISIBLE & flags));
         }
         
-        x=(x>=0)?x:AWTWindow.this.x;
-        y=(x>=0)?y:AWTWindow.this.y;
-        width=(width>0)?width:AWTWindow.this.width;
-        height=(height>0)?height:AWTWindow.this.height;
-
         container.setLocation(x, y);
         Insets insets = container.getInsets();
         container.setSize(width + insets.left + insets.right,
diff --git a/src/newt/classes/jogamp/newt/driver/broadcom/egl/Screen.java b/src/newt/classes/jogamp/newt/driver/broadcom/egl/Screen.java
index 0a8453701..9d96ac5d6 100644
--- a/src/newt/classes/jogamp/newt/driver/broadcom/egl/Screen.java
+++ b/src/newt/classes/jogamp/newt/driver/broadcom/egl/Screen.java
@@ -52,6 +52,10 @@ public class Screen extends jogamp.newt.ScreenImpl {
 
     protected void closeNativeImpl() { }
 
+    protected int validateScreenIndex(int idx) {
+        return 0; // only one screen available 
+    }
+        
     //----------------------------------------------------------------------
     // Internals only
     //
diff --git a/src/newt/classes/jogamp/newt/driver/intel/gdl/Screen.java b/src/newt/classes/jogamp/newt/driver/intel/gdl/Screen.java
index 26b7120a9..62d9da4ed 100644
--- a/src/newt/classes/jogamp/newt/driver/intel/gdl/Screen.java
+++ b/src/newt/classes/jogamp/newt/driver/intel/gdl/Screen.java
@@ -53,6 +53,10 @@ public class Screen extends jogamp.newt.ScreenImpl {
 
     protected void closeNativeImpl() { }
 
+    protected int validateScreenIndex(int idx) {
+        return 0; // only one screen available 
+    }
+        
     //----------------------------------------------------------------------
     // Internals only
     //
diff --git a/src/newt/classes/jogamp/newt/driver/intel/gdl/Window.java b/src/newt/classes/jogamp/newt/driver/intel/gdl/Window.java
index 6fc76a12d..873d0a0c1 100644
--- a/src/newt/classes/jogamp/newt/driver/intel/gdl/Window.java
+++ b/src/newt/classes/jogamp/newt/driver/intel/gdl/Window.java
@@ -84,11 +84,6 @@ public class Window extends jogamp.newt.WindowImpl {
     protected boolean reconfigureWindowImpl(int x, int y, int width, int height, int flags) {
         Screen  screen = (Screen) getScreen();
 
-        x=(x>=0)?x:this.x;
-        y=(x>=0)?y:this.y;
-        width=(width>0)?width:this.width;
-        height=(height>0)?height:this.height;
-
         if(width>screen.getWidth()) {
             width=screen.getWidth();
         }
diff --git a/src/newt/classes/jogamp/newt/driver/kd/KDScreen.java b/src/newt/classes/jogamp/newt/driver/kd/KDScreen.java
index a11b08b5c..0bfe8a622 100644
--- a/src/newt/classes/jogamp/newt/driver/kd/KDScreen.java
+++ b/src/newt/classes/jogamp/newt/driver/kd/KDScreen.java
@@ -54,4 +54,8 @@ public class KDScreen extends ScreenImpl {
     protected void setScreenSize(int w, int h) {
         super.setScreenSize(w, h);
     }
+    
+    protected int validateScreenIndex(int idx) {
+        return 0; // only one screen available 
+    }       
 }
diff --git a/src/newt/classes/jogamp/newt/driver/macosx/MacScreen.java b/src/newt/classes/jogamp/newt/driver/macosx/MacScreen.java
index 7785a5078..1c8128a5a 100644
--- a/src/newt/classes/jogamp/newt/driver/macosx/MacScreen.java
+++ b/src/newt/classes/jogamp/newt/driver/macosx/MacScreen.java
@@ -106,6 +106,10 @@ public class MacScreen extends ScreenImpl {
         return setScreenMode0(screen_idx, nativeModeIdx);
     }
     
+    protected int validateScreenIndex(int idx) {
+        return idx; 
+    }
+        
     private native int[] getScreenMode0(int screen_index, int mode_index);
     private native boolean setScreenMode0(int screen_index, int mode_idx);
 }
diff --git a/src/newt/classes/jogamp/newt/driver/windows/WindowsScreen.java b/src/newt/classes/jogamp/newt/driver/windows/WindowsScreen.java
index ef06667ce..b1cdc36b2 100644
--- a/src/newt/classes/jogamp/newt/driver/windows/WindowsScreen.java
+++ b/src/newt/classes/jogamp/newt/driver/windows/WindowsScreen.java
@@ -101,6 +101,10 @@ public class WindowsScreen extends ScreenImpl {
                               sm.getRotation());
     }
 
+    protected int validateScreenIndex(int idx) {
+        return 0; // big-desktop, only one screen available 
+    }
+        
     // Native calls
     private native int getWidthImpl0(int scrn_idx);
 
diff --git a/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java b/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java
index 23206c29d..ca868f4ee 100644
--- a/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java
+++ b/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java
@@ -115,7 +115,7 @@ public class WindowsWindow extends WindowImpl {
         final int flags = getReconfigureFlags(0, true) & 
                           ( FLAG_IS_ALWAYSONTOP | FLAG_IS_UNDECORATED ) ;
         setWindowHandle(CreateWindow0(display.getHInstance(), display.getWindowClassName(), display.getWindowClassName(),
-                                      getParentWindowHandle(), x, y, width, height, flags)); 
+                                      getParentWindowHandle(), x, y, width, height, autoPosition, flags)); 
         if (getWindowHandle() == 0) {
             throw new NativeWindowException("Error creating window");
         }
@@ -287,7 +287,7 @@ public class WindowsWindow extends WindowImpl {
 
     private native long CreateWindow0(long hInstance, String wndClassName, String wndName,
                                       long parentWindowHandle,
-                                      int x, int y, int width, int height, int flags);
+                                      int x, int y, int width, int height, boolean autoPosition, int flags);
     private native long MonitorFromWindow0(long windowHandle);
     private native void reconfigureWindow0(long parentWindowHandle, long windowHandle,
                                            int x, int y, int width, int height, int flags);
diff --git a/src/newt/classes/jogamp/newt/driver/x11/X11Screen.java b/src/newt/classes/jogamp/newt/driver/x11/X11Screen.java
index 463c62eba..1c5388d2c 100644
--- a/src/newt/classes/jogamp/newt/driver/x11/X11Screen.java
+++ b/src/newt/classes/jogamp/newt/driver/x11/X11Screen.java
@@ -33,6 +33,7 @@
  */
 package jogamp.newt.driver.x11;
 
+import jogamp.nativewindow.x11.X11Lib;
 import jogamp.nativewindow.x11.X11Util;
 import jogamp.newt.DisplayImpl;
 import jogamp.newt.ScreenImpl;
@@ -254,6 +255,21 @@ public class X11Screen extends ScreenImpl {
         return done;
     }
 
+    private class XineramaEnabledQuery implements DisplayImpl.DisplayRunnable<Boolean> {
+        public Boolean run(long dpy) {        
+            return new Boolean(X11Lib.XineramaEnabled(dpy)); 
+        }        
+    }
+    private XineramaEnabledQuery xineramaEnabledQuery = new XineramaEnabledQuery();
+    
+    protected int validateScreenIndex(final int idx) {
+        if(getDisplay().isNativeValid()) {
+            return runWithLockedDisplayHandle( xineramaEnabledQuery ).booleanValue() ? 0 : idx;
+        } else {
+            return runWithTempDisplayHandle( xineramaEnabledQuery ).booleanValue() ? 0 : idx;
+        }
+    }
+        
     //----------------------------------------------------------------------
     // Internals only
     //    
diff --git a/src/newt/classes/jogamp/newt/driver/x11/X11Window.java b/src/newt/classes/jogamp/newt/driver/x11/X11Window.java
index bfaf53f0d..0bcf45a8d 100644
--- a/src/newt/classes/jogamp/newt/driver/x11/X11Window.java
+++ b/src/newt/classes/jogamp/newt/driver/x11/X11Window.java
@@ -79,7 +79,7 @@ public class X11Window extends WindowImpl {
         setWindowHandle(CreateWindow0(getParentWindowHandle(),
                                display.getEDTHandle(), screen.getIndex(), visualID, 
                                display.getJavaObjectAtom(), display.getWindowDeleteAtom(), 
-                               x, y, width, height, flags));
+                               x, y, width, height, autoPosition, flags));
         windowHandleClose = getWindowHandle();
         if (0 == windowHandleClose) {
             throw new NativeWindowException("Error creating window");
@@ -239,7 +239,7 @@ public class X11Window extends WindowImpl {
     
     private native long CreateWindow0(long parentWindowHandle, long display, int screen_index, 
                                             long visualID, long javaObjectAtom, long windowDeleteAtom, 
-                                            int x, int y, int width, int height, int flags); 
+                                            int x, int y, int width, int height, boolean autoPosition, int flags); 
     private native void CloseWindow0(long display, long windowHandle, long javaObjectAtom, long windowDeleteAtom);
     private native void reconfigureWindow0(long display, int screen_index, long parentWindowHandle, long windowHandle,
                                            int x, int y, int width, int height, int flags);    
diff --git a/src/newt/native/KDWindow.c b/src/newt/native/KDWindow.c
index 5f1affed1..e6bc7952e 100644
--- a/src/newt/native/KDWindow.c
+++ b/src/newt/native/KDWindow.c
@@ -256,7 +256,7 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_kd_KDWindow_RealizeWindow
     jint res = kdRealizeWindow(w, &nativeWindow);
     if(res) {
         fprintf(stderr, "[RealizeWindow] failed: 0x%X, 0x%X\n", res, kdGetError());
-        nativeWindow = NULL;
+        nativeWindow = 0;
     }
     DBG_PRINT( "[RealizeWindow] ok: %p\n", nativeWindow);
     return (jlong) (intptr_t) nativeWindow;
diff --git a/src/newt/native/KeyEvent.h b/src/newt/native/KeyEvent.h
index 1ead0f5e8..0f7b1606b 100644
--- a/src/newt/native/KeyEvent.h
+++ b/src/newt/native/KeyEvent.h
@@ -1,3 +1,30 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
 
 #ifndef _KEY_EVENT_H_
 #define _KEY_EVENT_H_
diff --git a/src/newt/native/MouseEvent.h b/src/newt/native/MouseEvent.h
index e9c0476ef..59d63cecf 100644
--- a/src/newt/native/MouseEvent.h
+++ b/src/newt/native/MouseEvent.h
@@ -1,3 +1,30 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
 
 #ifndef _MOUSE_EVENT_H_
 #define _MOUSE_EVENT_H_
diff --git a/src/newt/native/NewtCommon.h b/src/newt/native/NewtCommon.h
index 91fceb310..33aba64ae 100644
--- a/src/newt/native/NewtCommon.h
+++ b/src/newt/native/NewtCommon.h
@@ -1,3 +1,30 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
 
 #ifndef NEWT_COMMON_H
 #define NEWT_COMMON_H 1
diff --git a/src/newt/native/NewtMacWindow.h b/src/newt/native/NewtMacWindow.h
index eaece2cf8..3ba89de1e 100644
--- a/src/newt/native/NewtMacWindow.h
+++ b/src/newt/native/NewtMacWindow.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2011 JogAmp Community. All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
diff --git a/src/newt/native/ScreenMode.h b/src/newt/native/ScreenMode.h
index 0a760d54a..bb782910e 100644
--- a/src/newt/native/ScreenMode.h
+++ b/src/newt/native/ScreenMode.h
@@ -1,4 +1,32 @@
 /**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+/**
  * WARNING: must be synced with com.jogamp.newt.util.ScreenModeUtil#streamIn*(int[])
  */
 
diff --git a/src/newt/native/Window.h b/src/newt/native/Window.h
index 865746b91..4755c4fc5 100644
--- a/src/newt/native/Window.h
+++ b/src/newt/native/Window.h
@@ -1,3 +1,30 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
 
 #ifndef _WINDOW_H_
 #define _WINDOW_H_
diff --git a/src/newt/native/WindowEvent.h b/src/newt/native/WindowEvent.h
index 05491b43c..3dc6ba97e 100644
--- a/src/newt/native/WindowEvent.h
+++ b/src/newt/native/WindowEvent.h
@@ -1,3 +1,30 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
 
 #ifndef _WINDOW_EVENT_H_
 #define _WINDOW_EVENT_H_
diff --git a/src/newt/native/WindowsWindow.c b/src/newt/native/WindowsWindow.c
index 9b97895c6..b763d5cad 100644
--- a/src/newt/native/WindowsWindow.c
+++ b/src/newt/native/WindowsWindow.c
@@ -1338,7 +1338,7 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_windows_WindowsWindow_CreateWind
   (JNIEnv *env, jobject obj, 
    jlong hInstance, jstring jWndClassName, jstring jWndName, 
    jlong parent,
-   jint jx, jint jy, jint defaultWidth, jint defaultHeight, jint flags)
+   jint jx, jint jy, jint defaultWidth, jint defaultHeight, jboolean autoPosition, jint flags)
 {
     HWND parentWindow = (HWND) (intptr_t) parent;
     const TCHAR* wndClassName = NULL;
@@ -1367,7 +1367,7 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_windows_WindowsWindow_CreateWind
         windowStyle |= WS_POPUP | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX;
     } else {
         windowStyle |= WS_OVERLAPPEDWINDOW;
-        if(0>_x || 0>_y) {
+        if(JNI_TRUE == autoPosition) {
             // user didn't requested specific position, use WM default
             _x = CW_USEDEFAULT;
             _y = 0;
@@ -1380,9 +1380,9 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_windows_WindowsWindow_CreateWind
                           (HINSTANCE) (intptr_t) hInstance,
                           NULL);
 
-    DBG_PRINT("*** WindowsWindow: CreateWindow thread 0x%X, parent %p, window %p, %d/%d %dx%d, undeco %d, alwaysOnTop %d\n", 
+    DBG_PRINT("*** WindowsWindow: CreateWindow thread 0x%X, parent %p, window %p, %d/%d %dx%d, undeco %d, alwaysOnTop %d, autoPosition %d\n", 
         (int)GetCurrentThreadId(), parentWindow, window, x, y, width, height,
-        TST_FLAG_IS_UNDECORATED(flags), TST_FLAG_IS_ALWAYSONTOP(flags));
+        TST_FLAG_IS_UNDECORATED(flags), TST_FLAG_IS_ALWAYSONTOP(flags), autoPosition);
 
     if (NULL == window) {
         int lastError = (int) GetLastError();
@@ -1402,7 +1402,6 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_windows_WindowsWindow_CreateWind
         {
             RECT rc;
             RECT * insets;
-            BOOL userPos = 0<=x && 0<=y ;
 
             ShowWindow(window, SW_SHOW);
 
@@ -1410,12 +1409,12 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_windows_WindowsWindow_CreateWind
             insets = UpdateInsets(env, wud->jinstance, window);
             (*env)->CallVoidMethod(env, wud->jinstance, visibleChangedID, JNI_FALSE, JNI_TRUE);
 
-            if(!userPos) {
+            if(JNI_TRUE == autoPosition) {
                 GetWindowRect(window, &rc);
                 x = rc.left + insets->left; // client coords
                 y = rc.top + insets->top;   // client coords
             }
-            DBG_PRINT("*** WindowsWindow: CreateWindow client: %d/%d %dx%d (is user-pos %d)\n", x, y, width, height, userPos);
+            DBG_PRINT("*** WindowsWindow: CreateWindow client: %d/%d %dx%d (autoPosition %d)\n", x, y, width, height, autoPosition);
 
             x -= insets->left; // top-level
             y -= insets->top;  // top-level
diff --git a/src/newt/native/X11Common.h b/src/newt/native/X11Common.h
new file mode 100644
index 000000000..20c72752c
--- /dev/null
+++ b/src/newt/native/X11Common.h
@@ -0,0 +1,76 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+#ifndef _X11COMMON_H_
+#define _X11COMMON_H_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include <gluegen_stdint.h>
+
+#include <unistd.h>
+#include <errno.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+#include <X11/Xatom.h>
+
+#include <X11/extensions/Xrandr.h>
+
+#include "jogamp_newt_driver_x11_X11Screen.h"
+#include "jogamp_newt_driver_x11_X11Display.h"
+#include "jogamp_newt_driver_x11_X11Window.h"
+
+#include "Window.h"
+#include "MouseEvent.h"
+#include "InputEvent.h"
+#include "KeyEvent.h"
+#include "WindowEvent.h"
+#include "ScreenMode.h"
+
+#include "NewtCommon.h"
+
+#define VERBOSE_ON 1
+
+#ifdef VERBOSE_ON
+    #define DBG_PRINT(...) fprintf(stderr, __VA_ARGS__); fflush(stderr) 
+#else
+    #define DBG_PRINT(...)
+#endif
+
+extern jclass X11NewtWindowClazz;
+extern jmethodID insetsChangedID;
+extern jmethodID visibleChangedID;
+
+jobject getJavaWindowProperty(JNIEnv *env, Display *dpy, Window window, jlong javaObjectAtom, Bool showWarning);
+
+#endif /* _X11COMMON_H_ */
+
diff --git a/src/newt/native/X11Display.c b/src/newt/native/X11Display.c
new file mode 100644
index 000000000..d6a099f1d
--- /dev/null
+++ b/src/newt/native/X11Display.c
@@ -0,0 +1,660 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+#include "X11Common.h"
+
+#define USE_SENDIO_DIRECT 1
+
+jclass X11NewtWindowClazz = NULL;
+jmethodID insetsChangedID = NULL;
+jmethodID visibleChangedID = NULL;
+
+static const char * const ClazzNameX11NewtWindow = "jogamp/newt/driver/x11/X11Window";
+
+static jmethodID displayCompletedID = NULL;
+
+static jmethodID sizeChangedID = NULL;
+static jmethodID positionChangedID = NULL;
+static jmethodID focusChangedID = NULL;
+static jmethodID reparentNotifyID = NULL;
+static jmethodID windowDestroyNotifyID = NULL;
+static jmethodID windowRepaintID = NULL;
+static jmethodID enqueueMouseEventID = NULL;
+static jmethodID sendMouseEventID = NULL;
+static jmethodID enqueueKeyEventID = NULL;
+static jmethodID sendKeyEventID = NULL;
+static jmethodID requestFocusID = NULL;
+
+static JavaVM *jvmHandle = NULL;
+static int jvmVersion = 0;
+
+static void setupJVMVars(JNIEnv * env) {
+    if(0 != (*env)->GetJavaVM(env, &jvmHandle)) {
+        jvmHandle = NULL;
+    }
+    jvmVersion = (*env)->GetVersion(env);
+}
+
+static XErrorHandler origErrorHandler = NULL ;
+
+static int displayDispatchErrorHandler(Display *dpy, XErrorEvent *e)
+{
+    fprintf(stderr, "Warning: NEWT X11 Error: DisplayDispatch %p, Code 0x%X, errno %s\n", dpy, e->error_code, strerror(errno));
+    
+    if (e->error_code == BadAtom) {
+        fprintf(stderr, "         BadAtom (%p): Atom probably already removed\n", (void*)e->resourceid);
+    } else if (e->error_code == BadWindow) {
+        fprintf(stderr, "         BadWindow (%p): Window probably already removed\n", (void*)e->resourceid);
+    } else {
+        int shallBeDetached = 0;
+        JNIEnv *jniEnv = NULL;
+        const char * errStr = strerror(errno);
+
+        fprintf(stderr, "Info: NEWT X11 Error: Display %p, Code 0x%X, errno %s\n", dpy, e->error_code, errStr);
+
+        jniEnv = NewtCommon_GetJNIEnv(jvmHandle, jvmVersion, &shallBeDetached);
+        if(NULL==jniEnv) {
+            fprintf(stderr, "NEWT X11 Error: null JNIEnv");
+            return;
+        }
+
+        NewtCommon_throwNewRuntimeException(jniEnv, "Info: NEWT X11 Error: Display %p, Code 0x%X, errno %s", 
+                                            dpy, e->error_code, errStr);
+
+        if (shallBeDetached) {
+            (*jvmHandle)->DetachCurrentThread(jvmHandle);
+        }
+    }
+
+    return 0;
+}
+
+static void displayDispatchErrorHandlerEnable(int onoff, JNIEnv * env) {
+    if(onoff) {
+        if(NULL==origErrorHandler) {
+            setupJVMVars(env);
+            origErrorHandler = XSetErrorHandler(displayDispatchErrorHandler);
+        }
+    } else {
+        if(NULL!=origErrorHandler) {
+            XSetErrorHandler(origErrorHandler);
+            origErrorHandler = NULL;
+        }
+    }
+}
+
+/**
+ * Keycode
+ */
+
+#define IS_WITHIN(k,a,b) ((a)<=(k)&&(k)<=(b))
+
+static jint X11KeySym2NewtVKey(KeySym keySym) {
+    if(IS_WITHIN(keySym,XK_F1,XK_F12)) 
+        return (keySym-XK_F1)+J_VK_F1;
+    if(IS_WITHIN(keySym,XK_KP_0,XK_KP_9)) 
+        return (keySym-XK_KP_0)+J_VK_NUMPAD0;
+
+    switch(keySym) {
+        case XK_Return:
+        case XK_KP_Enter:
+            return J_VK_ENTER;
+        case XK_BackSpace:
+            return J_VK_BACK_SPACE;
+        case XK_Tab:
+        case XK_KP_Tab:
+        case XK_ISO_Left_Tab:
+            return J_VK_TAB;
+        case XK_Cancel:
+            return J_VK_CANCEL;
+        case XK_Clear:
+            return J_VK_CLEAR;
+        case XK_Shift_L:
+        case XK_Shift_R:
+            return J_VK_SHIFT;
+        case XK_Control_L:
+        case XK_Control_R:
+            return J_VK_CONTROL;
+        case XK_Alt_L:
+        case XK_Alt_R:
+            return J_VK_ALT;
+        case XK_Pause:
+            return J_VK_PAUSE;
+        case XK_Caps_Lock:
+            return J_VK_CAPS_LOCK;
+        case XK_Escape:
+            return J_VK_ESCAPE;
+        case XK_space:
+        case XK_KP_Space:
+            return J_VK_SPACE;
+        case XK_Page_Up:
+        case XK_KP_Page_Up:
+            return J_VK_PAGE_UP;
+        case XK_Page_Down:
+        case XK_KP_Page_Down:
+            return J_VK_PAGE_DOWN;
+        case XK_End:
+        case XK_KP_End:
+            return J_VK_END;
+        case XK_Home:
+        case XK_KP_Home:
+            return J_VK_HOME;
+        case XK_Left:
+        case XK_KP_Left:
+            return J_VK_LEFT;
+        case XK_Up:
+        case XK_KP_Up:
+            return J_VK_UP;
+        case XK_Right:
+        case XK_KP_Right:
+            return J_VK_RIGHT;
+        case XK_Down:
+        case XK_KP_Down:
+            return J_VK_DOWN;
+        case XK_KP_Multiply:
+            return J_VK_MULTIPLY;
+        case XK_KP_Add:
+            return J_VK_ADD;
+        case XK_KP_Separator:
+            return J_VK_SEPARATOR;
+        case XK_KP_Subtract:
+            return J_VK_SUBTRACT;
+        case XK_KP_Decimal:
+            return J_VK_DECIMAL;
+        case XK_KP_Divide:
+            return J_VK_DIVIDE;
+        case XK_Delete:
+        case XK_KP_Delete:
+            return J_VK_DELETE;
+        case XK_Num_Lock:
+            return J_VK_NUM_LOCK;
+        case XK_Scroll_Lock:
+            return J_VK_SCROLL_LOCK;
+        case XK_Print:
+            return J_VK_PRINTSCREEN;
+        case XK_Insert:
+        case XK_KP_Insert:
+            return J_VK_INSERT;
+        case XK_Help:
+            return J_VK_HELP;
+    }
+    return keySym;
+}
+
+static jint X11InputState2NewtModifiers(unsigned int xstate) {
+    jint modifiers = 0;
+    if ((ControlMask & xstate) != 0) {
+        modifiers |= EVENT_CTRL_MASK;
+    }
+    if ((ShiftMask & xstate) != 0) {
+        modifiers |= EVENT_SHIFT_MASK;
+    }
+    if ((Mod1Mask & xstate) != 0) {
+        modifiers |= EVENT_ALT_MASK;
+    }
+    if ((Button1Mask & xstate) != 0) {
+        modifiers |= EVENT_BUTTON1_MASK;
+    }
+    if ((Button2Mask & xstate) != 0) {
+        modifiers |= EVENT_BUTTON2_MASK;
+    }
+    if ((Button3Mask & xstate) != 0) {
+        modifiers |= EVENT_BUTTON3_MASK;
+    }
+
+    return modifiers;
+}
+
+
+/**
+ * Keycode
+ */
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Display
+ * Method:    initIDs
+ * Signature: (Z)Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Display_initIDs0
+  (JNIEnv *env, jclass clazz)
+{
+    jclass c;
+
+    NewtCommon_init(env);
+
+    if(NULL==X11NewtWindowClazz) {
+        c = (*env)->FindClass(env, ClazzNameX11NewtWindow);
+        if(NULL==c) {
+            NewtCommon_FatalError(env, "NEWT X11Window: can't find %s", ClazzNameX11NewtWindow);
+        }
+        X11NewtWindowClazz = (jclass)(*env)->NewGlobalRef(env, c);
+        (*env)->DeleteLocalRef(env, c);
+        if(NULL==X11NewtWindowClazz) {
+            NewtCommon_FatalError(env, "NEWT X11Window: can't use %s", ClazzNameX11NewtWindow);
+        }
+    }
+
+    displayCompletedID = (*env)->GetMethodID(env, clazz, "displayCompleted", "(JJ)V");
+    insetsChangedID = (*env)->GetMethodID(env, X11NewtWindowClazz, "insetsChanged", "(ZIIII)V");
+    sizeChangedID = (*env)->GetMethodID(env, X11NewtWindowClazz, "sizeChanged", "(ZIIZ)V");
+    positionChangedID = (*env)->GetMethodID(env, X11NewtWindowClazz, "positionChanged", "(ZII)V");
+    focusChangedID = (*env)->GetMethodID(env, X11NewtWindowClazz, "focusChanged", "(ZZ)V");
+    visibleChangedID = (*env)->GetMethodID(env, X11NewtWindowClazz, "visibleChanged", "(ZZ)V");
+    reparentNotifyID = (*env)->GetMethodID(env, X11NewtWindowClazz, "reparentNotify", "(J)V");
+    windowDestroyNotifyID = (*env)->GetMethodID(env, X11NewtWindowClazz, "windowDestroyNotify", "()V");
+    windowRepaintID = (*env)->GetMethodID(env, X11NewtWindowClazz, "windowRepaint", "(ZIIII)V");
+    enqueueMouseEventID = (*env)->GetMethodID(env, X11NewtWindowClazz, "enqueueMouseEvent", "(ZIIIIII)V");
+    sendMouseEventID = (*env)->GetMethodID(env, X11NewtWindowClazz, "sendMouseEvent", "(IIIIII)V");
+    enqueueKeyEventID = (*env)->GetMethodID(env, X11NewtWindowClazz, "enqueueKeyEvent", "(ZIIIC)V");
+    sendKeyEventID = (*env)->GetMethodID(env, X11NewtWindowClazz, "sendKeyEvent", "(IIIC)V");
+    requestFocusID = (*env)->GetMethodID(env, X11NewtWindowClazz, "requestFocus", "(Z)V");
+
+    if (displayCompletedID == NULL ||
+        insetsChangedID == NULL ||
+        sizeChangedID == NULL ||
+        positionChangedID == NULL ||
+        focusChangedID == NULL ||
+        visibleChangedID == NULL ||
+        reparentNotifyID == NULL ||
+        windowDestroyNotifyID == NULL ||
+        windowRepaintID == NULL ||
+        enqueueMouseEventID == NULL ||
+        sendMouseEventID == NULL ||
+        enqueueKeyEventID == NULL ||
+        sendKeyEventID == NULL ||
+        requestFocusID == NULL) {
+        return JNI_FALSE;
+    }
+
+
+    return JNI_TRUE;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Display
+ * Method:    CompleteDisplay
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_CompleteDisplay0
+  (JNIEnv *env, jobject obj, jlong display)
+{
+    Display * dpy = (Display *)(intptr_t)display;
+    jlong javaObjectAtom;
+    jlong windowDeleteAtom;
+
+    if(dpy==NULL) {
+        NewtCommon_FatalError(env, "invalid display connection..");
+    }
+
+    javaObjectAtom = (jlong) XInternAtom(dpy, "NEWT_JAVA_OBJECT", False);
+    if(None==javaObjectAtom) {
+        NewtCommon_throwNewRuntimeException(env, "could not create Atom NEWT_JAVA_OBJECT, bail out!");
+        return;
+    }
+
+    windowDeleteAtom = (jlong) XInternAtom(dpy, "WM_DELETE_WINDOW", False);
+    if(None==windowDeleteAtom) {
+        NewtCommon_throwNewRuntimeException(env, "could not create Atom WM_DELETE_WINDOW, bail out!");
+        return;
+    }
+
+    // XSetCloseDownMode(dpy, RetainTemporary); // Just a try ..
+
+    DBG_PRINT("X11: X11Display_completeDisplay dpy %p\n", dpy);
+
+    (*env)->CallVoidMethod(env, obj, displayCompletedID, javaObjectAtom, windowDeleteAtom);
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Display
+ * Method:    DisplayRelease0
+ * Signature: (JJJ)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_DisplayRelease0
+  (JNIEnv *env, jobject obj, jlong display, jlong javaObjectAtom, jlong windowDeleteAtom)
+{
+    Display * dpy = (Display *)(intptr_t)display;
+    Atom wm_javaobject_atom = (Atom)javaObjectAtom;
+    Atom wm_delete_atom = (Atom)windowDeleteAtom;
+
+    if(dpy==NULL) {
+        NewtCommon_FatalError(env, "invalid display connection..");
+    }
+
+    // nothing to do to free the atoms !
+    (void) wm_javaobject_atom;
+    (void) wm_delete_atom;
+
+    XSync(dpy, True); // discard all pending events
+    DBG_PRINT("X11: X11Display_DisplayRelease dpy %p\n", dpy);
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Display
+ * Method:    DispatchMessages
+ * Signature: (JIJJ)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_DispatchMessages0
+  (JNIEnv *env, jobject obj, jlong display, jlong javaObjectAtom, jlong windowDeleteAtom)
+{
+    Display * dpy = (Display *) (intptr_t) display;
+    Atom wm_delete_atom = (Atom)windowDeleteAtom;
+    int num_events = 100;
+
+    if ( NULL == dpy ) {
+        return;
+    }
+
+    // Periodically take a break
+    while( num_events > 0 ) {
+        jobject jwindow = NULL;
+        XEvent evt;
+        KeySym keySym = 0;
+        jint modifiers = 0;
+        char keyChar = 0;
+        char text[255];
+
+        // XEventsQueued(dpy, X):
+        //   QueuedAlready                 : No I/O Flush or system call  doesn't work on some cards (eg ATI) ?) 
+        //   QueuedAfterFlush == XPending(): I/O Flush only if no already queued events are available
+        //   QueuedAfterReading            : QueuedAlready + if queue==0, attempt to read more ..
+        if ( 0 >= XPending(dpy) ) {
+            // DBG_PRINT( "X11: DispatchMessages 0x%X - Leave 1\n", dpy); 
+            return;
+        }
+
+        XNextEvent(dpy, &evt);
+        num_events--;
+
+        if( 0==evt.xany.window ) {
+            NewtCommon_throwNewRuntimeException(env, "event window NULL, bail out!");
+            return ;
+        }
+
+        if(dpy!=evt.xany.display) {
+            NewtCommon_throwNewRuntimeException(env, "wrong display, bail out!");
+            return ;
+        }
+
+        // DBG_PRINT( "X11: DispatchMessages dpy %p, win %p, Event %d\n", (void*)dpy, (void*)evt.xany.window, (int)evt.type);
+
+        displayDispatchErrorHandlerEnable(1, env);
+
+        jwindow = getJavaWindowProperty(env, dpy, evt.xany.window, javaObjectAtom,
+        #ifdef VERBOSE_ON
+                True
+        #else
+                False
+        #endif
+            );
+
+        displayDispatchErrorHandlerEnable(0, env);
+
+        if(NULL==jwindow) {
+            fprintf(stderr, "Warning: NEWT X11 DisplayDispatch %p, Couldn't handle event %d for X11 window %p\n", 
+                (void*)dpy, evt.type, (void*)evt.xany.window);
+            continue;
+        }
+ 
+        switch(evt.type) {
+            case KeyRelease:
+            case KeyPress:
+                if(XLookupString(&evt.xkey,text,255,&keySym,0)==1) {
+                    KeySym lower_return = 0, upper_return = 0;
+                    keyChar=text[0];
+                    XConvertCase(keySym, &lower_return, &upper_return);
+                    // always return upper case, set modifier masks (SHIFT, ..)
+                    keySym = X11KeySym2NewtVKey(upper_return);
+                } else {
+                    keyChar=0;
+                    keySym = X11KeySym2NewtVKey(keySym);
+                }
+                modifiers = X11InputState2NewtModifiers(evt.xkey.state);
+                break;
+
+            case ButtonPress:
+            case ButtonRelease:
+            case MotionNotify:
+                modifiers = X11InputState2NewtModifiers(evt.xbutton.state);
+                break;
+
+            default:
+                break;
+        }
+
+        switch(evt.type) {
+            case ButtonPress:
+                (*env)->CallVoidMethod(env, jwindow, requestFocusID, JNI_FALSE);
+                #ifdef USE_SENDIO_DIRECT
+                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_PRESSED, 
+                                      modifiers,
+                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
+                #else
+                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_PRESSED, 
+                                      modifiers,
+                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
+                #endif
+                break;
+            case ButtonRelease:
+                #ifdef USE_SENDIO_DIRECT
+                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_RELEASED, 
+                                      modifiers,
+                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
+                #else
+                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_RELEASED, 
+                                      modifiers,
+                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
+                #endif
+                break;
+            case MotionNotify:
+                #ifdef USE_SENDIO_DIRECT
+                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_MOVED, 
+                                      modifiers,
+                                      (jint) evt.xmotion.x, (jint) evt.xmotion.y, (jint) 0, 0 /*rotation*/); 
+                #else
+                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_MOVED, 
+                                      modifiers,
+                                      (jint) evt.xmotion.x, (jint) evt.xmotion.y, (jint) 0, 0 /*rotation*/); 
+                #endif
+                break;
+            case EnterNotify:
+                DBG_PRINT( "X11: event . EnterNotify call %p %d/%d\n", (void*)evt.xcrossing.window, evt.xcrossing.x, evt.xcrossing.y);
+                #ifdef USE_SENDIO_DIRECT
+                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_ENTERED, 
+                                      modifiers,
+                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
+                #else
+                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_ENTERED, 
+                                      modifiers,
+                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
+                #endif
+                break;
+            case LeaveNotify:
+                DBG_PRINT( "X11: event . LeaveNotify call %p %d/%d\n", (void*)evt.xcrossing.window, evt.xcrossing.x, evt.xcrossing.y);
+                #ifdef USE_SENDIO_DIRECT
+                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_EXITED, 
+                                      modifiers,
+                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
+                #else
+                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_EXITED, 
+                                      modifiers,
+                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
+                #endif
+                break;
+            case KeyPress:
+                #ifdef USE_SENDIO_DIRECT
+                (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_PRESSED, 
+                                      modifiers, keySym, (jchar) -1);
+                #else
+                (*env)->CallVoidMethod(env, jwindow, enqueueKeyEventID, JNI_FALSE, (jint) EVENT_KEY_PRESSED, 
+                                      modifiers, keySym, (jchar) -1);
+                #endif
+
+                break;
+            case KeyRelease:
+                #ifdef USE_SENDIO_DIRECT
+                (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_RELEASED, 
+                                      modifiers, keySym, (jchar) -1);
+
+                (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_TYPED, 
+                                      modifiers, keySym, (jchar) keyChar);
+                #else
+                (*env)->CallVoidMethod(env, jwindow, enqueueKeyEventID, JNI_FALSE, (jint) EVENT_KEY_RELEASED, 
+                                      modifiers, keySym, (jchar) -1);
+
+                (*env)->CallVoidMethod(env, jwindow, enqueueKeyEventID, JNI_FALSE, (jint) EVENT_KEY_TYPED, 
+                                      modifiers, keySym, (jchar) keyChar);
+                #endif
+
+                break;
+            case DestroyNotify:
+                DBG_PRINT( "X11: event . DestroyNotify call %p, parent %p, child-event: %d\n", 
+                    (void*)evt.xdestroywindow.window, (void*)evt.xdestroywindow.event, evt.xdestroywindow.window != evt.xdestroywindow.event);
+                if ( evt.xdestroywindow.window == evt.xdestroywindow.event ) {
+                    // ignore child destroy notification
+                }
+                break;
+            case CreateNotify:
+                DBG_PRINT( "X11: event . CreateNotify call %p, parent %p, child-event: 1\n", 
+                    (void*)evt.xcreatewindow.window, (void*) evt.xcreatewindow.parent);
+                break;
+            case ConfigureNotify:
+                DBG_PRINT( "X11: event . ConfigureNotify call %p (parent %p, above %p) %d/%d %dx%d %d, child-event: %d\n", 
+                            (void*)evt.xconfigure.window, (void*)evt.xconfigure.event, (void*)evt.xconfigure.above,
+                            evt.xconfigure.x, evt.xconfigure.y, evt.xconfigure.width, evt.xconfigure.height, 
+                            evt.xconfigure.override_redirect, evt.xconfigure.window != evt.xconfigure.event);
+                if ( evt.xconfigure.window == evt.xconfigure.event ) {
+                    // ignore child window change notification
+                    {
+                        // update insets
+                        int left, right, top, bottom;
+                        NewtWindows_updateInsets(env, jwindow, dpy, evt.xany.window, &left, &right, &top, &bottom);
+                    }
+                    (*env)->CallVoidMethod(env, jwindow, sizeChangedID, JNI_FALSE,
+                                            (jint) evt.xconfigure.width, (jint) evt.xconfigure.height, JNI_FALSE);
+                    (*env)->CallVoidMethod(env, jwindow, positionChangedID, JNI_FALSE,
+                                            (jint) evt.xconfigure.x, (jint) evt.xconfigure.y);
+                }
+                break;
+            case ClientMessage:
+                if (evt.xclient.send_event==True && evt.xclient.data.l[0]==wm_delete_atom) { // windowDeleteAtom
+                    DBG_PRINT( "X11: event . ClientMessage call %p type 0x%X !!!\n", 
+                        (void*)evt.xclient.window, (unsigned int)evt.xclient.message_type);
+                    (*env)->CallVoidMethod(env, jwindow, windowDestroyNotifyID);
+                    // Called by Window.java: CloseWindow(); 
+                    num_events = 0; // end loop in case of destroyed display
+                }
+                break;
+
+            case FocusIn:
+                DBG_PRINT( "X11: event . FocusIn call %p\n", (void*)evt.xvisibility.window);
+                (*env)->CallVoidMethod(env, jwindow, focusChangedID, JNI_FALSE, JNI_TRUE);
+                break;
+
+            case FocusOut:
+                DBG_PRINT( "X11: event . FocusOut call %p\n", (void*)evt.xvisibility.window);
+                (*env)->CallVoidMethod(env, jwindow, focusChangedID, JNI_FALSE, JNI_FALSE);
+                break;
+
+            case Expose:
+                DBG_PRINT( "X11: event . Expose call %p %d/%d %dx%d count %d\n", (void*)evt.xexpose.window,
+                    evt.xexpose.x, evt.xexpose.y, evt.xexpose.width, evt.xexpose.height, evt.xexpose.count);
+
+                if (evt.xexpose.count == 0 && evt.xexpose.width > 0 && evt.xexpose.height > 0) {
+                    (*env)->CallVoidMethod(env, jwindow, windowRepaintID, JNI_FALSE,
+                        evt.xexpose.x, evt.xexpose.y, evt.xexpose.width, evt.xexpose.height);
+                }
+                break;
+
+            case MapNotify:
+                DBG_PRINT( "X11: event . MapNotify call Event %p, Window %p, override_redirect %d, child-event: %d\n", 
+                    (void*)evt.xmap.event, (void*)evt.xmap.window, (int)evt.xmap.override_redirect,
+                    evt.xmap.event!=evt.xmap.window);
+                if( evt.xmap.event == evt.xmap.window ) {
+                    // ignore child window notification
+                    {
+                        // update insets
+                        int left, right, top, bottom;
+                        NewtWindows_updateInsets(env, jwindow, dpy, evt.xany.window, &left, &right, &top, &bottom);
+                    }
+                    (*env)->CallVoidMethod(env, jwindow, visibleChangedID, JNI_FALSE, JNI_TRUE);
+                }
+                break;
+
+            case UnmapNotify:
+                DBG_PRINT( "X11: event . UnmapNotify call Event %p, Window %p, from_configure %d, child-event: %d\n", 
+                    (void*)evt.xunmap.event, (void*)evt.xunmap.window, (int)evt.xunmap.from_configure,
+                    evt.xunmap.event!=evt.xunmap.window);
+                if( evt.xunmap.event == evt.xunmap.window ) {
+                    // ignore child window notification
+                    (*env)->CallVoidMethod(env, jwindow, visibleChangedID, JNI_FALSE, JNI_FALSE);
+                }
+                break;
+
+            case ReparentNotify:
+                {
+                    jlong parentResult; // 0 if root, otherwise proper value
+                    Window winRoot, winTopParent;
+                    #ifdef VERBOSE_ON
+                        Window oldParentRoot, oldParentTopParent;
+                        Window parentRoot, parentTopParent;
+                        if( 0 == NewtWindows_getRootAndParent(dpy, evt.xreparent.event, &oldParentRoot, &oldParentTopParent) ) {
+                            oldParentRoot=0; oldParentTopParent = 0;
+                        }
+                        if( 0 == NewtWindows_getRootAndParent(dpy, evt.xreparent.parent, &parentRoot, &parentTopParent) ) {
+                            parentRoot=0; parentTopParent = 0;
+                        }
+                    #endif
+                    if( 0 == NewtWindows_getRootAndParent(dpy, evt.xreparent.window, &winRoot, &winTopParent) ) {
+                        winRoot=0; winTopParent = 0;
+                    }
+                    if(evt.xreparent.parent == winRoot) {
+                        parentResult = 0; // our java indicator for root window
+                    } else {
+                        parentResult = (jlong) (intptr_t) evt.xreparent.parent;
+                    }
+                    #ifdef VERBOSE_ON
+                        DBG_PRINT( "X11: event . ReparentNotify: call %d/%d OldParent %p (root %p, top %p), NewParent %p (root %p, top %p), Window %p (root %p, top %p)\n", 
+                            evt.xreparent.x, evt.xreparent.y, 
+                            (void*)evt.xreparent.event, (void*)oldParentRoot, (void*)oldParentTopParent,
+                            (void*)evt.xreparent.parent, (void*)parentRoot, (void*)parentTopParent,
+                            (void*)evt.xreparent.window, (void*)winRoot, (void*)winTopParent);
+                    #endif
+                    (*env)->CallVoidMethod(env, jwindow, reparentNotifyID, (jlong)evt.xreparent.parent);
+                }
+                break;
+
+            // unhandled events .. yet ..
+
+            default:
+                DBG_PRINT("X11: event . unhandled %d 0x%X call %p\n", (int)evt.type, (unsigned int)evt.type, (void*)evt.xunmap.window);
+        }
+    }
+}
+
+
diff --git a/src/newt/native/X11Screen.c b/src/newt/native/X11Screen.c
new file mode 100644
index 000000000..ce8265556
--- /dev/null
+++ b/src/newt/native/X11Screen.c
@@ -0,0 +1,469 @@
+/**
+ * Copyright 2011 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+#include "X11Common.h"
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    GetScreen
+ * Signature: (JI)J
+ */
+JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Screen_GetScreen0
+  (JNIEnv *env, jclass clazz, jlong display, jint screen_index)
+{
+    Display * dpy = (Display *)(intptr_t)display;
+    Screen  * scrn= NULL;
+
+    DBG_PRINT("X11: X11Screen_GetScreen0 dpy %p START\n", dpy);
+
+    if(dpy==NULL) {
+        NewtCommon_FatalError(env, "invalid display connection..");
+    }
+
+    scrn = ScreenOfDisplay(dpy, screen_index);
+    if(scrn==NULL) {
+        fprintf(stderr, "couldn't get screen idx %d\n", screen_index);
+    }
+    DBG_PRINT("X11: X11Screen_GetScreen0 idx %d -> scrn %p DONE\n", screen_index, scrn);
+    return (jlong) (intptr_t) scrn;
+}
+
+JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getWidth0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
+{
+    Display * dpy = (Display *) (intptr_t) display;
+    return (jint) XDisplayWidth( dpy, scrn_idx);
+}
+
+JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getHeight0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
+{
+    Display * dpy = (Display *) (intptr_t) display;
+    return (jint) XDisplayHeight( dpy, scrn_idx);
+}
+
+static int showedRandRVersion = 0;
+
+static Bool NewtScreen_getRANDRVersion(Display *dpy, int *major, int *minor) {
+    if( 0 == XRRQueryVersion(dpy, major, minor) ) {
+        return False;
+    }
+    if(0 == showedRandRVersion) {
+        fprintf(stderr, "X11 RandR Version %d.%d\n", *major, *minor);
+        showedRandRVersion = 1;
+    }
+    return True;
+}
+
+static Bool NewtScreen_hasRANDR(Display *dpy) {
+    int major, minor;
+    return NewtScreen_getRANDRVersion(dpy, &major, &minor);
+}
+
+static int NewtScreen_XRotation2Degree(JNIEnv *env, int xrotation) {
+    int rot;
+    if(xrotation == RR_Rotate_0) {
+      rot = 0;
+    }
+    else if(xrotation == RR_Rotate_90) {
+      rot = 90;
+    }
+    else if(xrotation == RR_Rotate_180) {
+      rot = 180;
+    }
+    else if(xrotation == RR_Rotate_270) {
+      rot = 270;
+    } else {
+      NewtCommon_throwNewRuntimeException(env, "invalid native rotation: %d", xrotation);
+    }
+    return rot;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    getAvailableScreenModeRotations0
+ * Signature: (JI)I
+ */
+JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_x11_X11Screen_getAvailableScreenModeRotations0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    Window root = RootWindow(dpy, (int)scrn_idx);
+    int num_rotations = 0;
+    Rotation cur_rotation, rotations_supported;
+    int rotations[4];
+    int major, minor;
+
+    if(False == NewtScreen_getRANDRVersion(dpy, &major, &minor)) {
+        fprintf(stderr, "RANDR not available\n");
+        return (*env)->NewIntArray(env, 0);
+    }
+
+    rotations_supported = XRRRotations (dpy, (int)scrn_idx, &cur_rotation);
+
+    if(0 != (rotations_supported & RR_Rotate_0)) {
+      rotations[num_rotations++] = 0;
+    }
+    if(0 != (rotations_supported & RR_Rotate_90)) {
+      rotations[num_rotations++] = 90;
+    }
+    if(0 != (rotations_supported & RR_Rotate_180)) {
+      rotations[num_rotations++] = 180;
+    }
+    if(0 != (rotations_supported & RR_Rotate_270)) {
+      rotations[num_rotations++] = 270;
+    }
+    
+    jintArray properties = NULL;
+
+    if(num_rotations>0) {
+        properties = (*env)->NewIntArray(env, num_rotations);
+        if (properties == NULL) {
+            NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", num_rotations);
+        }
+        
+        // move from the temp structure to the java structure
+        (*env)->SetIntArrayRegion(env, properties, 0, num_rotations, rotations);
+    }
+        
+    return properties;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    getNumScreenModeResolution0
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getNumScreenModeResolutions0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    
+    if(False == NewtScreen_hasRANDR(dpy)) {
+        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getNumScreenModeResolutions0: RANDR not available\n");
+        return 0;
+    }
+
+    int num_sizes;   
+    XRRScreenSize *xrrs = XRRSizes(dpy, (int)scrn_idx, &num_sizes); //get possible screen resolutions
+    
+    DBG_PRINT("getNumScreenModeResolutions0: %d\n", num_sizes);
+
+    return num_sizes;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    getScreenModeResolutions0
+ * Signature: (JII)[I
+ */
+JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_x11_X11Screen_getScreenModeResolution0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx, jint resMode_idx)
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    
+    if(False == NewtScreen_hasRANDR(dpy)) {
+        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getScreenModeResolution0: RANDR not available\n");
+        return (*env)->NewIntArray(env, 0);
+    }
+
+    int num_sizes;   
+    XRRScreenSize *xrrs = XRRSizes(dpy, (int)scrn_idx, &num_sizes); //get possible screen resolutions
+
+    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
+        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
+    }
+ 
+    // Fill the properties in temp jint array
+    int propIndex = 0;
+    jint prop[4];
+    
+    prop[propIndex++] = xrrs[(int)resMode_idx].width; 
+    prop[propIndex++] = xrrs[(int)resMode_idx].height;
+    prop[propIndex++] = xrrs[(int)resMode_idx].mwidth; 
+    prop[propIndex++] = xrrs[(int)resMode_idx].mheight;
+    
+    jintArray properties = (*env)->NewIntArray(env, 4);
+    if (properties == NULL) {
+        NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", 4);
+    }
+    
+    // move from the temp structure to the java structure
+    (*env)->SetIntArrayRegion(env, properties, 0, 4, prop);
+    
+    return properties;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    getScreenModeRates0
+ * Signature: (JII)[I
+ */
+JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_x11_X11Screen_getScreenModeRates0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx, jint resMode_idx)
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    
+    if(False == NewtScreen_hasRANDR(dpy)) {
+        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getScreenModeRates0: RANDR not available\n");
+        return (*env)->NewIntArray(env, 0);
+    }
+
+    int num_sizes;   
+    XRRScreenSize *xrrs = XRRSizes(dpy, (int)scrn_idx, &num_sizes); //get possible screen resolutions
+
+    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
+        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
+    }
+ 
+    int num_rates;
+    short *rates = XRRRates(dpy, (int)scrn_idx, (int)resMode_idx, &num_rates);
+ 
+    jint prop[num_rates];
+    int i;
+    for(i=0; i<num_rates; i++) {
+        prop[i] = (int) rates[i];
+        /** fprintf(stderr, "rate[%d, %d, %d/%d]: %d\n", (int)scrn_idx, resMode_idx, i, num_rates, prop[i]); */
+    }
+    
+    jintArray properties = (*env)->NewIntArray(env, num_rates);
+    if (properties == NULL) {
+        NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", num_rates);
+    }
+    
+    // move from the temp structure to the java structure
+    (*env)->SetIntArrayRegion(env, properties, 0, num_rates, prop);
+    
+    return properties;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    getCurrentScreenRate0
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRate0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx) 
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    Window root = RootWindow(dpy, (int)scrn_idx);
+    
+    if(False == NewtScreen_hasRANDR(dpy)) {
+        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRate0: RANDR not available\n");
+        return -1;
+    }
+
+    // get current resolutions and frequencies
+    XRRScreenConfiguration  *conf = XRRGetScreenInfo(dpy, root);
+    short original_rate = XRRConfigCurrentRate(conf);
+
+    //free
+    XRRFreeScreenConfigInfo(conf);
+    
+    DBG_PRINT("getCurrentScreenRate0: %d\n", (int)original_rate);
+
+    return (jint) original_rate;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    getCurrentScreenRotation0
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRotation0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    Window root = RootWindow(dpy, (int)scrn_idx);
+    
+    if(False == NewtScreen_hasRANDR(dpy)) {
+        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRotation0: RANDR not available\n");
+        return -1;
+    }
+
+    //get current resolutions and frequencies
+    XRRScreenConfiguration  *conf = XRRGetScreenInfo(dpy, root);
+    
+    Rotation rotation;
+    XRRConfigCurrentConfiguration(conf, &rotation);
+
+    //free
+    XRRFreeScreenConfigInfo(conf);
+    
+    return NewtScreen_XRotation2Degree(env, rotation);
+}
+
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    getCurrentScreenResolutionIndex0
+ * Signature: (JI)I
+ */
+JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenResolutionIndex0
+  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
+{
+   Display *dpy = (Display *) (intptr_t) display;
+   Window root = RootWindow(dpy, (int)scrn_idx);
+  
+   if(False == NewtScreen_hasRANDR(dpy)) {
+       DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenResolutionIndex0: RANDR not available\n");
+       return -1;
+   }
+
+   // get current resolutions and frequency configuration
+   XRRScreenConfiguration  *conf = XRRGetScreenInfo(dpy, root);
+   short original_rate = XRRConfigCurrentRate(conf);
+   
+   Rotation original_rotation;
+   SizeID original_size_id = XRRConfigCurrentConfiguration(conf, &original_rotation);
+   
+   //free
+   XRRFreeScreenConfigInfo(conf);
+   
+   DBG_PRINT("getCurrentScreenResolutionIndex0: %d\n", (int)original_size_id);
+   return (jint)original_size_id;   
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    setCurrentScreenModeStart0
+ * Signature: (JIIII)Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModeStart0
+  (JNIEnv *env, jclass clazz, jlong display, jint screen_idx, jint resMode_idx, jint freq, jint rotation)
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    Window root = RootWindow(dpy, (int)screen_idx);
+
+    if(False == NewtScreen_hasRANDR(dpy)) {
+        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModeStart0: RANDR not available\n");
+        return JNI_FALSE;
+    }
+
+    int num_sizes;   
+    XRRScreenSize *xrrs = XRRSizes(dpy, (int)screen_idx, &num_sizes); //get possible screen resolutions
+    XRRScreenConfiguration *conf;
+    int rot;
+    
+    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
+        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
+    }
+
+    conf = XRRGetScreenInfo(dpy, root);
+   
+    switch(rotation) {
+        case   0:
+            rot = RR_Rotate_0; 
+            break;
+        case  90:
+            rot = RR_Rotate_90; 
+            break;
+        case 180:
+            rot = RR_Rotate_180; 
+            break;
+        case 270:
+            rot = RR_Rotate_270; 
+            break;
+        default:
+            NewtCommon_throwNewRuntimeException(env, "Invalid rotation: %d", rotation);
+    }
+    
+    DBG_PRINT("X11Screen.setCurrentScreenMode0: CHANGED TO %d: %d x %d PIXELS, %d Hz, %d degree\n", 
+        resMode_idx, xrrs[resMode_idx].width, xrrs[resMode_idx].height, (int)freq, rotation);
+
+    XRRSelectInput (dpy, root, RRScreenChangeNotifyMask);
+
+    XSync(dpy, False);
+    XRRSetScreenConfigAndRate(dpy, conf, root, (int)resMode_idx, rot, (short)freq, CurrentTime);   
+    XSync(dpy, False);
+
+    //free
+    XRRFreeScreenConfigInfo(conf);
+    XSync(dpy, False);
+
+    return JNI_TRUE;
+}
+
+/*
+ * Class:     jogamp_newt_driver_x11_X11Screen
+ * Method:    setCurrentScreenModePollEnd0
+ * Signature: (J)Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModePollEnd0
+  (JNIEnv *env, jclass clazz, jlong display, jint screen_idx, jint resMode_idx, jint freq, jint rotation)
+{
+    Display *dpy = (Display *) (intptr_t) display;
+    int randr_event_base, randr_error_base;
+    XEvent evt;
+    XRRScreenChangeNotifyEvent * scn_event = (XRRScreenChangeNotifyEvent *) &evt;
+
+    if(False == NewtScreen_hasRANDR(dpy)) {
+        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModePollEnd0: RANDR not available\n");
+        return JNI_FALSE;
+    }
+
+    int num_sizes;   
+    XRRScreenSize *xrrs = XRRSizes(dpy, (int)screen_idx, &num_sizes); //get possible screen resolutions
+    XRRScreenConfiguration *conf;
+    
+    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
+        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
+    }
+
+    XRRQueryExtension(dpy, &randr_event_base, &randr_error_base);
+
+    int done = 0;
+    int rot;
+    do {
+        if ( 0 >= XEventsQueued(dpy, QueuedAfterFlush) ) {
+            return;
+        }
+        XNextEvent(dpy, &evt);
+
+        switch (evt.type - randr_event_base) {
+            case RRScreenChangeNotify:
+                rot = NewtScreen_XRotation2Degree(env, (int)scn_event->rotation);
+                DBG_PRINT( "XRANDR: event . RRScreenChangeNotify call %p (root %p) resIdx %d rot %d %dx%d\n", 
+                            (void*)scn_event->window, (void*)scn_event->root, 
+                            (int)scn_event->size_index, rot, 
+                            scn_event->width, scn_event->height);
+                // done = scn_event->size_index == resMode_idx; // not reliable ..
+                done = rot == rotation && 
+                       scn_event->width == xrrs[resMode_idx].width && 
+                       scn_event->height == xrrs[resMode_idx].height;
+                break;
+            default:
+                DBG_PRINT("RANDR: event . unhandled %d 0x%X call %p\n", (int)evt.type, (int)evt.type, (void*)evt.xany.window);
+        }
+        XRRUpdateConfiguration(&evt);
+    } while(!done);
+
+    XSync(dpy, False);
+
+}
+
diff --git a/src/newt/native/X11Window.c b/src/newt/native/X11Window.c
index 3613f0018..25c73dd10 100644
--- a/src/newt/native/X11Window.c
+++ b/src/newt/native/X11Window.c
@@ -32,40 +32,9 @@
  * 
  */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-
-#include <gluegen_stdint.h>
-
-#include <unistd.h>
-#include <errno.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/keysym.h>
-#include <X11/Xatom.h>
-
-#include <X11/extensions/Xrandr.h>
-
-#include "jogamp_newt_driver_x11_X11Screen.h"
-#include "jogamp_newt_driver_x11_X11Display.h"
-#include "jogamp_newt_driver_x11_X11Window.h"
-
-#include "Window.h"
-#include "MouseEvent.h"
-#include "InputEvent.h"
-#include "KeyEvent.h"
-#include "WindowEvent.h"
-#include "ScreenMode.h"
-
-#include "NewtCommon.h"
-
-// #define VERBOSE_ON 1
+#include "X11Common.h"
 
 #ifdef VERBOSE_ON
-    #define DBG_PRINT(...) fprintf(stderr, __VA_ARGS__); fflush(stderr) 
-
     #define DUMP_VISUAL_INFO(a,b) _dumpVisualInfo((a),(b))
 
     static void _dumpVisualInfo(const char * msg, XVisualInfo *pVisualQuery) {
@@ -90,315 +59,12 @@
 
 #else
 
-    #define DBG_PRINT(...)
-
     #define DUMP_VISUAL_INFO(a,b)
 
 #endif
 
-/**
- * Keycode
- */
-
-#define IS_WITHIN(k,a,b) ((a)<=(k)&&(k)<=(b))
-
-static jint X11KeySym2NewtVKey(KeySym keySym) {
-    if(IS_WITHIN(keySym,XK_F1,XK_F12)) 
-        return (keySym-XK_F1)+J_VK_F1;
-    if(IS_WITHIN(keySym,XK_KP_0,XK_KP_9)) 
-        return (keySym-XK_KP_0)+J_VK_NUMPAD0;
-
-    switch(keySym) {
-        case XK_Return:
-        case XK_KP_Enter:
-            return J_VK_ENTER;
-        case XK_BackSpace:
-            return J_VK_BACK_SPACE;
-        case XK_Tab:
-        case XK_KP_Tab:
-        case XK_ISO_Left_Tab:
-            return J_VK_TAB;
-        case XK_Cancel:
-            return J_VK_CANCEL;
-        case XK_Clear:
-            return J_VK_CLEAR;
-        case XK_Shift_L:
-        case XK_Shift_R:
-            return J_VK_SHIFT;
-        case XK_Control_L:
-        case XK_Control_R:
-            return J_VK_CONTROL;
-        case XK_Alt_L:
-        case XK_Alt_R:
-            return J_VK_ALT;
-        case XK_Pause:
-            return J_VK_PAUSE;
-        case XK_Caps_Lock:
-            return J_VK_CAPS_LOCK;
-        case XK_Escape:
-            return J_VK_ESCAPE;
-        case XK_space:
-        case XK_KP_Space:
-            return J_VK_SPACE;
-        case XK_Page_Up:
-        case XK_KP_Page_Up:
-            return J_VK_PAGE_UP;
-        case XK_Page_Down:
-        case XK_KP_Page_Down:
-            return J_VK_PAGE_DOWN;
-        case XK_End:
-        case XK_KP_End:
-            return J_VK_END;
-        case XK_Home:
-        case XK_KP_Home:
-            return J_VK_HOME;
-        case XK_Left:
-        case XK_KP_Left:
-            return J_VK_LEFT;
-        case XK_Up:
-        case XK_KP_Up:
-            return J_VK_UP;
-        case XK_Right:
-        case XK_KP_Right:
-            return J_VK_RIGHT;
-        case XK_Down:
-        case XK_KP_Down:
-            return J_VK_DOWN;
-        case XK_KP_Multiply:
-            return J_VK_MULTIPLY;
-        case XK_KP_Add:
-            return J_VK_ADD;
-        case XK_KP_Separator:
-            return J_VK_SEPARATOR;
-        case XK_KP_Subtract:
-            return J_VK_SUBTRACT;
-        case XK_KP_Decimal:
-            return J_VK_DECIMAL;
-        case XK_KP_Divide:
-            return J_VK_DIVIDE;
-        case XK_Delete:
-        case XK_KP_Delete:
-            return J_VK_DELETE;
-        case XK_Num_Lock:
-            return J_VK_NUM_LOCK;
-        case XK_Scroll_Lock:
-            return J_VK_SCROLL_LOCK;
-        case XK_Print:
-            return J_VK_PRINTSCREEN;
-        case XK_Insert:
-        case XK_KP_Insert:
-            return J_VK_INSERT;
-        case XK_Help:
-            return J_VK_HELP;
-    }
-    return keySym;
-}
-
-static jint X11InputState2NewtModifiers(unsigned int xstate) {
-    jint modifiers = 0;
-    if ((ControlMask & xstate) != 0) {
-        modifiers |= EVENT_CTRL_MASK;
-    }
-    if ((ShiftMask & xstate) != 0) {
-        modifiers |= EVENT_SHIFT_MASK;
-    }
-    if ((Mod1Mask & xstate) != 0) {
-        modifiers |= EVENT_ALT_MASK;
-    }
-    if ((Button1Mask & xstate) != 0) {
-        modifiers |= EVENT_BUTTON1_MASK;
-    }
-    if ((Button2Mask & xstate) != 0) {
-        modifiers |= EVENT_BUTTON2_MASK;
-    }
-    if ((Button3Mask & xstate) != 0) {
-        modifiers |= EVENT_BUTTON3_MASK;
-    }
-
-    return modifiers;
-}
-
 #define X11_MOUSE_EVENT_MASK (ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | LeaveWindowMask)
 
-static const char * const ClazzNameNewtWindow = "com/jogamp/newt/Window";
-
-static jclass    newtWindowClz=NULL;
-
-static jmethodID insetsChangedID = NULL;
-static jmethodID sizeChangedID = NULL;
-static jmethodID positionChangedID = NULL;
-static jmethodID focusChangedID = NULL;
-static jmethodID visibleChangedID = NULL;
-static jmethodID reparentNotifyID = NULL;
-static jmethodID windowDestroyNotifyID = NULL;
-static jmethodID windowRepaintID = NULL;
-static jmethodID enqueueMouseEventID = NULL;
-static jmethodID sendMouseEventID = NULL;
-static jmethodID enqueueKeyEventID = NULL;
-static jmethodID sendKeyEventID = NULL;
-static jmethodID requestFocusID = NULL;
-
-static jmethodID displayCompletedID = NULL;
-
-
-/**
- * Display
- */
-
-static JavaVM *jvmHandle = NULL;
-static int jvmVersion = 0;
-
-static void setupJVMVars(JNIEnv * env) {
-    if(0 != (*env)->GetJavaVM(env, &jvmHandle)) {
-        jvmHandle = NULL;
-    }
-    jvmVersion = (*env)->GetVersion(env);
-}
-
-static XErrorHandler origErrorHandler = NULL ;
-
-static int displayDispatchErrorHandler(Display *dpy, XErrorEvent *e)
-{
-    fprintf(stderr, "Warning: NEWT X11 Error: DisplayDispatch %p, Code 0x%X, errno %s\n", dpy, e->error_code, strerror(errno));
-    
-    if (e->error_code == BadAtom) {
-        fprintf(stderr, "         BadAtom (%p): Atom probably already removed\n", (void*)e->resourceid);
-    } else if (e->error_code == BadWindow) {
-        fprintf(stderr, "         BadWindow (%p): Window probably already removed\n", (void*)e->resourceid);
-    } else {
-        int shallBeDetached = 0;
-        JNIEnv *jniEnv = NULL;
-        const char * errStr = strerror(errno);
-
-        fprintf(stderr, "Info: NEWT X11 Error: Display %p, Code 0x%X, errno %s\n", dpy, e->error_code, errStr);
-
-        jniEnv = NewtCommon_GetJNIEnv(jvmHandle, jvmVersion, &shallBeDetached);
-        if(NULL==jniEnv) {
-            fprintf(stderr, "NEWT X11 Error: null JNIEnv");
-            return;
-        }
-
-        NewtCommon_throwNewRuntimeException(jniEnv, "Info: NEWT X11 Error: Display %p, Code 0x%X, errno %s", 
-                                            dpy, e->error_code, errStr);
-
-        if (shallBeDetached) {
-            (*jvmHandle)->DetachCurrentThread(jvmHandle);
-        }
-    }
-
-    return 0;
-}
-
-static void displayDispatchErrorHandlerEnable(int onoff, JNIEnv * env) {
-    if(onoff) {
-        if(NULL==origErrorHandler) {
-            setupJVMVars(env);
-            origErrorHandler = XSetErrorHandler(displayDispatchErrorHandler);
-        }
-    } else {
-        if(NULL!=origErrorHandler) {
-            XSetErrorHandler(origErrorHandler);
-            origErrorHandler = NULL;
-        }
-    }
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Display
- * Method:    initIDs
- * Signature: (Z)Z
- */
-JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Display_initIDs0
-  (JNIEnv *env, jclass clazz)
-{
-    jclass c;
-
-    NewtCommon_init(env);
-
-    displayCompletedID = (*env)->GetMethodID(env, clazz, "displayCompleted", "(JJ)V");
-    if (displayCompletedID == NULL) {
-        return JNI_FALSE;
-    }
-
-    if(NULL==newtWindowClz) {
-        c = (*env)->FindClass(env, ClazzNameNewtWindow);
-        if(NULL==c) {
-            NewtCommon_FatalError(env, "NEWT X11Window: can't find %s", ClazzNameNewtWindow);
-        }
-        newtWindowClz = (jclass)(*env)->NewGlobalRef(env, c);
-        (*env)->DeleteLocalRef(env, c);
-        if(NULL==newtWindowClz) {
-            NewtCommon_FatalError(env, "NEWT X11Window: can't use %s", ClazzNameNewtWindow);
-        }
-    }
-
-    return JNI_TRUE;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Display
- * Method:    CompleteDisplay
- * Signature: (J)V
- */
-JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_CompleteDisplay0
-  (JNIEnv *env, jobject obj, jlong display)
-{
-    Display * dpy = (Display *)(intptr_t)display;
-    jlong javaObjectAtom;
-    jlong windowDeleteAtom;
-
-    if(dpy==NULL) {
-        NewtCommon_FatalError(env, "invalid display connection..");
-    }
-
-    javaObjectAtom = (jlong) XInternAtom(dpy, "NEWT_JAVA_OBJECT", False);
-    if(None==javaObjectAtom) {
-        NewtCommon_throwNewRuntimeException(env, "could not create Atom NEWT_JAVA_OBJECT, bail out!");
-        return;
-    }
-
-    windowDeleteAtom = (jlong) XInternAtom(dpy, "WM_DELETE_WINDOW", False);
-    if(None==windowDeleteAtom) {
-        NewtCommon_throwNewRuntimeException(env, "could not create Atom WM_DELETE_WINDOW, bail out!");
-        return;
-    }
-
-    // XSetCloseDownMode(dpy, RetainTemporary); // Just a try ..
-
-    DBG_PRINT("X11: X11Display_completeDisplay dpy %p\n", dpy);
-
-    (*env)->CallVoidMethod(env, obj, displayCompletedID, javaObjectAtom, windowDeleteAtom);
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Display
- * Method:    DisplayRelease0
- * Signature: (JJJ)V
- */
-JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_DisplayRelease0
-  (JNIEnv *env, jobject obj, jlong display, jlong javaObjectAtom, jlong windowDeleteAtom)
-{
-    Display * dpy = (Display *)(intptr_t)display;
-    Atom wm_javaobject_atom = (Atom)javaObjectAtom;
-    Atom wm_delete_atom = (Atom)windowDeleteAtom;
-
-    if(dpy==NULL) {
-        NewtCommon_FatalError(env, "invalid display connection..");
-    }
-
-    // nothing to do to free the atoms !
-    (void) wm_javaobject_atom;
-    (void) wm_delete_atom;
-
-    XSync(dpy, True); // discard all pending events
-    DBG_PRINT("X11: X11Display_DisplayRelease dpy %p\n", dpy);
-}
-
-
-/**
- * Window
- */
-
 static int putPtrIn32Long(unsigned long * dst, uintptr_t src) {
     int i=0;
         dst[i++] = (unsigned long) ( ( src >>  0 ) & 0xFFFFFFFF ) ;
@@ -431,7 +97,7 @@ static void setJavaWindowProperty(JNIEnv *env, Display *dpy, Window window, jlon
                                      (unsigned char *)&jogl_java_object_data, nitems_32);
 }
 
-static jobject getJavaWindowProperty(JNIEnv *env, Display *dpy, Window window, jlong javaObjectAtom, Bool showWarning) {
+jobject getJavaWindowProperty(JNIEnv *env, Display *dpy, Window window, jlong javaObjectAtom, Bool showWarning) {
     Atom actual_type;
     int actual_format;
     int nitems_32 = ( sizeof(uintptr_t) == 8 ) ? 2 : 1 ;
@@ -469,7 +135,7 @@ static jobject getJavaWindowProperty(JNIEnv *env, Display *dpy, Window window, j
     XFree(jogl_java_object_data_pp);
 
 #ifdef VERBOSE_ON
-    if(JNI_FALSE == (*env)->IsInstanceOf(env, jwindow, newtWindowClz)) {
+    if(JNI_FALSE == (*env)->IsInstanceOf(env, jwindow, X11NewtWindowClazz)) {
         NewtCommon_throwNewRuntimeException(env, "fetched Atom NEWT_JAVA_OBJECT window is not a NEWT Window: javaWindow 0x%X !", jwindow);
     }
 #endif
@@ -764,753 +430,6 @@ static Bool NewtWindows_setFullscreenEWMH (Display *dpy, Window root, Window w,
     return res;
 }
 
-#define USE_SENDIO_DIRECT 1
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Display
- * Method:    DispatchMessages
- * Signature: (JIJJ)V
- */
-JNIEXPORT void JNICALL Java_jogamp_newt_driver_x11_X11Display_DispatchMessages0
-  (JNIEnv *env, jobject obj, jlong display, jlong javaObjectAtom, jlong windowDeleteAtom)
-{
-    Display * dpy = (Display *) (intptr_t) display;
-    Atom wm_delete_atom = (Atom)windowDeleteAtom;
-    int num_events = 100;
-
-    if ( NULL == dpy ) {
-        return;
-    }
-
-    // Periodically take a break
-    while( num_events > 0 ) {
-        jobject jwindow = NULL;
-        XEvent evt;
-        KeySym keySym = 0;
-        jint modifiers = 0;
-        char keyChar = 0;
-        char text[255];
-
-        // XEventsQueued(dpy, X):
-        //   QueuedAlready                 : No I/O Flush or system call  doesn't work on some cards (eg ATI) ?) 
-        //   QueuedAfterFlush == XPending(): I/O Flush only if no already queued events are available
-        //   QueuedAfterReading            : QueuedAlready + if queue==0, attempt to read more ..
-        if ( 0 >= XPending(dpy) ) {
-            // DBG_PRINT( "X11: DispatchMessages 0x%X - Leave 1\n", dpy); 
-            return;
-        }
-
-        XNextEvent(dpy, &evt);
-        num_events--;
-
-        if( 0==evt.xany.window ) {
-            NewtCommon_throwNewRuntimeException(env, "event window NULL, bail out!");
-            return ;
-        }
-
-        if(dpy!=evt.xany.display) {
-            NewtCommon_throwNewRuntimeException(env, "wrong display, bail out!");
-            return ;
-        }
-
-        // DBG_PRINT( "X11: DispatchMessages dpy %p, win %p, Event %d\n", (void*)dpy, (void*)evt.xany.window, (int)evt.type);
-
-        displayDispatchErrorHandlerEnable(1, env);
-
-        jwindow = getJavaWindowProperty(env, dpy, evt.xany.window, javaObjectAtom,
-        #ifdef VERBOSE_ON
-                True
-        #else
-                False
-        #endif
-            );
-
-        displayDispatchErrorHandlerEnable(0, env);
-
-        if(NULL==jwindow) {
-            fprintf(stderr, "Warning: NEWT X11 DisplayDispatch %p, Couldn't handle event %d for X11 window %p\n", 
-                (void*)dpy, evt.type, (void*)evt.xany.window);
-            continue;
-        }
- 
-        switch(evt.type) {
-            case KeyRelease:
-            case KeyPress:
-                if(XLookupString(&evt.xkey,text,255,&keySym,0)==1) {
-                    KeySym lower_return = 0, upper_return = 0;
-                    keyChar=text[0];
-                    XConvertCase(keySym, &lower_return, &upper_return);
-                    // always return upper case, set modifier masks (SHIFT, ..)
-                    keySym = X11KeySym2NewtVKey(upper_return);
-                } else {
-                    keyChar=0;
-                    keySym = X11KeySym2NewtVKey(keySym);
-                }
-                modifiers = X11InputState2NewtModifiers(evt.xkey.state);
-                break;
-
-            case ButtonPress:
-            case ButtonRelease:
-            case MotionNotify:
-                modifiers = X11InputState2NewtModifiers(evt.xbutton.state);
-                break;
-
-            default:
-                break;
-        }
-
-        switch(evt.type) {
-            case ButtonPress:
-                (*env)->CallVoidMethod(env, jwindow, requestFocusID, JNI_FALSE);
-                #ifdef USE_SENDIO_DIRECT
-                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_PRESSED, 
-                                      modifiers,
-                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
-                #else
-                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_PRESSED, 
-                                      modifiers,
-                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
-                #endif
-                break;
-            case ButtonRelease:
-                #ifdef USE_SENDIO_DIRECT
-                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_RELEASED, 
-                                      modifiers,
-                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
-                #else
-                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_RELEASED, 
-                                      modifiers,
-                                      (jint) evt.xbutton.x, (jint) evt.xbutton.y, (jint) evt.xbutton.button, 0 /*rotation*/);
-                #endif
-                break;
-            case MotionNotify:
-                #ifdef USE_SENDIO_DIRECT
-                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_MOVED, 
-                                      modifiers,
-                                      (jint) evt.xmotion.x, (jint) evt.xmotion.y, (jint) 0, 0 /*rotation*/); 
-                #else
-                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_MOVED, 
-                                      modifiers,
-                                      (jint) evt.xmotion.x, (jint) evt.xmotion.y, (jint) 0, 0 /*rotation*/); 
-                #endif
-                break;
-            case EnterNotify:
-                DBG_PRINT( "X11: event . EnterNotify call %p %d/%d\n", (void*)evt.xcrossing.window, evt.xcrossing.x, evt.xcrossing.y);
-                #ifdef USE_SENDIO_DIRECT
-                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_ENTERED, 
-                                      modifiers,
-                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
-                #else
-                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_ENTERED, 
-                                      modifiers,
-                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
-                #endif
-                break;
-            case LeaveNotify:
-                DBG_PRINT( "X11: event . LeaveNotify call %p %d/%d\n", (void*)evt.xcrossing.window, evt.xcrossing.x, evt.xcrossing.y);
-                #ifdef USE_SENDIO_DIRECT
-                (*env)->CallVoidMethod(env, jwindow, sendMouseEventID, (jint) EVENT_MOUSE_EXITED, 
-                                      modifiers,
-                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
-                #else
-                (*env)->CallVoidMethod(env, jwindow, enqueueMouseEventID, JNI_FALSE, (jint) EVENT_MOUSE_EXITED, 
-                                      modifiers,
-                                      (jint) evt.xcrossing.x, (jint) evt.xcrossing.y, (jint) 0, 0 /*rotation*/); 
-                #endif
-                break;
-            case KeyPress:
-                #ifdef USE_SENDIO_DIRECT
-                (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_PRESSED, 
-                                      modifiers, keySym, (jchar) -1);
-                #else
-                (*env)->CallVoidMethod(env, jwindow, enqueueKeyEventID, JNI_FALSE, (jint) EVENT_KEY_PRESSED, 
-                                      modifiers, keySym, (jchar) -1);
-                #endif
-
-                break;
-            case KeyRelease:
-                #ifdef USE_SENDIO_DIRECT
-                (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_RELEASED, 
-                                      modifiers, keySym, (jchar) -1);
-
-                (*env)->CallVoidMethod(env, jwindow, sendKeyEventID, (jint) EVENT_KEY_TYPED, 
-                                      modifiers, keySym, (jchar) keyChar);
-                #else
-                (*env)->CallVoidMethod(env, jwindow, enqueueKeyEventID, JNI_FALSE, (jint) EVENT_KEY_RELEASED, 
-                                      modifiers, keySym, (jchar) -1);
-
-                (*env)->CallVoidMethod(env, jwindow, enqueueKeyEventID, JNI_FALSE, (jint) EVENT_KEY_TYPED, 
-                                      modifiers, keySym, (jchar) keyChar);
-                #endif
-
-                break;
-            case DestroyNotify:
-                DBG_PRINT( "X11: event . DestroyNotify call %p, parent %p, child-event: %d\n", 
-                    (void*)evt.xdestroywindow.window, (void*)evt.xdestroywindow.event, evt.xdestroywindow.window != evt.xdestroywindow.event);
-                if ( evt.xdestroywindow.window == evt.xdestroywindow.event ) {
-                    // ignore child destroy notification
-                }
-                break;
-            case CreateNotify:
-                DBG_PRINT( "X11: event . CreateNotify call %p, parent %p, child-event: 1\n", 
-                    (void*)evt.xcreatewindow.window, (void*) evt.xcreatewindow.parent);
-                break;
-            case ConfigureNotify:
-                DBG_PRINT( "X11: event . ConfigureNotify call %p (parent %p, above %p) %d/%d %dx%d %d, child-event: %d\n", 
-                            (void*)evt.xconfigure.window, (void*)evt.xconfigure.event, (void*)evt.xconfigure.above,
-                            evt.xconfigure.x, evt.xconfigure.y, evt.xconfigure.width, evt.xconfigure.height, 
-                            evt.xconfigure.override_redirect, evt.xconfigure.window != evt.xconfigure.event);
-                if ( evt.xconfigure.window == evt.xconfigure.event ) {
-                    // ignore child window change notification
-                    {
-                        // update insets
-                        int left, right, top, bottom;
-                        NewtWindows_updateInsets(env, jwindow, dpy, evt.xany.window, &left, &right, &top, &bottom);
-                    }
-                    (*env)->CallVoidMethod(env, jwindow, sizeChangedID, JNI_FALSE,
-                                            (jint) evt.xconfigure.width, (jint) evt.xconfigure.height, JNI_FALSE);
-                    (*env)->CallVoidMethod(env, jwindow, positionChangedID, JNI_FALSE,
-                                            (jint) evt.xconfigure.x, (jint) evt.xconfigure.y);
-                }
-                break;
-            case ClientMessage:
-                if (evt.xclient.send_event==True && evt.xclient.data.l[0]==wm_delete_atom) { // windowDeleteAtom
-                    DBG_PRINT( "X11: event . ClientMessage call %p type 0x%X !!!\n", 
-                        (void*)evt.xclient.window, (unsigned int)evt.xclient.message_type);
-                    (*env)->CallVoidMethod(env, jwindow, windowDestroyNotifyID);
-                    // Called by Window.java: CloseWindow(); 
-                    num_events = 0; // end loop in case of destroyed display
-                }
-                break;
-
-            case FocusIn:
-                DBG_PRINT( "X11: event . FocusIn call %p\n", (void*)evt.xvisibility.window);
-                (*env)->CallVoidMethod(env, jwindow, focusChangedID, JNI_FALSE, JNI_TRUE);
-                break;
-
-            case FocusOut:
-                DBG_PRINT( "X11: event . FocusOut call %p\n", (void*)evt.xvisibility.window);
-                (*env)->CallVoidMethod(env, jwindow, focusChangedID, JNI_FALSE, JNI_FALSE);
-                break;
-
-            case Expose:
-                DBG_PRINT( "X11: event . Expose call %p %d/%d %dx%d count %d\n", (void*)evt.xexpose.window,
-                    evt.xexpose.x, evt.xexpose.y, evt.xexpose.width, evt.xexpose.height, evt.xexpose.count);
-
-                if (evt.xexpose.count == 0 && evt.xexpose.width > 0 && evt.xexpose.height > 0) {
-                    (*env)->CallVoidMethod(env, jwindow, windowRepaintID, JNI_FALSE,
-                        evt.xexpose.x, evt.xexpose.y, evt.xexpose.width, evt.xexpose.height);
-                }
-                break;
-
-            case MapNotify:
-                DBG_PRINT( "X11: event . MapNotify call Event %p, Window %p, override_redirect %d, child-event: %d\n", 
-                    (void*)evt.xmap.event, (void*)evt.xmap.window, (int)evt.xmap.override_redirect,
-                    evt.xmap.event!=evt.xmap.window);
-                if( evt.xmap.event == evt.xmap.window ) {
-                    // ignore child window notification
-                    {
-                        // update insets
-                        int left, right, top, bottom;
-                        NewtWindows_updateInsets(env, jwindow, dpy, evt.xany.window, &left, &right, &top, &bottom);
-                    }
-                    (*env)->CallVoidMethod(env, jwindow, visibleChangedID, JNI_FALSE, JNI_TRUE);
-                }
-                break;
-
-            case UnmapNotify:
-                DBG_PRINT( "X11: event . UnmapNotify call Event %p, Window %p, from_configure %d, child-event: %d\n", 
-                    (void*)evt.xunmap.event, (void*)evt.xunmap.window, (int)evt.xunmap.from_configure,
-                    evt.xunmap.event!=evt.xunmap.window);
-                if( evt.xunmap.event == evt.xunmap.window ) {
-                    // ignore child window notification
-                    (*env)->CallVoidMethod(env, jwindow, visibleChangedID, JNI_FALSE, JNI_FALSE);
-                }
-                break;
-
-            case ReparentNotify:
-                {
-                    jlong parentResult; // 0 if root, otherwise proper value
-                    Window winRoot, winTopParent;
-                    #ifdef VERBOSE_ON
-                        Window oldParentRoot, oldParentTopParent;
-                        Window parentRoot, parentTopParent;
-                        if( 0 == NewtWindows_getRootAndParent(dpy, evt.xreparent.event, &oldParentRoot, &oldParentTopParent) ) {
-                            oldParentRoot=0; oldParentTopParent = 0;
-                        }
-                        if( 0 == NewtWindows_getRootAndParent(dpy, evt.xreparent.parent, &parentRoot, &parentTopParent) ) {
-                            parentRoot=0; parentTopParent = 0;
-                        }
-                    #endif
-                    if( 0 == NewtWindows_getRootAndParent(dpy, evt.xreparent.window, &winRoot, &winTopParent) ) {
-                        winRoot=0; winTopParent = 0;
-                    }
-                    if(evt.xreparent.parent == winRoot) {
-                        parentResult = 0; // our java indicator for root window
-                    } else {
-                        parentResult = (jlong) (intptr_t) evt.xreparent.parent;
-                    }
-                    #ifdef VERBOSE_ON
-                        DBG_PRINT( "X11: event . ReparentNotify: call %d/%d OldParent %p (root %p, top %p), NewParent %p (root %p, top %p), Window %p (root %p, top %p)\n", 
-                            evt.xreparent.x, evt.xreparent.y, 
-                            (void*)evt.xreparent.event, (void*)oldParentRoot, (void*)oldParentTopParent,
-                            (void*)evt.xreparent.parent, (void*)parentRoot, (void*)parentTopParent,
-                            (void*)evt.xreparent.window, (void*)winRoot, (void*)winTopParent);
-                    #endif
-                    (*env)->CallVoidMethod(env, jwindow, reparentNotifyID, (jlong)evt.xreparent.parent);
-                }
-                break;
-
-            // unhandled events .. yet ..
-
-            default:
-                DBG_PRINT("X11: event . unhandled %d 0x%X call %p\n", (int)evt.type, (unsigned int)evt.type, (void*)evt.xunmap.window);
-        }
-    }
-}
-
-
-/**
- * Screen
- */
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    GetScreen
- * Signature: (JI)J
- */
-JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Screen_GetScreen0
-  (JNIEnv *env, jclass clazz, jlong display, jint screen_index)
-{
-    Display * dpy = (Display *)(intptr_t)display;
-    Screen  * scrn= NULL;
-
-    DBG_PRINT("X11: X11Screen_GetScreen0 dpy %p START\n", dpy);
-
-    if(dpy==NULL) {
-        NewtCommon_FatalError(env, "invalid display connection..");
-    }
-
-    scrn = ScreenOfDisplay(dpy, screen_index);
-    if(scrn==NULL) {
-        fprintf(stderr, "couldn't get screen idx %d\n", screen_index);
-    }
-    DBG_PRINT("X11: X11Screen_GetScreen0 idx %d -> scrn %p DONE\n", screen_index, scrn);
-    return (jlong) (intptr_t) scrn;
-}
-
-JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getWidth0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
-{
-    Display * dpy = (Display *) (intptr_t) display;
-    return (jint) XDisplayWidth( dpy, scrn_idx);
-}
-
-JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getHeight0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
-{
-    Display * dpy = (Display *) (intptr_t) display;
-    return (jint) XDisplayHeight( dpy, scrn_idx);
-}
-
-
-static Bool NewtScreen_getRANDRVersion(Display *dpy, int *major, int *minor) {
-    if( 0 == XRRQueryVersion(dpy, major, minor) ) {
-        return False;
-    }
-    return True;
-}
-
-static Bool NewtScreen_hasRANDR(Display *dpy) {
-    int major, minor;
-    return NewtScreen_getRANDRVersion(dpy, &major, &minor);
-}
-
-static int NewtScreen_XRotation2Degree(JNIEnv *env, int xrotation) {
-    int rot;
-    if(xrotation == RR_Rotate_0) {
-      rot = 0;
-    }
-    else if(xrotation == RR_Rotate_90) {
-      rot = 90;
-    }
-    else if(xrotation == RR_Rotate_180) {
-      rot = 180;
-    }
-    else if(xrotation == RR_Rotate_270) {
-      rot = 270;
-    } else {
-      NewtCommon_throwNewRuntimeException(env, "invalid native rotation: %d", xrotation);
-    }
-    return rot;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    getAvailableScreenModeRotations0
- * Signature: (JI)I
- */
-JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_x11_X11Screen_getAvailableScreenModeRotations0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    Window root = RootWindow(dpy, (int)scrn_idx);
-    int num_rotations = 0;
-    Rotation cur_rotation, rotations_supported;
-    int rotations[4];
-    int major, minor;
-
-    if(False == NewtScreen_getRANDRVersion(dpy, &major, &minor)) {
-        fprintf(stderr, "RANDR not available\n");
-        return (*env)->NewIntArray(env, 0);
-    }
-
-    rotations_supported = XRRRotations (dpy, (int)scrn_idx, &cur_rotation);
-
-    if(0 != (rotations_supported & RR_Rotate_0)) {
-      rotations[num_rotations++] = 0;
-    }
-    if(0 != (rotations_supported & RR_Rotate_90)) {
-      rotations[num_rotations++] = 90;
-    }
-    if(0 != (rotations_supported & RR_Rotate_180)) {
-      rotations[num_rotations++] = 180;
-    }
-    if(0 != (rotations_supported & RR_Rotate_270)) {
-      rotations[num_rotations++] = 270;
-    }
-    
-    jintArray properties = NULL;
-
-    if(num_rotations>0) {
-        properties = (*env)->NewIntArray(env, num_rotations);
-        if (properties == NULL) {
-            NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", num_rotations);
-        }
-        
-        // move from the temp structure to the java structure
-        (*env)->SetIntArrayRegion(env, properties, 0, num_rotations, rotations);
-    }
-        
-    return properties;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    getNumScreenModeResolution0
- * Signature: (JI)I
- */
-JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getNumScreenModeResolutions0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    Window root = RootWindow(dpy, (int)scrn_idx);
-    
-    if(False == NewtScreen_hasRANDR(dpy)) {
-        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getNumScreenModeResolutions0: RANDR not available\n");
-        return 0;
-    }
-
-    int num_sizes;   
-    XRRScreenSize *xrrs = XRRSizes(dpy, (int)scrn_idx, &num_sizes); //get possible screen resolutions
-    
-    DBG_PRINT("getNumScreenModeResolutions0: %d\n", num_sizes);
-
-    return num_sizes;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    getScreenModeResolutions0
- * Signature: (JII)[I
- */
-JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_x11_X11Screen_getScreenModeResolution0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx, jint resMode_idx)
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    Window root = RootWindow(dpy, (int)scrn_idx);
-    
-    if(False == NewtScreen_hasRANDR(dpy)) {
-        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getScreenModeResolution0: RANDR not available\n");
-        return (*env)->NewIntArray(env, 0);
-    }
-
-    int num_sizes;   
-    XRRScreenSize *xrrs = XRRSizes(dpy, (int)scrn_idx, &num_sizes); //get possible screen resolutions
-
-    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
-        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
-    }
- 
-    // Fill the properties in temp jint array
-    int propIndex = 0;
-    jint prop[4];
-    
-    prop[propIndex++] = xrrs[(int)resMode_idx].width; 
-    prop[propIndex++] = xrrs[(int)resMode_idx].height;
-    prop[propIndex++] = xrrs[(int)resMode_idx].mwidth; 
-    prop[propIndex++] = xrrs[(int)resMode_idx].mheight;
-    
-    jintArray properties = (*env)->NewIntArray(env, 4);
-    if (properties == NULL) {
-        NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", 4);
-    }
-    
-    // move from the temp structure to the java structure
-    (*env)->SetIntArrayRegion(env, properties, 0, 4, prop);
-    
-    return properties;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    getScreenModeRates0
- * Signature: (JII)[I
- */
-JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_x11_X11Screen_getScreenModeRates0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx, jint resMode_idx)
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    Window root = RootWindow(dpy, (int)scrn_idx);
-    
-    if(False == NewtScreen_hasRANDR(dpy)) {
-        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getScreenModeRates0: RANDR not available\n");
-        return (*env)->NewIntArray(env, 0);
-    }
-
-    int num_sizes;   
-    XRRScreenSize *xrrs = XRRSizes(dpy, (int)scrn_idx, &num_sizes); //get possible screen resolutions
-
-    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
-        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
-    }
- 
-    int num_rates;
-    short *rates = XRRRates(dpy, (int)scrn_idx, (int)resMode_idx, &num_rates);
- 
-    jint prop[num_rates];
-    int i;
-    for(i=0; i<num_rates; i++) {
-        prop[i] = (int) rates[i];
-        /** fprintf(stderr, "rate[%d, %d, %d/%d]: %d\n", (int)scrn_idx, resMode_idx, i, num_rates, prop[i]); */
-    }
-    
-    jintArray properties = (*env)->NewIntArray(env, num_rates);
-    if (properties == NULL) {
-        NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", num_rates);
-    }
-    
-    // move from the temp structure to the java structure
-    (*env)->SetIntArrayRegion(env, properties, 0, num_rates, prop);
-    
-    return properties;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    getCurrentScreenRate0
- * Signature: (JI)I
- */
-JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRate0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx) 
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    Window root = RootWindow(dpy, (int)scrn_idx);
-    
-    if(False == NewtScreen_hasRANDR(dpy)) {
-        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRate0: RANDR not available\n");
-        return -1;
-    }
-
-    // get current resolutions and frequencies
-    XRRScreenConfiguration  *conf = XRRGetScreenInfo(dpy, root);
-    short original_rate = XRRConfigCurrentRate(conf);
-
-    //free
-    XRRFreeScreenConfigInfo(conf);
-    
-    DBG_PRINT("getCurrentScreenRate0: %d\n", (int)original_rate);
-
-    return (jint) original_rate;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    getCurrentScreenRotation0
- * Signature: (JI)I
- */
-JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRotation0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    Window root = RootWindow(dpy, (int)scrn_idx);
-    
-    if(False == NewtScreen_hasRANDR(dpy)) {
-        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenRotation0: RANDR not available\n");
-        return -1;
-    }
-
-    //get current resolutions and frequencies
-    XRRScreenConfiguration  *conf = XRRGetScreenInfo(dpy, root);
-    
-    Rotation rotation;
-    XRRConfigCurrentConfiguration(conf, &rotation);
-
-    //free
-    XRRFreeScreenConfigInfo(conf);
-    
-    return NewtScreen_XRotation2Degree(env, rotation);
-}
-
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    getCurrentScreenResolutionIndex0
- * Signature: (JI)I
- */
-JNIEXPORT jint JNICALL Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenResolutionIndex0
-  (JNIEnv *env, jclass clazz, jlong display, jint scrn_idx)
-{
-   Display *dpy = (Display *) (intptr_t) display;
-   Window root = RootWindow(dpy, (int)scrn_idx);
-  
-   if(False == NewtScreen_hasRANDR(dpy)) {
-       DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_getCurrentScreenResolutionIndex0: RANDR not available\n");
-       return -1;
-   }
-
-   // get current resolutions and frequency configuration
-   XRRScreenConfiguration  *conf = XRRGetScreenInfo(dpy, root);
-   short original_rate = XRRConfigCurrentRate(conf);
-   
-   Rotation original_rotation;
-   SizeID original_size_id = XRRConfigCurrentConfiguration(conf, &original_rotation);
-   
-   //free
-   XRRFreeScreenConfigInfo(conf);
-   
-   DBG_PRINT("getCurrentScreenResolutionIndex0: %d\n", (int)original_size_id);
-   return (jint)original_size_id;   
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    setCurrentScreenModeStart0
- * Signature: (JIIII)Z
- */
-JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModeStart0
-  (JNIEnv *env, jclass clazz, jlong display, jint screen_idx, jint resMode_idx, jint freq, jint rotation)
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    Window root = RootWindow(dpy, (int)screen_idx);
-
-    if(False == NewtScreen_hasRANDR(dpy)) {
-        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModeStart0: RANDR not available\n");
-        return JNI_FALSE;
-    }
-
-    int num_sizes;   
-    XRRScreenSize *xrrs = XRRSizes(dpy, (int)screen_idx, &num_sizes); //get possible screen resolutions
-    XRRScreenConfiguration *conf;
-    int rot;
-    
-    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
-        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
-    }
-
-    conf = XRRGetScreenInfo(dpy, root);
-   
-    switch(rotation) {
-        case   0:
-            rot = RR_Rotate_0; 
-            break;
-        case  90:
-            rot = RR_Rotate_90; 
-            break;
-        case 180:
-            rot = RR_Rotate_180; 
-            break;
-        case 270:
-            rot = RR_Rotate_270; 
-            break;
-        default:
-            NewtCommon_throwNewRuntimeException(env, "Invalid rotation: %d", rotation);
-    }
-    
-    DBG_PRINT("X11Screen.setCurrentScreenMode0: CHANGED TO %d: %d x %d PIXELS, %d Hz, %d degree\n", 
-        resMode_idx, xrrs[resMode_idx].width, xrrs[resMode_idx].height, (int)freq, rotation);
-
-    XRRSelectInput (dpy, root, RRScreenChangeNotifyMask);
-
-    XSync(dpy, False);
-    XRRSetScreenConfigAndRate(dpy, conf, root, (int)resMode_idx, rot, (short)freq, CurrentTime);   
-    XSync(dpy, False);
-
-    //free
-    XRRFreeScreenConfigInfo(conf);
-    XSync(dpy, False);
-
-    return JNI_TRUE;
-}
-
-/*
- * Class:     jogamp_newt_driver_x11_X11Screen
- * Method:    setCurrentScreenModePollEnd0
- * Signature: (J)Z
- */
-JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModePollEnd0
-  (JNIEnv *env, jclass clazz, jlong display, jint screen_idx, jint resMode_idx, jint freq, jint rotation)
-{
-    Display *dpy = (Display *) (intptr_t) display;
-    int randr_event_base, randr_error_base;
-    XEvent evt;
-    XRRScreenChangeNotifyEvent * scn_event = (XRRScreenChangeNotifyEvent *) &evt;
-
-    if(False == NewtScreen_hasRANDR(dpy)) {
-        DBG_PRINT("Java_jogamp_newt_driver_x11_X11Screen_setCurrentScreenModePollEnd0: RANDR not available\n");
-        return JNI_FALSE;
-    }
-
-    int num_sizes;   
-    XRRScreenSize *xrrs = XRRSizes(dpy, (int)screen_idx, &num_sizes); //get possible screen resolutions
-    XRRScreenConfiguration *conf;
-    
-    if( 0 > resMode_idx || resMode_idx >= num_sizes ) {
-        NewtCommon_throwNewRuntimeException(env, "Invalid resolution index: ! 0 < %d < %d", resMode_idx, num_sizes);
-    }
-
-    XRRQueryExtension(dpy, &randr_event_base, &randr_error_base);
-
-    int done = 0;
-    int rot;
-    do {
-        if ( 0 >= XEventsQueued(dpy, QueuedAfterFlush) ) {
-            return;
-        }
-        XNextEvent(dpy, &evt);
-
-        switch (evt.type - randr_event_base) {
-            case RRScreenChangeNotify:
-                rot = NewtScreen_XRotation2Degree(env, (int)scn_event->rotation);
-                DBG_PRINT( "XRANDR: event . RRScreenChangeNotify call %p (root %p) resIdx %d rot %d %dx%d\n", 
-                            (void*)scn_event->window, (void*)scn_event->root, 
-                            (int)scn_event->size_index, rot, 
-                            scn_event->width, scn_event->height);
-                // done = scn_event->size_index == resMode_idx; // not reliable ..
-                done = rot == rotation && 
-                       scn_event->width == xrrs[resMode_idx].width && 
-                       scn_event->height == xrrs[resMode_idx].height;
-                break;
-            default:
-                DBG_PRINT("RANDR: event . unhandled %d 0x%X call %p\n", (int)evt.type, (int)evt.type, (void*)evt.xany.window);
-        }
-        XRRUpdateConfiguration(&evt);
-    } while(!done);
-
-    XSync(dpy, False);
-
-}
-
 /**
  * Window
  */
@@ -1523,35 +442,6 @@ JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Screen_setCurrentScree
 JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_x11_X11Window_initIDs0
   (JNIEnv *env, jclass clazz)
 {
-    insetsChangedID = (*env)->GetMethodID(env, clazz, "insetsChanged", "(ZIIII)V");
-    sizeChangedID = (*env)->GetMethodID(env, clazz, "sizeChanged", "(ZIIZ)V");
-    positionChangedID = (*env)->GetMethodID(env, clazz, "positionChanged", "(ZII)V");
-    focusChangedID = (*env)->GetMethodID(env, clazz, "focusChanged", "(ZZ)V");
-    visibleChangedID = (*env)->GetMethodID(env, clazz, "visibleChanged", "(ZZ)V");
-    reparentNotifyID = (*env)->GetMethodID(env, clazz, "reparentNotify", "(J)V");
-    windowDestroyNotifyID = (*env)->GetMethodID(env, clazz, "windowDestroyNotify", "()V");
-    windowRepaintID = (*env)->GetMethodID(env, clazz, "windowRepaint", "(ZIIII)V");
-    enqueueMouseEventID = (*env)->GetMethodID(env, clazz, "enqueueMouseEvent", "(ZIIIIII)V");
-    sendMouseEventID = (*env)->GetMethodID(env, clazz, "sendMouseEvent", "(IIIIII)V");
-    enqueueKeyEventID = (*env)->GetMethodID(env, clazz, "enqueueKeyEvent", "(ZIIIC)V");
-    sendKeyEventID = (*env)->GetMethodID(env, clazz, "sendKeyEvent", "(IIIC)V");
-    requestFocusID = (*env)->GetMethodID(env, clazz, "requestFocus", "(Z)V");
-
-    if (insetsChangedID == NULL ||
-        sizeChangedID == NULL ||
-        positionChangedID == NULL ||
-        focusChangedID == NULL ||
-        visibleChangedID == NULL ||
-        reparentNotifyID == NULL ||
-        windowDestroyNotifyID == NULL ||
-        windowRepaintID == NULL ||
-        enqueueMouseEventID == NULL ||
-        sendMouseEventID == NULL ||
-        enqueueKeyEventID == NULL ||
-        sendKeyEventID == NULL ||
-        requestFocusID == NULL) {
-        return JNI_FALSE;
-    }
     return JNI_TRUE;
 }
 
@@ -1587,13 +477,12 @@ static void NewtWindows_setPosSize(Display *dpy, Window w, jint x, jint y, jint
 /*
  * Class:     jogamp_newt_driver_x11_X11Window
  * Method:    CreateWindow
- * Signature: (JJIJIIII)J
  */
 JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
   (JNIEnv *env, jobject obj, jlong parent, jlong display, jint screen_index, 
                              jlong visualID, 
                              jlong javaObjectAtom, jlong windowDeleteAtom, 
-                             jint x, jint y, jint width, jint height, int flags)
+                             jint x, jint y, jint width, jint height, jboolean autoPosition, int flags)
 {
     Display * dpy = (Display *)(intptr_t)display;
     Atom wm_delete_atom = (Atom)windowDeleteAtom;
@@ -1629,9 +518,9 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
     if(0==windowParent) {
         windowParent = root;
     }
-    DBG_PRINT( "X11: CreateWindow dpy %p, parent %p, %x/%d %dx%d, undeco %d, alwaysOnTop %d\n", 
+    DBG_PRINT( "X11: CreateWindow dpy %p, parent %p, %d/%d %dx%d, undeco %d, alwaysOnTop %d, autoPosition %d\n", 
         (void*)dpy, (void*)windowParent, x, y, width, height,
-        TST_FLAG_IS_UNDECORATED(flags), TST_FLAG_IS_ALWAYSONTOP(flags));
+        TST_FLAG_IS_UNDECORATED(flags), TST_FLAG_IS_ALWAYSONTOP(flags), autoPosition);
 
     // try given VisualID on screen
     memset(&visualTemplate, 0, sizeof(XVisualInfo));
@@ -1681,7 +570,7 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
 
     {
         int _x = x, _y = y; // pos for CreateWindow, might be tweaked
-        if(0>_x || 0>_y) {
+        if(JNI_TRUE == autoPosition) {
             // user didn't requested specific position, use WM default
             _x = 0;
             _y = 0;
@@ -1715,7 +604,6 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
     {
         XEvent event;
         int left, right, top, bottom;
-        Bool userPos = 0<=x && 0<=y ;
 
         XMapWindow(dpy, window);
         XIfEvent( dpy, &event, WaitForMapNotify, (XPointer) window ); // wait to get proper insets values
@@ -1724,19 +612,17 @@ JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_x11_X11Window_CreateWindow0
         NewtWindows_updateInsets(env, jwindow, dpy, window, &left, &right, &top, &bottom);
         (*env)->CallVoidMethod(env, jwindow, visibleChangedID, JNI_FALSE, JNI_TRUE);
 
-        if(!userPos) {
+        if(JNI_TRUE == autoPosition) {
             // get position from WM
             int dest_x, dest_y;
             Window child;
             XTranslateCoordinates(dpy, window, windowParent, 0, 0, &dest_x, &dest_y, &child);
             x = (int)dest_x; y = (int)dest_y;
         }
-        DBG_PRINT("X11: [CreateWindow]: client: %d/%d %dx%d (is user-pos %d)\n", x, y, width, height, userPos);
+        DBG_PRINT("X11: [CreateWindow]: client: %d/%d %dx%d (autoPosition %d)\n", x, y, width, height, autoPosition);
 
         x -= left; // top-level
         y -= top;  // top-level
-        if(0>x) { x = 0; }
-        if(0>y) { y = 0; }
         DBG_PRINT("X11: [CreateWindow]: top-level: %d/%d\n", x, y);
         NewtWindows_setPosSize(dpy, window, x, y, width, height);
 
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java
index e57b26f76..faa7eb311 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/newt/TestGearsES2NEWT.java
@@ -32,8 +32,13 @@ import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 
+import com.jogamp.newt.Display;
+import com.jogamp.newt.NewtFactory;
+import com.jogamp.newt.Screen;
 import com.jogamp.newt.event.KeyAdapter;
 import com.jogamp.newt.event.KeyEvent;
+import com.jogamp.newt.event.WindowEvent;
+import com.jogamp.newt.event.WindowAdapter;
 import com.jogamp.newt.opengl.GLWindow;
 import com.jogamp.opengl.test.junit.util.UITestCase;
 import com.jogamp.opengl.test.junit.util.QuitAdapter;
@@ -42,6 +47,11 @@ import com.jogamp.opengl.util.Animator;
 
 import com.jogamp.opengl.test.junit.jogl.demos.es2.GearsES2;
 
+import javax.media.nativewindow.util.Dimension;
+import javax.media.nativewindow.util.Point;
+import javax.media.nativewindow.util.PointImmutable;
+import javax.media.nativewindow.util.DimensionImmutable;
+
 import javax.media.opengl.GLAnimatorControl;
 import javax.media.opengl.GLAutoDrawable;
 import javax.media.opengl.GLCapabilities;
@@ -55,8 +65,23 @@ import org.junit.Test;
 
 public class TestGearsES2NEWT extends UITestCase {
     static GLProfile glp;
-    static int width, height;
+    
+    static int screenIdx = 0;
+    static PointImmutable wpos;
+    static DimensionImmutable wsize;
 
+    static long duration = 500; // ms
+    static boolean opaque = true;
+    static boolean undecorated = false;
+    static boolean alwaysOnTop = false;
+    static boolean fullscreen = false;
+    static boolean pmvUseBackingArray = true;
+    static boolean vsync = false;
+    static boolean waitForKey = false;
+    static boolean mouseVisible = true;
+    static boolean mouseConfined = false;
+    static boolean showFPS = false;
+    
     @BeforeClass
     public static void initClass() {
         /*if(GLProfile.isAvailable(GLProfile.getDefaultEGLDevice(), GLProfile.GLES2)) {
@@ -67,10 +92,9 @@ public class TestGearsES2NEWT extends UITestCase {
             glp = GLProfile.getGL2ES2(); 
         }
         Assert.assertNotNull(glp);
-        // width  = 512;
-        // height = 512;
-        width  = 200;
-        height = 200;
+        if(null == wsize) {
+            wsize = new Dimension(200, 200);
+        }
     }
 
     @AfterClass
@@ -79,11 +103,15 @@ public class TestGearsES2NEWT extends UITestCase {
 
     protected void runTestGL(GLCapabilities caps, boolean undecorated) throws InterruptedException {
         System.err.println("requested: "+caps);
-        final GLWindow glWindow = GLWindow.create(caps);
+        Display dpy = NewtFactory.createDisplay(null);
+        Screen screen = NewtFactory.createScreen(dpy, screenIdx);
+        final GLWindow glWindow = GLWindow.create(screen, caps);
         Assert.assertNotNull(glWindow);
-        glWindow.setTitle("Gears NEWT Test (translucent "+!caps.isBackgroundOpaque()+")");
-        glWindow.setSize(width, height);
-        glWindow.setPosition(100, 100);
+        glWindow.setTitle("Gears NEWT Test (translucent "+!caps.isBackgroundOpaque()+"), size "+wsize+", pos "+wpos);
+        glWindow.setSize(wsize.getWidth(), wsize.getHeight());
+        if(null != wpos) {
+            glWindow.setPosition(wpos.getX(), wpos.getY());
+        }
         glWindow.setUndecorated(undecorated);
         glWindow.setAlwaysOnTop(alwaysOnTop);
         glWindow.setFullscreen(fullscreen);
@@ -122,6 +150,15 @@ public class TestGearsES2NEWT extends UITestCase {
         glWindow.addKeyListener(quitAdapter);
         glWindow.addWindowListener(quitAdapter);
 
+        glWindow.addWindowListener(new WindowAdapter() {
+            public void windowResized(WindowEvent e) {
+                System.err.println("window resized: "+glWindow.getX()+"/"+glWindow.getY()+" "+glWindow.getWidth()+"x"+glWindow.getHeight());
+            }
+            public void windowMoved(WindowEvent e) {
+                System.err.println("window moved:   "+glWindow.getX()+"/"+glWindow.getY()+" "+glWindow.getWidth()+"x"+glWindow.getHeight());
+            }            
+        });
+        
         glWindow.addKeyListener(new KeyAdapter() {
             public void keyTyped(KeyEvent e) {
                 if(e.getKeyChar()=='f') {
@@ -188,14 +225,14 @@ public class TestGearsES2NEWT extends UITestCase {
             }
         });
 
-        animator.setUpdateFPSFrames(60, System.err);
+        animator.setUpdateFPSFrames(60, showFPS ? System.err : null);
         animator.start();
         // glWindow.setSkipContextReleaseThread(animator.getThread());
 
         glWindow.setVisible(true);
         
-        System.err.println("size/pos: "+glWindow.getX()+"/"+glWindow.getY()+" "+glWindow.getWidth()+"x"+glWindow.getHeight()+", "+glWindow.getInsets());
         System.err.println("chosen: "+glWindow.getChosenCapabilities());
+        System.err.println("window pos/siz: "+glWindow.getX()+"/"+glWindow.getY()+" "+glWindow.getWidth()+"x"+glWindow.getHeight()+", "+glWindow.getInsets());
         
         while(!quitAdapter.shouldQuit() && animator.isAnimating() && animator.getTotalFPSDuration()<duration) {
             Thread.sleep(100);
@@ -212,25 +249,22 @@ public class TestGearsES2NEWT extends UITestCase {
         runTestGL(caps, undecorated);
     }
 
-    static long duration = 500; // ms
-    static boolean opaque = true;
-    static boolean undecorated = false;
-    static boolean alwaysOnTop = false;
-    static boolean fullscreen = false;
-    static boolean pmvUseBackingArray = true;
-    static boolean vsync = false;
-    static boolean waitForKey = false;
-    static boolean mouseVisible = true;
-    static boolean mouseConfined = false;
-
+    static int atoi(String a) {
+        try {
+            return Integer.parseInt(a);
+        } catch (Exception ex) { throw new RuntimeException(ex); }
+    }
+    
     public static void main(String args[]) throws IOException {
         
+        int x=0, y=0, w=200, h=200;
+        boolean useSize = false;
+        boolean usePos = false;
+        
         for(int i=0; i<args.length; i++) {
             if(args[i].equals("-time")) {
                 i++;
-                try {
-                    duration = Integer.parseInt(args[i]);
-                } catch (Exception ex) { ex.printStackTrace(); }
+                duration = atoi(args[i]);
             } else if(args[i].equals("-translucent")) {
                 opaque = false;
             } else if(args[i].equals("-undecorated")) {
@@ -249,8 +283,38 @@ public class TestGearsES2NEWT extends UITestCase {
                 mouseVisible = false;
             } else if(args[i].equals("-mouseConfine")) {
                 mouseConfined = true;
+            } else if(args[i].equals("-showFPS")) {
+                showFPS = true;
+            } else if(args[i].equals("-width")) {
+                i++;
+                w = atoi(args[i]);
+                useSize = true;
+            } else if(args[i].equals("-height")) {
+                i++;
+                h = atoi(args[i]);
+                useSize = true;
+            } else if(args[i].equals("-x")) {
+                i++;
+                x = atoi(args[i]);
+                usePos = true;
+            } else if(args[i].equals("-y")) {
+                i++;
+                y = atoi(args[i]);
+                usePos = true;
+            } else if(args[i].equals("-screen")) {
+                i++;
+                screenIdx = atoi(args[i]);
             }
         }
+        if(useSize) {
+            wsize = new Dimension(w, h);
+        }
+        if(usePos) {
+            wpos = new Point(x, y);
+        }
+        System.err.println("position "+wpos);
+        System.err.println("size "+wsize);
+        System.err.println("screen "+screenIdx);
         System.err.println("translucent "+(!opaque));
         System.err.println("undecorated "+undecorated);
         System.err.println("atop "+alwaysOnTop);
diff --git a/src/test/com/jogamp/opengl/test/junit/newt/TestScreenMode00NEWT.java b/src/test/com/jogamp/opengl/test/junit/newt/TestScreenMode00NEWT.java
index 985affa92..7bd421234 100644
--- a/src/test/com/jogamp/opengl/test/junit/newt/TestScreenMode00NEWT.java
+++ b/src/test/com/jogamp/opengl/test/junit/newt/TestScreenMode00NEWT.java
@@ -35,10 +35,12 @@ import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
+import com.jogamp.newt.Display;
 import com.jogamp.newt.NewtFactory;
 import com.jogamp.newt.Screen;
 import com.jogamp.newt.Window;
 import com.jogamp.newt.ScreenMode;
+import com.jogamp.newt.opengl.GLWindow;
 import com.jogamp.newt.util.MonitorMode;
 import com.jogamp.newt.util.ScreenModeUtil;
 import com.jogamp.opengl.test.junit.util.UITestCase;
@@ -50,6 +52,7 @@ import javax.media.nativewindow.util.DimensionImmutable;
 import javax.media.nativewindow.util.SurfaceSize;
 
 public class TestScreenMode00NEWT extends UITestCase {
+    static int screenIdx = 0;
     static int width, height;
     
     static int waitTimeShort = 4; //1 sec
@@ -64,7 +67,7 @@ public class TestScreenMode00NEWT extends UITestCase {
         height = 480;
     }
 
-    @Test
+    // @Test
     public void testScreenModeInfo00() throws InterruptedException {
         DimensionImmutable res = new Dimension(640, 480);
         SurfaceSize surfsz = new SurfaceSize(res, 32);
@@ -95,12 +98,12 @@ public class TestScreenMode00NEWT extends UITestCase {
 
     @Test
     public void testScreenModeInfo01() throws InterruptedException {
-        Capabilities caps = new Capabilities();
-        Window window = NewtFactory.createWindow(caps);
-        window.setSize(width, height);
-        window.setVisible(true);
-
-        Screen screen = window.getScreen();
+        Display dpy = NewtFactory.createDisplay(null);
+        Screen screen = NewtFactory.createScreen(dpy, screenIdx);
+        screen.addReference();
+        Assert.assertEquals(true,screen.isNativeValid());
+        Assert.assertEquals(true,screen.getDisplay().isNativeValid());
+        System.err.println("Screen: "+screen.toString());
 
         List<ScreenMode> screenModes = screen.getScreenModes();
         Assert.assertTrue(screenModes.size()>0);
@@ -119,15 +122,25 @@ public class TestScreenMode00NEWT extends UITestCase {
         Assert.assertEquals(sm_c.getRotatedWidth(), screen.getWidth());
         Assert.assertEquals(sm_c.getRotatedHeight(), screen.getHeight());
 
-        window.destroy();
+        screen.removeReference();
 
-        Assert.assertEquals(false,window.isVisible());
-        Assert.assertEquals(false,window.isNativeValid());
         Assert.assertEquals(false,screen.isNativeValid());
         Assert.assertEquals(false,screen.getDisplay().isNativeValid());
     }
 
+    static int atoi(String a) {
+        try {
+            return Integer.parseInt(a);
+        } catch (Exception ex) { throw new RuntimeException(ex); }
+    }
+    
     public static void main(String args[]) throws IOException {
+        for(int i=0; i<args.length; i++) {
+            if(args[i].equals("-screen")) {
+                i++;
+                screenIdx = atoi(args[i]);
+            }
+        }
         String tstname = TestScreenMode00NEWT.class.getName();
         org.junit.runner.JUnitCore.main(tstname);
     }