Changed NEWT NativeWindow creation contract - AWT/NEWT Parenting - Misc Fixes

+++++

Changed NEWT NativeWindow creation contract

Original contract:

(1) A native window was created as soon as possible,
    ie when NEWTFactory.createWindow(..) was called - if possible.

(2) A valid native window has to be created at least after setVisible(true)
    has been called.

Problems:
    Not all implementation are able to create the native window that early,
    but at setVisible(true) only (e.g: KD and EGL).

    Due to window parenting especially the new AWT/NEWT parenting,
    the native window can only be created in case the parent native window is valid.

New contract:

(1) A native window is created at setVisible(true),
    if it's a top level window or the native parent window is valid.

(2) A valid native window may not be created after setVisible(true)
    has been called.
    Subsequent setVisible(true) calls shall be made in case
    the creation has not been done yet.
    This is demonstrated in GLWindow.display() for example.

The new contract implements a lazy native window creation.

+++++

AWT/NEWT Parenting

- HierarchyListener and ComponentListener ensure that the NEWT child window
  will be setVisible according to the AWT parent window.

- Lazy native window creation relaxes requirements to the parent window's state.

- Attachment of the child window and setVisible() may be called
  after NEWT child window creation.

- GLWindow supports NEWT child window creation directly

The test case TestParenting01AWT.java reflect this new contract
and demonstrates more simplified and more flexible use cases.

+++++

NEWT Fixes:

- All NEWT implementation's native code method names end with 0.

- GLWindow: don't issue the actual 'init'/'display' call to GLEventListeners
  in case the window is not visible.

- NEWT setSize/setPosition:
    if native-window
        call native-window action and let the attributes being set by
        the feedback call, which issues more action, ie RESIZE.
    else
        set the attributes directly, no feedback call/action is necessary.

+++++

X11 Fixes:

- X11GLContext MakeContextCurrent:
  Use MakeCurrent in case write and read drawable are equal,
  otherwise SEGV happens on ATI with heavy multithreading involved!
  Even XLockDisplay and XSync didn't help here ..

- X11GLXDrawableFactory shared resource:
  Removed the resource holder thread to simplify code,
  hence proper release is no more desired and it could become a cause for deadlock.

- Moved XInitThreads() from NEWT X11Window -> NativeWindow X11Util,
  since NativeWindow is loaded first (essential for XInitThreads())
  and it is the more basic lib.

- Made call to XInitThreads() conditional, ie it's spared if
  AWT could be used - which causes SEGV .. (AWT bug). See X11Util.java

+++++

JOGL Fixes:

- GLProfile.isAWTAvailable() -> NativeWindowFactory.isAWTAvailable()
- GLProfile.isAWTJOGLAvailable() -> GLProfile.isAWTAvailable()

28 files changed, 621 insertions, 463 deletions

diff --git a/src/newt/classes/com/jogamp/newt/Display.java b/src/newt/classes/com/jogamp/newt/Display.java
index abd03d13d..6705db970 100755
--- a/src/newt/classes/com/jogamp/newt/Display.java
+++ b/src/newt/classes/com/jogamp/newt/Display.java
@@ -125,8 +125,11 @@ public abstract class Display {
     }
 
     /** Make sure to reuse a Display with the same name */
-    protected static Display create(String type, String name) {
+    protected static Display create(String type, String name, final long handle) {
         try {
+            if(null==name && 0!=handle) {
+                name="wrapping-0x"+Long.toHexString(handle); // may change within implementation ..
+            }
             if(DEBUG) {
                 dumpDisplayMap("Display.create("+getFQName(type, name)+") BEGIN");
             }
@@ -152,11 +155,11 @@ public abstract class Display {
                     display.edt = display.edtUtil.start();
                     display.edtUtil.invokeAndWait(new Runnable() {
                         public void run() {
-                            f_dpy.createNative();
+                            f_dpy.createNative(handle);
                         }
                     } );
                 } else {
-                    display.createNative();
+                    display.createNative(handle);
                 }
                 if(null==display.aDevice) {
                     throw new RuntimeException("Display.createNative() failed to instanciate an AbstractGraphicsDevice");
@@ -182,19 +185,6 @@ public abstract class Display {
         }
     }
 
-    protected static Display wrapHandle(String type, String name, AbstractGraphicsDevice aDevice) {
-        try {
-            Class displayClass = getDisplayClass(type);
-            Display display = (Display) displayClass.newInstance();
-            display.name=name;
-            display.type=type;
-            display.aDevice=aDevice;
-            return display;
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     public EDTUtil getEDTUtil() { return edtUtil; }
 
     public synchronized void destroy() {
@@ -234,7 +224,7 @@ public abstract class Display {
         }
     }
 
-    protected abstract void createNative();
+    protected abstract void createNative(long handle);
     protected abstract void closeNative();
 
     public final String getType() {
diff --git a/src/newt/classes/com/jogamp/newt/NewtFactory.java b/src/newt/classes/com/jogamp/newt/NewtFactory.java
index 183acb3df..7860197ef 100755
--- a/src/newt/classes/com/jogamp/newt/NewtFactory.java
+++ b/src/newt/classes/com/jogamp/newt/NewtFactory.java
@@ -78,14 +78,14 @@ public abstract class NewtFactory {
      * Create a Display entity, incl native creation
      */
     public static Display createDisplay(String name) {
-      return Display.create(NativeWindowFactory.getNativeWindowType(true), name);
+      return Display.create(NativeWindowFactory.getNativeWindowType(true), name, 0);
     }
 
     /**
      * Create a Display entity using the given implementation type, incl native creation
      */
     public static Display createDisplay(String type, String name) {
-      return Display.create(type, name);
+      return Display.create(type, name, 0);
     }
 
     /**
@@ -106,77 +106,99 @@ public abstract class NewtFactory {
      * Create a top level Window entity, incl native creation
      */
     public static Window createWindow(Screen screen, Capabilities caps) {
-        return Window.create(NativeWindowFactory.getNativeWindowType(true), 0, screen, caps, false);
+        return Window.create(NativeWindowFactory.getNativeWindowType(true), null, 0, screen, caps, false);
     }
 
     /**
      * Create a top level Window entity, incl native creation
      */
     public static Window createWindow(Screen screen, Capabilities caps, boolean undecorated) {
-        return Window.create(NativeWindowFactory.getNativeWindowType(true), 0, screen, caps, undecorated);
+        return Window.create(NativeWindowFactory.getNativeWindowType(true), null, 0, screen, caps, undecorated);
     }
 
     /**
-     * Create a child Window entity attached to the given parent, incl native creation<br>
+     * Create a child Window entity attached to the given parent, incl native creation.<br>
+     * The Screen and Display information is regenrated utilizing the parents information.<br>
      * <p>
      * In case <code>parentWindowObject</code> is a {@link javax.media.nativewindow.NativeWindow},<br>
      * we create a child {@link com.jogamp.newt.Window},
-     * utilizing {@link com.jogamp.newt.NewtFactory#createWindow(long, com.jogamp.newt.Screen, javax.media.nativewindow.Capabilities, boolean)}
-     * passing the parent's native window handle retrieved via {@link javax.media.nativewindow.NativeWindow#getWindowHandle()}.<br></p>
+     * utilizing {@link com.jogamp.newt.NewtFactory#createWindowImpl(java.lang.String, javax.media.nativewindow.NativeWindow, com.jogamp.newt.Screen, javax.media.nativewindow.Capabilities, boolean)}<br></p>.
      * <p>
      * In case <code>parentWindowObject</code> is even a {@link com.jogamp.newt.Window}, the following applies:<br>
      * {@link com.jogamp.newt.event.WindowEvent#EVENT_WINDOW_RESIZED} is not propagated to the child window for e.g. layout<br>,
      * you have to add an appropriate {@link com.jogamp.newt.event.WindowListener} for this use case.<br>
      * However, {@link com.jogamp.newt.event.WindowEvent#EVENT_WINDOW_DESTROY_NOTIFY} is propagated to the child window, so it will be closed properly.<br>
-     * In case <code>parentWindowObject</code> is a different {@javax.media.nativewindow.NativeWindow} implementation,<br>
+     * The parents visibility is passed to the new Window<br></p>
+     * <p>
+     * In case <code>parentWindowObject</code> is a different {@link javax.media.nativewindow.NativeWindow} implementation,<br>
      * you have to handle all events appropriatly.<br></p>
      * <p>
      * In case <code>parentWindowObject</code> is a {@link java.awt.Component},<br>
-     * we utilize the {@link com.jogamp.newt.impl.awt.AWTNewtFactory#createNativeChildWindow(Object, com.jogamp.newt.Screen, com.jogamp.newt.Capabilities, boolean)}
+     * we utilize the {@link com.jogamp.newt.impl.awt.AWTNewtFactory#createNativeChildWindow(Object, com.jogamp.newt.Capabilities, boolean)}
      * factory method.<br>
      * The factory adds a {@link com.jogamp.newt.event.WindowListener} to propagate {@link com.jogamp.newt.event.WindowEvent}'s so
-     * your NEWT Window integrates into the AWT layout.<br></p>
+     * your NEWT Window integrates into the AWT layout.<br>
+     * The parents visibility is passed to the new Window<br></p>
      *
      * @param parentWindowObject either a NativeWindow or java.awt.Component 
      * @param undecorated only impacts if the window is in top-level state, while attached to a parent window it's rendered undecorated always
      *
      * @see com.jogamp.newt.NewtFactory#createWindow(long, com.jogamp.newt.Screen, javax.media.nativewindow.Capabilities, boolean)
-     * @see com.jogamp.newt.impl.awt.AWTNewtFactory#createNativeChildWindow(java.lang.Object, com.jogamp.newt.Screen, javax.media.nativewindow.Capabilities, boolean)
+     * @see com.jogamp.newt.impl.awt.AWTNewtFactory#createNativeChildWindow(java.lang.Object, javax.media.nativewindow.Capabilities, boolean)
      */
-    public static Window createWindow(Object parentWindowObject, Screen screen, Capabilities caps, boolean undecorated) {
+    public static Window createWindow(Object parentWindowObject, Capabilities caps, boolean undecorated) {
+        final String type = NativeWindowFactory.getNativeWindowType(true);
         if(null==parentWindowObject) {
-            throw new RuntimeException("Null parentWindowObject");
+            return createWindowImpl(type, null, null, caps, undecorated);
         }
         if(parentWindowObject instanceof NativeWindow) {
-            NativeWindow nativeParentWindow = (NativeWindow) parentWindowObject;
-            nativeParentWindow.lockSurface();
-            long parentWindowHandle = nativeParentWindow.getWindowHandle();
-            nativeParentWindow.unlockSurface();
-            final Window win = createWindow(parentWindowHandle, screen, caps, undecorated);
-            if ( nativeParentWindow instanceof Window) {
-                final Window f_nativeParentWindow = (Window) nativeParentWindow ;
-                f_nativeParentWindow.addWindowListener(new WindowAdapter() {
+            NativeWindow nParentWindow = (NativeWindow) parentWindowObject;
+
+            Display display=null;
+            Screen screen=null;
+            Window parentWindow=null;
+
+            if ( nParentWindow instanceof Window ) {
+                parentWindow = (Window) nParentWindow ;
+                Screen nParentScreen = parentWindow.getScreen();
+                Display nParentDisplay = nParentScreen.getDisplay();
+                display = NewtFactory.wrapDisplay(type, nParentDisplay.getHandle());
+                screen  = NewtFactory.createScreen(type, display, nParentScreen.getIndex());
+            } else {
+                AbstractGraphicsConfiguration nParentConfig = nParentWindow.getGraphicsConfiguration();
+                AbstractGraphicsScreen nParentScreen = nParentConfig.getScreen();
+                AbstractGraphicsDevice nParentDevice = nParentScreen.getDevice();
+                display = NewtFactory.wrapDisplay(type, nParentDevice.getHandle());
+                screen  = NewtFactory.createScreen(type, display, nParentScreen.getIndex());
+            }
+            final Window win = createWindowImpl(type, nParentWindow, screen, caps, undecorated);
+
+            win.setSize(nParentWindow.getWidth(), nParentWindow.getHeight());
+            if ( null != parentWindow ) {
+                parentWindow.addWindowListener(new WindowAdapter() {
                     public void windowDestroyNotify(WindowEvent e) {
                         win.sendEvent(e);
                     }
                 });
+                win.setVisible(parentWindow.isVisible());
             }
             return win;
         } else {
             if(ReflectionUtil.instanceOf(parentWindowObject, "java.awt.Component")) {
                 if(ReflectionUtil.isClassAvailable("com.jogamp.newt.impl.awt.AWTNewtFactory")) {
-                    return (Window) ReflectionUtil.callStaticMethod("com.jogamp.newt.impl.awt.AWTNewtFactory",
-                                                                    "createNativeChildWindow",
-                                                                    new Class[]  { Object.class, Screen.class, Capabilities.class, java.lang.Boolean.TYPE},
-                                                                    new Object[] { parentWindowObject, screen, caps, new Boolean(undecorated) } );
+                    return (Window) ReflectionUtil.callStaticMethod(
+                                            "com.jogamp.newt.impl.awt.AWTNewtFactory",
+                                            "createNativeChildWindow",
+                                            new Class[]  { Object.class, Capabilities.class, java.lang.Boolean.TYPE},
+                                            new Object[] { parentWindowObject, caps, new Boolean(undecorated) } );
                 }
             }
         }
         throw new RuntimeException("No NEWT child Window factory method for parent object: "+parentWindowObject);
     }
 
-    public static Window createWindow(Object parentWindowObject, Screen screen, Capabilities caps) {
-        return createWindow(parentWindowObject, screen, caps, false);
+    protected static Window createWindowImpl(String type, NativeWindow parentNativeWindow, Screen screen, Capabilities caps, boolean undecorated) {
+        return Window.create(type, parentNativeWindow, 0, screen, caps, undecorated);
     }
 
     /**
@@ -186,14 +208,7 @@ public abstract class NewtFactory {
      * @param undecorated only impacts if the window is in top-level state, while attached to a parent window it's rendered undecorated always
      */
     public static Window createWindow(long parentWindowHandle, Screen screen, Capabilities caps, boolean undecorated) {
-        if(0==parentWindowHandle) {
-            throw new RuntimeException("Null parentWindowHandle");
-        }
-        return Window.create(NativeWindowFactory.getNativeWindowType(true), parentWindowHandle, screen, caps, undecorated);
-    }
-
-    public static Window createWindow(long parentWindowHandle, Screen screen, Capabilities caps) {
-        return  createWindow(parentWindowHandle, screen, caps, false);
+        return Window.create(NativeWindowFactory.getNativeWindowType(true), null, parentWindowHandle, screen, caps, undecorated);
     }
 
     /**
@@ -213,7 +228,7 @@ public abstract class NewtFactory {
      * @param undecorated only impacts if the window is in top-level state, while attached to a parent window it's rendered undecorated always
      */
     public static Window createWindow(String type, Screen screen, Capabilities caps, boolean undecorated) {
-        return Window.create(type, 0, screen, caps, undecorated);
+        return Window.create(type, null, 0, screen, caps, undecorated);
     }
 
     public static Window createWindow(String type, Object[] cstrArguments, Screen screen, Capabilities caps, boolean undecorated) {
@@ -223,25 +238,8 @@ public abstract class NewtFactory {
     /**
      * Instantiate a Display entity using the native handle.
      */
-    public static Display wrapDisplay(String name, AbstractGraphicsDevice device) {
-      return Display.wrapHandle(NativeWindowFactory.getNativeWindowType(true), name, device);
-    }
-
-    /**
-     * Instantiate a Screen entity using the native handle.
-     */
-    public static Screen wrapScreen(Display display, AbstractGraphicsScreen screen) {
-      return Screen.wrapHandle(NativeWindowFactory.getNativeWindowType(true), display, screen);
-    }
-
-    /**
-     * Instantiate a Window entity using the native handle.
-     */
-    public static Window wrapWindow(Screen screen, AbstractGraphicsConfiguration config,
-                                    long windowHandle, boolean fullscreen, boolean visible, 
-                                    int x, int y, int width, int height) {
-      return Window.wrapHandle(NativeWindowFactory.getNativeWindowType(true), screen, config,
-                               windowHandle, fullscreen, visible, x, y, width, height);
+    public static Display wrapDisplay(String type, long handle) {
+      return Display.create(type, null, handle);
     }
 
     private static final boolean instanceOf(Object obj, String clazzName) {
diff --git a/src/newt/classes/com/jogamp/newt/OffscreenWindow.java b/src/newt/classes/com/jogamp/newt/OffscreenWindow.java
index c9c56fc61..5b957afa5 100644
--- a/src/newt/classes/com/jogamp/newt/OffscreenWindow.java
+++ b/src/newt/classes/com/jogamp/newt/OffscreenWindow.java
@@ -44,7 +44,7 @@ public class OffscreenWindow extends Window implements SurfaceChangeable {
 
     static long nextWindowHandle = 0x100; // start here - a marker
 
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
+    protected void createNativeImpl() {
         if(0!=parentWindowHandle) {
             throw new NativeWindowException("OffscreenWindow does not support window parenting");
         }
@@ -83,10 +83,7 @@ public class OffscreenWindow extends Window implements SurfaceChangeable {
         return surfaceHandle;
     }
 
-    public void setVisible(boolean visible) {
-        if(!visible) {
-            this.visible = visible;
-        }
+    protected void setVisibleImpl() {
     }
 
     public void setSize(int width, int height) {
diff --git a/src/newt/classes/com/jogamp/newt/Screen.java b/src/newt/classes/com/jogamp/newt/Screen.java
index 7bf520332..26342519e 100755
--- a/src/newt/classes/com/jogamp/newt/Screen.java
+++ b/src/newt/classes/com/jogamp/newt/Screen.java
@@ -67,7 +67,9 @@ public abstract class Screen {
             if(usrWidth<0 || usrHeight<0) {
                 usrWidth  = Debug.getIntProperty("newt.ws.swidth", true, localACC);
                 usrHeight = Debug.getIntProperty("newt.ws.sheight", true, localACC);
-                System.out.println("User screen size "+usrWidth+"x"+usrHeight);
+                if(usrWidth>0 || usrHeight>0) {
+                    System.out.println("User screen size "+usrWidth+"x"+usrHeight);
+                }
             }
             Class screenClass = getScreenClass(type);
             Screen screen  = (Screen) screenClass.newInstance();
@@ -88,18 +90,6 @@ public abstract class Screen {
         aScreen = null;
     }
 
-    protected static Screen wrapHandle(String type, Display display, AbstractGraphicsScreen aScreen) {
-        try {
-            Class screenClass = getScreenClass(type);
-            Screen screen  = (Screen) screenClass.newInstance();
-            screen.display = display;
-            screen.aScreen = aScreen;
-            return screen;
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     protected abstract void createNative(int index);
     protected abstract void closeNative();
 
diff --git a/src/newt/classes/com/jogamp/newt/Window.java b/src/newt/classes/com/jogamp/newt/Window.java
index 869ca2cf3..978b7f068 100755
--- a/src/newt/classes/com/jogamp/newt/Window.java
+++ b/src/newt/classes/com/jogamp/newt/Window.java
@@ -88,8 +88,12 @@ public abstract class Window implements NativeWindow
         return windowClass;
     }
 
-    protected static Window create(String type, final long parentWindowHandle, Screen screen, final Capabilities caps, boolean undecorated) {
+    protected static Window create(String type, NativeWindow parentNativeWindow, long parentWindowHandle, Screen screen, Capabilities caps, boolean undecorated) {
         try {
+            if(null==screen) {
+                Display display = NewtFactory.createDisplay(type, null); // local display
+                screen  = NewtFactory.createScreen(type, display, 0); // screen 0
+            }
             Class windowClass;
             if(caps.isOnscreen()) {
                 windowClass = getWindowClass(type);
@@ -98,22 +102,11 @@ public abstract class Window implements NativeWindow
             }
             Window window = (Window) windowClass.newInstance();
             window.invalidate();
-            window.screen   = screen;
+            window.parentNativeWindow = parentNativeWindow;
+            window.parentWindowHandle = parentWindowHandle;
+            window.screen = screen;
+            window.caps = (Capabilities)caps.clone();
             window.setUndecorated(undecorated||0!=parentWindowHandle);
-            EDTUtil edtUtil = screen.getDisplay().getEDTUtil();
-            if(null!=edtUtil) {
-                final Window f_win = window;
-                edtUtil.invokeAndWait(new Runnable() {
-                    public void run() {
-                        f_win.createNative(parentWindowHandle, caps);
-                    }
-                } );
-            } else {
-                window.createNative(parentWindowHandle, caps);
-            }
-            if(DEBUG_WINDOW_EVENT) {
-                System.out.println("Window.create-1() done ("+Thread.currentThread()+", "+window+")");
-            }
             return window;
         } catch (Throwable t) {
             t.printStackTrace();
@@ -121,7 +114,7 @@ public abstract class Window implements NativeWindow
         }
     }
 
-    protected static Window create(String type, Object[] cstrArguments, Screen screen, final Capabilities caps, boolean undecorated) {
+    protected static Window create(String type, Object[] cstrArguments, Screen screen, Capabilities caps, boolean undecorated) {
         try {
             Class windowClass = getWindowClass(type);
             Class[] cstrArgumentTypes = getCustomConstructorArgumentTypes(windowClass);
@@ -134,52 +127,15 @@ public abstract class Window implements NativeWindow
             }
             Window window = (Window) ReflectionUtil.createInstance( windowClass, cstrArgumentTypes, cstrArguments ) ;
             window.invalidate();
-            window.screen   = screen;
+            window.screen = screen;
+            window.caps = (Capabilities)caps.clone();
             window.setUndecorated(undecorated);
-            EDTUtil edtUtil = screen.getDisplay().getEDTUtil();
-            if(null!=edtUtil) {
-                final Window f_win = window;
-                edtUtil.invokeAndWait(new Runnable() {
-                    public void run() {
-                        f_win.createNative(0, caps);
-                    }
-                } );
-            } else {
-                window.createNative(0, caps);
-            }
-            if(DEBUG_WINDOW_EVENT) {
-                System.out.println("Window.create-2() done ("+Thread.currentThread()+", "+window+")");
-            }
             return window;
         } catch (Throwable t) {
             throw new NativeWindowException(t);
         }
     }
 
-    protected static Window wrapHandle(String type, Screen screen, AbstractGraphicsConfiguration config, 
-                                 long windowHandle, boolean fullscreen, boolean visible, 
-                                 int x, int y, int width, int height) 
-    {
-        try {
-            Class windowClass = getWindowClass(type);
-            Window window = (Window) windowClass.newInstance();
-            window.invalidate();
-            window.screen   = screen;
-            window.config = config;
-            window.windowHandle = windowHandle;
-            window.fullscreen=fullscreen;
-            window.visible=visible;
-            window.x=x;
-            window.y=y;
-            window.width=width;
-            window.height=height;
-            return window;
-        } catch (Throwable t) {
-            t.printStackTrace();
-            throw new NativeWindowException(t);
-        }
-    }
-
     public static String toHexString(int hex) {
         return "0x" + Integer.toHexString(hex);
     }
@@ -190,6 +146,10 @@ public abstract class Window implements NativeWindow
 
     protected Screen screen;
 
+    private NativeWindow parentNativeWindow;
+    protected long parentWindowHandle;
+
+    protected Capabilities caps;
     protected AbstractGraphicsConfiguration config;
     protected long   windowHandle;
     protected boolean fullscreen, visible;
@@ -199,16 +159,53 @@ public abstract class Window implements NativeWindow
     protected String title = "Newt Window";
     protected boolean undecorated = false;
 
+    private synchronized boolean createNative() {
+        if( null==screen || 0!=windowHandle || !visible ) {
+            // NOP .. or already done
+            return 0 != windowHandle ;
+        }
+        EDTUtil edtUtil = screen.getDisplay().getEDTUtil();
+        if( null != edtUtil && !edtUtil.isCurrentThreadEDT() ) {
+            throw new NativeWindowException("EDT enabled but not on EDT");
+        }
+
+        if(DEBUG_WINDOW_EVENT) {
+            System.out.println("Window.createNative() START ("+Thread.currentThread()+", "+this+")");
+        }
+        if(validateParentWindowHandle()) {
+            createNativeImpl();
+            setVisibleImpl();
+        }
+        if(DEBUG_WINDOW_EVENT) {
+            System.out.println("Window.createNative() END ("+Thread.currentThread()+", "+this+")");
+        }
+        return 0 != windowHandle ;
+    }
+
+    private boolean validateParentWindowHandle() {
+        boolean ok = true;
+        if(null!=parentNativeWindow) {
+            try {
+                parentNativeWindow.lockSurface();
+            } catch (NativeWindowException nwe) {
+                // parent native window not ready .. just skip action for now
+                ok = false;
+            }
+            if(ok) {
+                parentWindowHandle = parentNativeWindow.getWindowHandle();
+                parentNativeWindow.unlockSurface();
+                if(0==parentWindowHandle) {
+                    throw new NativeWindowException("Parent native window handle is NULL, after succesful locking: "+parentNativeWindow);
+                }
+            }
+        }
+        return ok;
+    }
+
     /**
      * Create native windowHandle, ie creates a new native invisible window.
-     *
-     * The parentWindowHandle may be null, in which case no window parenting 
-     * is requested.
-     *
-     * Shall use the capabilities to determine the graphics configuration
-     * and shall set the chosen capabilities.
      */
-    protected abstract void createNative(long parentWindowHandle, Capabilities caps);
+    protected abstract void createNativeImpl();
 
     protected abstract void closeNative();
 
@@ -371,18 +368,25 @@ public abstract class Window implements NativeWindow
             e.printStackTrace();
         }
         screen   = null;
+        parentNativeWindow = null;
+        parentWindowHandle = 0;
+        caps = null;
         windowHandle = 0;
         fullscreen=false;
         visible=false;
         eventMask = 0;
 
         // Default position and dimension will be re-set immediately by user
-        width  = 100;
-        height = 100;
+        width  = 128;
+        height = 128;
         x=0;
         y=0;
     }
 
+    public boolean isDestroyed() {
+        return null == screen ;
+    }
+
     public boolean surfaceSwap() { 
         return false;
     }
@@ -506,7 +510,62 @@ public abstract class Window implements NativeWindow
         }
     }
 
-    public abstract void    setVisible(boolean visible);
+    /**
+     * <p>
+     * <code>setVisible</code> makes the window visible if <code>visible</code> is true,
+     * otherwise the window becomes invisible.<br></p>
+     * <p>
+     * The <code>setVisible(true)</code> is responsible to actual create the native window.<br></p>
+     * <p>
+     * In case this window is a child window and a parent {@link javax.media.nativewindow.NativeWindow} is being used,<br>
+     * the parent's {@link javax.media.nativewindow.NativeWindow} handle is retrieved via {@link javax.media.nativewindow.NativeWindow#getWindowHandle()}.<br>
+     * If this action fails, ie if the parent {@link javax.media.nativewindow.NativeWindow} is not valid yet,<br>
+     * no native window is created yet and <code>setVisible(true)</code> shall be repeated when it is.<br></p>
+     */
+    public void setVisible(final boolean visible) {
+        setVisible(visible, false);
+    }
+
+    public void setVisible(final boolean visible, boolean deferred) {
+        if(!isDestroyed()) {
+            EDTUtil edtUtil = screen.getDisplay().getEDTUtil();
+            if(null!=edtUtil) {
+                edtUtil.invoke(deferred, new Runnable() {
+                    public void run() {
+                        setVisibleTask(visible);
+                    }
+                });
+            } else {
+                setVisibleTask(visible);
+            }
+        }
+    }
+
+    private synchronized void setVisibleTask(final boolean visible) {
+        if(DEBUG_IMPLEMENTATION) {
+            System.err.println("setVisibleTask: START ("+Thread.currentThread()+") "+this.x+"/"+this.y+" "+this.width+"x"+this.height+", fs "+fullscreen+", windowHandle "+windowHandle+", visible: "+this.visible+" -> "+visible);
+        }
+        int didit = 0;
+        if(0==windowHandle && visible) {
+            this.visible = visible;
+            didit = 01;
+            if( createNative() ) {
+                didit = 11;
+            }
+        } else if(this.visible != visible) {
+            this.visible = visible;
+            didit = 2;
+            if(0 != windowHandle) {
+                setVisibleImpl();
+                didit = 22;
+            }
+        }
+        if(DEBUG_IMPLEMENTATION) {
+            System.err.println("setVisibleTask: END ("+Thread.currentThread()+") didit "+didit+", "+this.x+"/"+this.y+" "+this.width+"x"+this.height+", fs "+fullscreen+", windowHandle "+windowHandle+", visible: "+visible);
+        }
+    }
+
+    protected abstract void setVisibleImpl();
 
     /**
      * Sets the size of the client area of the window, excluding decorations
diff --git a/src/newt/classes/com/jogamp/newt/event/awt/AWTAdapter.java b/src/newt/classes/com/jogamp/newt/event/awt/AWTAdapter.java
index 9fd3d604b..3abe6531a 100644
--- a/src/newt/classes/com/jogamp/newt/event/awt/AWTAdapter.java
+++ b/src/newt/classes/com/jogamp/newt/event/awt/AWTAdapter.java
@@ -136,6 +136,7 @@ public abstract class AWTAdapter implements java.util.EventListener
     /** 
      * Create a pipeline adapter, AWT EventListener.<br>
      * Once attached to an AWT component, it sends the converted AWT events to the NEWT downstream window.<br>
+     * This is only supported with EDT enabled!
      */
     public AWTAdapter(com.jogamp.newt.Window downstream) {
         if(null==downstream) {
@@ -143,6 +144,9 @@ public abstract class AWTAdapter implements java.util.EventListener
         }
         this.newtListener = null;
         this.newtWindow = downstream;
+        if( null == newtWindow.getScreen().getDisplay().getEDTUtil() ) {
+            throw new RuntimeException("EDT not enabled");
+        }
     }
 
     /** 
diff --git a/src/newt/classes/com/jogamp/newt/event/awt/AWTParentWindowAdapter.java b/src/newt/classes/com/jogamp/newt/event/awt/AWTParentWindowAdapter.java
index 49d9bf0f2..01f0457e3 100644
--- a/src/newt/classes/com/jogamp/newt/event/awt/AWTParentWindowAdapter.java
+++ b/src/newt/classes/com/jogamp/newt/event/awt/AWTParentWindowAdapter.java
@@ -52,11 +52,11 @@ public class AWTParentWindowAdapter extends AWTWindowAdapter
     }
 
     public void windowActivated(java.awt.event.WindowEvent e) {
-        // no propagation to NEWT child window ?? FIXME: Maybe yes in case of a 100% Opaque one ?
+        // no propagation to NEWT child window
     }
 
     public void windowDeactivated(java.awt.event.WindowEvent e) {
-        // no propagation to NEWT child window ?? FIXME: Maybe yes in case of a 100% Opaque one ?
+        // no propagation to NEWT child window
     }
 }
 
diff --git a/src/newt/classes/com/jogamp/newt/event/awt/AWTWindowAdapter.java b/src/newt/classes/com/jogamp/newt/event/awt/AWTWindowAdapter.java
index 2a5312d0b..fd6ceddae 100644
--- a/src/newt/classes/com/jogamp/newt/event/awt/AWTWindowAdapter.java
+++ b/src/newt/classes/com/jogamp/newt/event/awt/AWTWindowAdapter.java
@@ -31,8 +31,13 @@
  */
 package com.jogamp.newt.event.awt;
 
-public class AWTWindowAdapter extends AWTAdapter implements java.awt.event.ComponentListener, java.awt.event.WindowListener
+public class AWTWindowAdapter 
+    extends AWTAdapter 
+    implements java.awt.event.ComponentListener, java.awt.event.WindowListener, java.awt.event.HierarchyListener
 {
+    java.awt.Component awtComponent;
+    WindowClosingListener windowClosingListener;
+
     public AWTWindowAdapter(com.jogamp.newt.event.WindowListener newtListener) {
         super(newtListener);
     }
@@ -46,13 +51,35 @@ public class AWTWindowAdapter extends AWTAdapter implements java.awt.event.Compo
     }
 
     public AWTAdapter addTo(java.awt.Component awtComponent) {
+        this.awtComponent = awtComponent;
         awtComponent.addComponentListener(this);
+        awtComponent.addHierarchyListener(this);
+        addWindowClosingListenerTo(getWindow(awtComponent));
         if(awtComponent instanceof java.awt.Window) {
             ((java.awt.Window)awtComponent).addWindowListener(this);
         }
         return this;
     }
 
+    static java.awt.Window getWindow(java.awt.Component comp) {
+        while( null != comp && !(comp instanceof java.awt.Window) ) {
+            comp = comp.getParent();
+        }
+        if(comp instanceof java.awt.Window) {
+            return (java.awt.Window) comp;
+        }
+        return null;
+    }
+
+    void addWindowClosingListenerTo(java.awt.Window win) {
+        if( null == windowClosingListener ) {
+            windowClosingListener = new WindowClosingListener();
+        }
+        if( null != win ) {
+            win.addWindowListener(windowClosingListener);
+        }
+    }
+
     public void componentResized(java.awt.event.ComponentEvent e) {
         com.jogamp.newt.event.WindowEvent event = AWTNewtEventFactory.createWindowEvent(e, newtWindow);
         if(null!=newtListener) {
@@ -72,11 +99,19 @@ public class AWTWindowAdapter extends AWTAdapter implements java.awt.event.Compo
     }
 
     public void componentShown(java.awt.event.ComponentEvent e) {
-        // n/a 
+        if(null==newtListener) {
+            if(!newtWindow.isDestroyed()) {
+                newtWindow.setVisible(true, true /* deferred */);
+            }
+        }
     }
 
     public void componentHidden(java.awt.event.ComponentEvent e) {
-        // n/a 
+        if(null==newtListener) {
+            if(!newtWindow.isDestroyed()) {
+                newtWindow.setVisible(false, true /* deferred */);
+            }
+        }
     }
 
     public void windowActivated(java.awt.event.WindowEvent e) {
@@ -88,18 +123,9 @@ public class AWTWindowAdapter extends AWTAdapter implements java.awt.event.Compo
         }
     }
 
-    public void windowClosed(java.awt.event.WindowEvent e) {
-        // n/a 
-    }
+    public void windowClosed(java.awt.event.WindowEvent e) { }
 
-    public void windowClosing(java.awt.event.WindowEvent e) {
-        com.jogamp.newt.event.WindowEvent event = AWTNewtEventFactory.createWindowEvent(e, newtWindow);
-        if(null!=newtListener) {
-            ((com.jogamp.newt.event.WindowListener)newtListener).windowDestroyNotify(event);
-        } else {
-            enqueueEvent(event);
-        }
-    }
+    public void windowClosing(java.awt.event.WindowEvent e) { }
 
     public void windowDeactivated(java.awt.event.WindowEvent e) {
         com.jogamp.newt.event.WindowEvent event = AWTNewtEventFactory.createWindowEvent(e, newtWindow);
@@ -110,17 +136,56 @@ public class AWTWindowAdapter extends AWTAdapter implements java.awt.event.Compo
         }
     }
 
-    public void windowDeiconified(java.awt.event.WindowEvent e) {
-        // n/a 
+    public void windowDeiconified(java.awt.event.WindowEvent e) { }
+
+    public void windowIconified(java.awt.event.WindowEvent e) { }
+
+    public void windowOpened(java.awt.event.WindowEvent e) { }
+
+    public void hierarchyChanged(java.awt.event.HierarchyEvent e) {
+        if( null == newtListener ) {
+            long bits = e.getChangeFlags();
+            java.awt.Component changed = e.getChanged();
+            if( 0 != ( java.awt.event.HierarchyEvent.SHOWING_CHANGED & bits ) ) {
+                final boolean visible = changed.isVisible();
+                if(!newtWindow.isDestroyed()) {
+                    newtWindow.setVisible(visible, true /* deferred */);
+                }
+            } else if( 0 != ( java.awt.event.HierarchyEvent.PARENT_CHANGED & bits ) ) {
+                if(awtComponent == changed) {
+                    java.awt.Window win = getWindow(changed);
+                    if(null != win) {
+                        addWindowClosingListenerTo(win);
+                    } else {
+                        java.awt.Component parent = e.getChangedParent();
+                        if(parent instanceof java.awt.Window) {
+                            ((java.awt.Window)parent).removeWindowListener(this);
+                            if( null != windowClosingListener ) {
+                                ((java.awt.Window)parent).removeWindowListener(windowClosingListener);
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
 
-    public void windowIconified(java.awt.event.WindowEvent e) {
-        // n/a 
-    }
+    class WindowClosingListener implements java.awt.event.WindowListener {
+        public void windowClosing(java.awt.event.WindowEvent e) {
+            com.jogamp.newt.event.WindowEvent event = AWTNewtEventFactory.createWindowEvent(e, newtWindow);
+            if(null!=newtListener) {
+                ((com.jogamp.newt.event.WindowListener)newtListener).windowDestroyNotify(event);
+            } else {
+                enqueueEvent(event);
+            }
+        }
 
-    public void windowOpened(java.awt.event.WindowEvent e) {
-        // n/a 
+        public void windowActivated(java.awt.event.WindowEvent e) { }
+        public void windowClosed(java.awt.event.WindowEvent e) { }
+        public void windowDeactivated(java.awt.event.WindowEvent e) { }
+        public void windowDeiconified(java.awt.event.WindowEvent e) { }
+        public void windowIconified(java.awt.event.WindowEvent e) { }
+        public void windowOpened(java.awt.event.WindowEvent e) { }
     }
-
 }
 
diff --git a/src/newt/classes/com/jogamp/newt/impl/awt/AWTDisplay.java b/src/newt/classes/com/jogamp/newt/impl/awt/AWTDisplay.java
index f54e66f07..b0b518c59 100644
--- a/src/newt/classes/com/jogamp/newt/impl/awt/AWTDisplay.java
+++ b/src/newt/classes/com/jogamp/newt/impl/awt/AWTDisplay.java
@@ -44,7 +44,7 @@ public class AWTDisplay extends Display {
     public AWTDisplay() {
     }
 
-    protected void createNative() {
+    protected void createNative(long handle) {
         aDevice = (AWTGraphicsDevice) AWTGraphicsDevice.createDevice(null); // default 
     }
 
diff --git a/src/newt/classes/com/jogamp/newt/impl/awt/AWTNewtFactory.java b/src/newt/classes/com/jogamp/newt/impl/awt/AWTNewtFactory.java
index b42730a81..e0f86b1a9 100644
--- a/src/newt/classes/com/jogamp/newt/impl/awt/AWTNewtFactory.java
+++ b/src/newt/classes/com/jogamp/newt/impl/awt/AWTNewtFactory.java
@@ -42,11 +42,13 @@ import javax.media.nativewindow.*;
 import javax.media.nativewindow.awt.*;
 
 import com.jogamp.newt.event.awt.AWTParentWindowAdapter;
+import com.jogamp.newt.Display;
 import com.jogamp.newt.Screen;
 import com.jogamp.newt.Window;
 import com.jogamp.newt.NewtFactory;
+import com.jogamp.common.util.ReflectionUtil;
 
-public class AWTNewtFactory {
+public class AWTNewtFactory extends NewtFactory {
 
   /**
    * Wraps an AWT component into a {@link javax.media.nativewindow.NativeWindow} utilizing the {@link javax.media.nativewindow.NativeWindowFactory},<br>
@@ -60,19 +62,20 @@ public class AWTNewtFactory {
    *
    * @param awtCompObject must be of type java.awt.Component
    */
-  public static NativeWindow getNativeWindow(Object awtCompObject) {
+  public static NativeWindow getNativeWindow(Object awtCompObject, Capabilities capsRequested) {
       if(null==awtCompObject) {
         throw new NativeWindowException("Null AWT Component");
       }
       if( ! (awtCompObject instanceof java.awt.Component) ) {
         throw new NativeWindowException("AWT Component not a java.awt.Component");
       }
-      java.awt.Component awtComp = (java.awt.Component) awtCompObject;
-      DefaultGraphicsDevice dummyDevice = new DefaultGraphicsDevice("AWTNewtBridge");
-      DefaultGraphicsScreen dummyScreen = new DefaultGraphicsScreen(dummyDevice, 0);
-      Capabilities dummyCaps = new Capabilities();
-      DefaultGraphicsConfiguration dummyConfig = new DefaultGraphicsConfiguration(dummyScreen, dummyCaps, dummyCaps);
-      NativeWindow awtNative = NativeWindowFactory.getNativeWindow(awtComp, dummyConfig);
+      return getNativeWindow( (java.awt.Component) awtCompObject, capsRequested );
+  }
+
+  public static NativeWindow getNativeWindow(java.awt.Component awtComp, Capabilities capsRequested) {
+      DefaultGraphicsConfiguration config = 
+          AWTGraphicsConfiguration.create(awtComp, (Capabilities) capsRequested.clone(), capsRequested);
+      NativeWindow awtNative = NativeWindowFactory.getNativeWindow(awtComp, config); // a JAWTWindow
       return awtNative;
   }
 
@@ -84,30 +87,52 @@ public class AWTNewtFactory {
    * The actual wrapping implementation is {@link com.jogamp.nativewindow.impl.jawt.JAWTWindow}.<br></p>
    * <p>
    * Second we create a child {@link com.jogamp.newt.Window}, 
-   * utilizing {@link com.jogamp.newt.NewtFactory#createWindow(long, com.jogamp.newt.Screen, javax.media.nativewindow.Capabilities, boolean)},
-   * passing the AWT parent's native window handle retrieved via {@link com.jogamp.nativewindow.impl.jawt.JAWTWindow#getWindowHandle()}.<br></p>
+   * utilizing {@link com.jogamp.newt.NewtFactory#createWindowImpl(java.lang.String, javax.media.nativewindow.NativeWindow, com.jogamp.newt.Screen, javax.media.nativewindow.Capabilities, boolean)},
+   * passing the created {@link javax.media.nativewindow.NativeWindow}.<br></p>
 
    * <p>
    * Third we attach a {@link com.jogamp.newt.event.awt.AWTParentWindowAdapter} to the given AWT component.<br>
    * The adapter passes window related events to our new child window, look at the implementation<br></p>
    *
+   * <p>
+   * Forth we pass the parents visibility to the new Window<br></p>
+   *
    * @param awtParentObject must be of type java.awt.Component
    * @param undecorated only impacts if the window is in top-level state, while attached to a parent window it's rendered undecorated always
+   * @return The successful created child window, or null if the AWT parent is not ready yet (no valid peers)
    */ 
-  public static Window createNativeChildWindow(Object awtParentObject, Screen newtScreen, Capabilities newtCaps, boolean undecorated) {
-      NativeWindow parent = getNativeWindow(awtParentObject); // also checks java.awt.Component type
+  public static Window createNativeChildWindow(Object awtParentObject, Capabilities newtCaps, boolean undecorated) {
+      if( null == awtParentObject ) {
+        throw new NativeWindowException("Null AWT Parent Component");
+      }
+      if( ! (awtParentObject instanceof java.awt.Component) ) {
+        throw new NativeWindowException("AWT Parent Component not a java.awt.Component");
+      }
       java.awt.Component awtParent = (java.awt.Component) awtParentObject;
+
+      // Generate a complete JAWT NativeWindow from the AWT Component
+      NativeWindow parent = getNativeWindow(awtParent, newtCaps);
       if(null==parent) {
         throw new NativeWindowException("Null NativeWindow from parent: "+awtParent);
       }
-      parent.lockSurface();
-      long windowHandle = parent.getWindowHandle();
-      parent.unlockSurface();
-      if(0==windowHandle) {
-        throw new NativeWindowException("Null window handle: "+parent);
-      }
-      Window window = NewtFactory.createWindow(windowHandle, newtScreen, newtCaps, undecorated);
+
+      // Get parent's NativeWindow details
+      AWTGraphicsConfiguration parentConfig = (AWTGraphicsConfiguration) parent.getGraphicsConfiguration();
+      AWTGraphicsScreen parentScreen = (AWTGraphicsScreen) parentConfig.getScreen();
+      AWTGraphicsDevice parentDevice = (AWTGraphicsDevice) parentScreen.getDevice();
+
+      // Prep NEWT's Display and Screen according to the parent
+      final String type = NativeWindowFactory.getNativeWindowType(true);
+      Display display = NewtFactory.wrapDisplay(type, parentDevice.getHandle());
+      Screen screen  = NewtFactory.createScreen(type, display, parentScreen.getIndex());
+
+      // NEWT Window creation and add event handler for proper propagation AWT -> NEWT
+      // and copy size/visible state
+      Window window = NewtFactory.createWindowImpl(type, parent, screen, newtCaps, undecorated);
       new AWTParentWindowAdapter(window).addTo(awtParent);
+      window.setSize(awtParent.getWidth(), awtParent.getHeight());
+      window.setVisible(awtParent.isVisible());
+
       return window;
   }
 }
diff --git a/src/newt/classes/com/jogamp/newt/impl/awt/AWTWindow.java b/src/newt/classes/com/jogamp/newt/impl/awt/AWTWindow.java
index bc04f2523..b98a6fa20 100644
--- a/src/newt/classes/com/jogamp/newt/impl/awt/AWTWindow.java
+++ b/src/newt/classes/com/jogamp/newt/impl/awt/AWTWindow.java
@@ -34,6 +34,7 @@
 package com.jogamp.newt.impl.awt;
 
 import com.jogamp.newt.event.awt.*;
+import com.jogamp.newt.util.EDTUtil;
 
 import java.awt.BorderLayout;
 import java.awt.Canvas;
@@ -94,7 +95,7 @@ public class AWTWindow extends Window {
             });
     }
 
-    protected void createNative(long parentWindowHandle, final Capabilities caps) {
+    protected void createNativeImpl() {
 
         if(0!=parentWindowHandle) {
             throw new RuntimeException("Window parenting not supported in AWT, use AWTWindow(Frame) cstr for wrapping instead");
@@ -175,7 +176,7 @@ public class AWTWindow extends Window {
         return res;
     }
 
-    public void setVisible(final boolean visible) {
+    protected void setVisibleImpl() {
         runOnEDT(true, new Runnable() {
                 public void run() {
                     container.setVisible(visible);
@@ -209,14 +210,16 @@ public class AWTWindow extends Window {
             nfs_width=width;
             nfs_height=height;
         }
-        /** An AWT event on setSize() would bring us in a deadlock situation, hence invokeLater() */
-        runOnEDT(false, new Runnable() {
-                public void run() {
-                    Insets insets = container.getInsets();
-                    container.setSize(width + insets.left + insets.right,
-                                      height + insets.top + insets.bottom);
-                }
-            });
+        if(null!=container) {
+            /** An AWT event on setSize() would bring us in a deadlock situation, hence invokeLater() */
+            runOnEDT(false, new Runnable() {
+                    public void run() {
+                        Insets insets = container.getInsets();
+                        container.setSize(width + insets.left + insets.right,
+                                          height + insets.top + insets.bottom);
+                    }
+                });
+        }
     }
 
     public com.jogamp.newt.Insets getInsets() {
@@ -302,8 +305,9 @@ public class AWTWindow extends Window {
         super.sendMouseEvent(eventType, modifiers, x, y, button, rotation);
     }
 
-    private static void runOnEDT(boolean wait, Runnable r) {
-        if (EventQueue.isDispatchThread()) {
+    private void runOnEDT(boolean wait, Runnable r) {
+        EDTUtil edtUtil = screen.getDisplay().getEDTUtil();
+        if ( ( null != edtUtil && edtUtil.isCurrentThreadEDT() ) || EventQueue.isDispatchThread() ) {
             r.run();
         } else {
             try {
diff --git a/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Display.java b/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Display.java
index d19aaf796..ac27da9ef 100644
--- a/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Display.java
+++ b/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Display.java
@@ -58,10 +58,10 @@ public class Display extends com.jogamp.newt.Display {
     public Display() {
     }
 
-    protected void createNative() {
+    protected void createNative(long handle) {
         synchronized(Display.class) {
             if(0==initCounter) {
-                displayHandle = CreateDisplay();
+                displayHandle = (0 == handle) ?  CreateDisplay() : handle;
                 if(0==displayHandle) {
                     throw new NativeWindowException("Couldn't initialize GDL Display");
                 }
diff --git a/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Window.java b/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Window.java
index cb52618b2..7b867db21 100644
--- a/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Window.java
+++ b/src/newt/classes/com/jogamp/newt/impl/intel/gdl/Window.java
@@ -45,7 +45,7 @@ public class Window extends com.jogamp.newt.Window {
 
     static long nextWindowHandle = 1;
 
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
+    protected void createNativeImpl() {
         if(0!=parentWindowHandle) {
             throw new NativeWindowException("GDL Window does not support window parenting");
         }
@@ -59,6 +59,11 @@ public class Window extends com.jogamp.newt.Window {
 
         synchronized(Window.class) {
             windowHandle = nextWindowHandle++;
+
+            surfaceHandle = CreateSurface(aDevice.getHandle(), screen.getWidth(), screen.getHeight(), x, y, width, height);
+            if (surfaceHandle == 0) {
+                throw new NativeWindowException("Error creating window");
+            }
         }
     }
 
@@ -72,19 +77,9 @@ public class Window extends com.jogamp.newt.Window {
         }
     }
 
-    public void setVisible(boolean visible) {
-        if(this.visible!=visible) {
-            this.visible=visible;
-            if(visible && 0==surfaceHandle) {
-                synchronized(Window.class) {
-                    AbstractGraphicsDevice aDevice = screen.getDisplay().getGraphicsDevice();
-                    surfaceHandle = CreateSurface(aDevice.getHandle(), screen.getWidth(), screen.getHeight(), x, y, width, height);
-                }
-                if (surfaceHandle == 0) {
-                    throw new NativeWindowException("Error creating window");
-                }
-                ((Display)screen.getDisplay()).setFocus(this);
-            }
+    protected void setVisibleImpl() {
+        if(visible) {
+            ((Display)screen.getDisplay()).setFocus(this);
         }
     }
 
diff --git a/src/newt/classes/com/jogamp/newt/impl/macosx/MacDisplay.java b/src/newt/classes/com/jogamp/newt/impl/macosx/MacDisplay.java
index 68242bba7..6e1119a9d 100755
--- a/src/newt/classes/com/jogamp/newt/impl/macosx/MacDisplay.java
+++ b/src/newt/classes/com/jogamp/newt/impl/macosx/MacDisplay.java
@@ -43,10 +43,10 @@ public class MacDisplay extends Display {
     static {
         NEWTJNILibLoader.loadNEWT();
 
-        if(!initNSApplication()) {
+        if(!initNSApplication0()) {
             throw new NativeWindowException("Failed to initialize native Application hook");
         }
-        if(!MacWindow.initIDs()) {
+        if(!MacWindow.initIDs0()) {
             throw new NativeWindowException("Failed to initialize jmethodIDs");
         }
         if(DEBUG) System.out.println("MacDisplay.init App and IDs OK "+Thread.currentThread().getName());
@@ -70,13 +70,13 @@ public class MacDisplay extends Display {
         MainThread.invoke(false, dispatchAction);
     }
     
-    protected void createNative() {
+    protected void createNative(long handle) {
         aDevice = new MacOSXGraphicsDevice();
     }
 
     protected void closeNative() { }
 
-    private static native boolean initNSApplication();
+    private static native boolean initNSApplication0();
     protected native void dispatchMessages0();
 }
 
diff --git a/src/newt/classes/com/jogamp/newt/impl/macosx/MacScreen.java b/src/newt/classes/com/jogamp/newt/impl/macosx/MacScreen.java
index ce9254857..d7deb13ee 100755
--- a/src/newt/classes/com/jogamp/newt/impl/macosx/MacScreen.java
+++ b/src/newt/classes/com/jogamp/newt/impl/macosx/MacScreen.java
@@ -46,11 +46,11 @@ public class MacScreen extends Screen {
 
     protected void createNative(int index) {
         aScreen = new DefaultGraphicsScreen(getDisplay().getGraphicsDevice(), index);
-        setScreenSize(getWidthImpl(getIndex()), getHeightImpl(getIndex()));
+        setScreenSize(getWidthImpl0(getIndex()), getHeightImpl0(getIndex()));
     }
 
     protected void closeNative() { }
 
-    private static native int getWidthImpl(int scrn_idx);
-    private static native int getHeightImpl(int scrn_idx);
+    private static native int getWidthImpl0(int scrn_idx);
+    private static native int getHeightImpl0(int scrn_idx);
 }
diff --git a/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java b/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java
index 963c0c0a7..93c2b14bb 100755
--- a/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java
+++ b/src/newt/classes/com/jogamp/newt/impl/macosx/MacWindow.java
@@ -130,7 +130,6 @@ public class MacWindow extends Window {
     private static final int NSModeSwitchFunctionKey     = 0xF747;
 
     private volatile long surfaceHandle;
-    private long parentWindowHandle;
 
     // non fullscreen dimensions ..
     private int nfs_width, nfs_height, nfs_x, nfs_y;
@@ -143,8 +142,7 @@ public class MacWindow extends Window {
     public MacWindow() {
     }
     
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
-        this.parentWindowHandle=parentWindowHandle;
+    protected void createNativeImpl() {
         config = GraphicsConfigurationFactory.getFactory(getScreen().getDisplay().getGraphicsDevice()).chooseGraphicsConfiguration(caps, null, getScreen().getGraphicsScreen());
         if (config == null) {
             throw new NativeWindowException("Error choosing GraphicsConfiguration creating window: "+this);
@@ -193,7 +191,7 @@ public class MacWindow extends Window {
         public void run() {
             nsViewLock.lock();
             try {
-                createWindow(parentWindowHandle, false);
+                createWindow(false);
             } finally {
                 nsViewLock.unlock();
             }
@@ -237,13 +235,13 @@ public class MacWindow extends Window {
             try {
                 if(DEBUG_IMPLEMENTATION) System.out.println("MacWindow.VisibleAction "+visible+" "+Thread.currentThread().getName());
                 if (visible) {
-                    createWindow(parentWindowHandle, false);
+                    createWindow(false);
                     if (windowHandle != 0) {
-                        makeKeyAndOrderFront(windowHandle);
+                        makeKeyAndOrderFront0(windowHandle);
                     }
                 } else {
                     if (windowHandle != 0) {
-                        orderOut(windowHandle);
+                        orderOut0(windowHandle);
                     }
                 }
             } finally {
@@ -253,8 +251,7 @@ public class MacWindow extends Window {
     }
     private VisibleAction visibleAction = new VisibleAction();
 
-    public void setVisible(boolean visible) {
-        this.visible = visible;
+    protected void setVisibleImpl() {
         MainThread.invoke(true, visibleAction);
     }
 
@@ -282,7 +279,7 @@ public class MacWindow extends Window {
             nsViewLock.lock();
             try {
                 if (windowHandle != 0) {
-                    makeKey(windowHandle);
+                    makeKey0(windowHandle);
                 }
             } finally {
                 nsViewLock.unlock();
@@ -301,7 +298,7 @@ public class MacWindow extends Window {
             nsViewLock.lock();
             try {
                 if (windowHandle != 0) {
-                    setContentSize(windowHandle, width, height);
+                    setContentSize0(windowHandle, width, height);
                 }
             } finally {
                 nsViewLock.unlock();
@@ -311,13 +308,19 @@ public class MacWindow extends Window {
     private SizeAction sizeAction = new SizeAction();
 
     public void setSize(int width, int height) {
-        this.width=width;
-        this.height=height;
-        if(!fullscreen) {
-            nfs_width=width;
-            nfs_height=height;
+        if (width != this.width || this.height != height) {
+            if(!fullscreen) {
+                nfs_width=width;
+                nfs_height=height;
+                if (0 != windowHandle) {
+                    // this width/height will be set by sizeChanged, called by OSX
+                    MainThread.invoke(true, sizeAction);
+                } else {
+                    this.width=width;
+                    this.height=height;
+                }
+            }
         }
-        MainThread.invoke(true, sizeAction);
     }
     
     class PositionAction implements Runnable {
@@ -325,7 +328,7 @@ public class MacWindow extends Window {
             nsViewLock.lock();
             try {
                 if (windowHandle != 0) {
-                    setFrameTopLeftPoint(parentWindowHandle, windowHandle, x, y);
+                    setFrameTopLeftPoint0(parentWindowHandle, windowHandle, x, y);
                 }
             } finally {
                 nsViewLock.unlock();
@@ -335,13 +338,19 @@ public class MacWindow extends Window {
     private PositionAction positionAction = new PositionAction();
 
     public void setPosition(int x, int y) {
-        this.x=x;
-        this.y=y;
-        if(!fullscreen) {
-            nfs_x=x;
-            nfs_y=y;
+        if ( this.x != x || this.y != y ) {
+            if(!fullscreen) {
+                nfs_x=x;
+                nfs_y=y;
+                if (0 != windowHandle) {
+                    // this x/y will be set by positionChanged, called by OSX
+                    MainThread.invoke(true, positionAction);
+                } else {
+                    this.x=x;
+                    this.y=y;
+                }
+            }
         }
-        MainThread.invoke(true, positionAction);
     }
     
     class FullscreenAction implements Runnable {
@@ -351,9 +360,9 @@ public class MacWindow extends Window {
                 if(DEBUG_IMPLEMENTATION || DEBUG_WINDOW_EVENT) {
                     System.err.println("MacWindow fs: "+fullscreen+" "+x+"/"+y+" "+width+"x"+height);
                 }
-                createWindow(parentWindowHandle, true);
+                createWindow(true);
                 if (windowHandle != 0) {
-                    makeKeyAndOrderFront(windowHandle);
+                    makeKeyAndOrderFront0(windowHandle);
                 }
             } finally {
                 nsViewLock.unlock();
@@ -382,19 +391,21 @@ public class MacWindow extends Window {
     }
     
     private void sizeChanged(int newWidth, int newHeight) {
-        if (DEBUG_IMPLEMENTATION) {
-            System.out.println(Thread.currentThread().getName()+" Size changed to " + newWidth + ", " + newHeight);
-        }
-        width = newWidth;
-        height = newHeight;
-        if(!fullscreen) {
-            nfs_width=width;
-            nfs_height=height;
-        }
-        if (DEBUG_IMPLEMENTATION) {
-            System.out.println("  Posted WINDOW_RESIZED event");
+        if(width != newWidth || height != newHeight) {
+            if (DEBUG_IMPLEMENTATION) {
+                System.out.println(Thread.currentThread().getName()+" Size changed to " + newWidth + ", " + newHeight);
+            }
+            width = newWidth;
+            height = newHeight;
+            if(!fullscreen) {
+                nfs_width=width;
+                nfs_height=height;
+            }
+            if (DEBUG_IMPLEMENTATION) {
+                System.out.println("  Posted WINDOW_RESIZED event");
+            }
+            sendWindowEvent(WindowEvent.EVENT_WINDOW_RESIZED);
         }
-        sendWindowEvent(WindowEvent.EVENT_WINDOW_RESIZED);
     }
 
     private void insetsChanged(int left, int top, int right, int bottom) {
@@ -411,19 +422,21 @@ public class MacWindow extends Window {
     }
 
     private void positionChanged(int newX, int newY) {
-        if (DEBUG_IMPLEMENTATION) {
-            System.out.println(Thread.currentThread().getName()+" Position changed to " + newX + ", " + newY);
-        }
-        x = newX;
-        y = newY;
-        if(!fullscreen) {
-            nfs_x=x;
-            nfs_y=y;
-        }
-        if (DEBUG_IMPLEMENTATION) {
-            System.out.println("  Posted WINDOW_MOVED event");
+        if( 0==parentWindowHandle && ( x != newX || y != newY ) ) {
+            if (DEBUG_IMPLEMENTATION) {
+                System.out.println(Thread.currentThread().getName()+" Position changed to " + newX + ", " + newY);
+            }
+            x = newX;
+            y = newY;
+            if(!fullscreen) {
+                nfs_x=x;
+                nfs_y=y;
+            }
+            if (DEBUG_IMPLEMENTATION) {
+                System.out.println("  Posted WINDOW_MOVED event");
+            }
+            sendWindowEvent(WindowEvent.EVENT_WINDOW_MOVED);
         }
-        sendWindowEvent(WindowEvent.EVENT_WINDOW_MOVED);
     }
 
     private void focusChanged(boolean focusGained) {
@@ -525,13 +538,13 @@ public class MacWindow extends Window {
         super.sendKeyEvent(eventType, modifiers, key, keyChar);
     }
 
-    private void createWindow(long parentWindowHandle, boolean recreate) {
+    private void createWindow(boolean recreate) {
         if(0!=windowHandle && !recreate) {
             return;
         }
         if(0!=windowHandle) {
             // save the view .. close the window
-            surfaceHandle = changeContentView(parentWindowHandle, windowHandle, 0);
+            surfaceHandle = changeContentView0(parentWindowHandle, windowHandle, 0);
             if(recreate && 0==surfaceHandle) {
                 throw new NativeWindowException("Internal Error - recreate, window but no view");
             }
@@ -550,27 +563,27 @@ public class MacWindow extends Window {
         if (windowHandle == 0) {
             throw new NativeWindowException("Could create native window "+Thread.currentThread().getName()+" "+this);
         }
-        surfaceHandle = contentView(windowHandle);
+        surfaceHandle = contentView0(windowHandle);
         setTitle0(windowHandle, getTitle());
         // don't make the window visible on window creation
-//        makeKeyAndOrderFront(windowHandle);
+//        makeKeyAndOrderFront0(windowHandle);
         sendWindowEvent(WindowEvent.EVENT_WINDOW_MOVED);
         sendWindowEvent(WindowEvent.EVENT_WINDOW_RESIZED);
         sendWindowEvent(WindowEvent.EVENT_WINDOW_GAINED_FOCUS);
     }
     
-    protected static native boolean initIDs();
+    protected static native boolean initIDs0();
     private native long createWindow0(long parentWindowHandle, int x, int y, int w, int h,
                                      boolean fullscreen, int windowStyle,
                                      int backingStoreType,
                                      int screen_idx, long view);
-    private native void makeKeyAndOrderFront(long window);
-    private native void makeKey(long window);
-    private native void orderOut(long window);
+    private native void makeKeyAndOrderFront0(long window);
+    private native void makeKey0(long window);
+    private native void orderOut0(long window);
     private native void close0(long window);
     private native void setTitle0(long window, String title);
-    private native long contentView(long window);
-    private native long changeContentView(long parentWindowHandle, long window, long view);
-    private native void setContentSize(long window, int w, int h);
-    private native void setFrameTopLeftPoint(long parentWindowHandle, long window, int x, int y);
+    private native long contentView0(long window);
+    private native long changeContentView0(long parentWindowHandle, long window, long view);
+    private native void setContentSize0(long window, int w, int h);
+    private native void setFrameTopLeftPoint0(long parentWindowHandle, long window, int x, int y);
 }
diff --git a/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Display.java b/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Display.java
index c2d323e56..c08499359 100644
--- a/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Display.java
+++ b/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Display.java
@@ -56,8 +56,10 @@ public class Display extends com.jogamp.newt.Display {
     public Display() {
     }
 
-    protected void createNative() {
-        long handle = CreateDisplay(Screen.fixedWidth, Screen.fixedHeight);
+    protected void createNative(long handle) {
+        if( 0 == handle ) {
+            handle = CreateDisplay(Screen.fixedWidth, Screen.fixedHeight);
+        }
         if (handle == EGL.EGL_NO_DISPLAY) {
             throw new NativeWindowException("BC EGL CreateDisplay failed");
         }
diff --git a/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Window.java b/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Window.java
index 9e1ead40e..b25ed4ee8 100755
--- a/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Window.java
+++ b/src/newt/classes/com/jogamp/newt/impl/opengl/broadcom/egl/Window.java
@@ -46,7 +46,7 @@ public class Window extends com.jogamp.newt.Window {
     public Window() {
     }
 
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
+    protected void createNativeImpl() {
         if(0!=parentWindowHandle) {
             throw new RuntimeException("Window parenting not supported (yet)");
         }
@@ -57,6 +57,11 @@ public class Window extends com.jogamp.newt.Window {
             throw new NativeWindowException("Error choosing GraphicsConfiguration creating window: "+this);
         }
         setSizeImpl(getScreen().getWidth(), getScreen().getHeight());
+
+        windowHandle = realizeWindow(true, width, height);
+        if (0 == windowHandle) {
+            throw new NativeWindowException("Error native Window Handle is null");
+        }
     }
 
     protected void closeNative() {
@@ -65,18 +70,7 @@ public class Window extends com.jogamp.newt.Window {
         }
     }
 
-    public void setVisible(boolean visible) {
-        if(this.visible!=visible) {
-            this.visible=visible;
-            if ( 0==windowHandle ) {
-                windowHandle = realizeWindow(true, width, height);
-                if (0 == windowHandle) {
-                    throw new NativeWindowException("Error native Window Handle is null");
-                }
-            }
-            clearEventMask();
-        }
-    }
+    protected void setVisibleImpl() { }
 
     public void setSize(int width, int height) {
         System.err.println("setSize "+width+"x"+height+" n/a in BroadcomEGL");
diff --git a/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDDisplay.java b/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDDisplay.java
index 2ab30773f..bb5f1cc7a 100755
--- a/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDDisplay.java
+++ b/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDDisplay.java
@@ -57,9 +57,12 @@ public class KDDisplay extends Display {
     public KDDisplay() {
     }
 
-    protected void createNative() {
+    protected void createNative(long handle) {
         // FIXME: map name to EGL_*_DISPLAY
-        long handle = EGL.eglGetDisplay(EGL.EGL_DEFAULT_DISPLAY);
+        // FIXME: what do to with external handle ?
+        if(0==handle) {
+            handle = EGL.eglGetDisplay(EGL.EGL_DEFAULT_DISPLAY);
+        }
         if (handle == EGL.EGL_NO_DISPLAY) {
             throw new NativeWindowException("eglGetDisplay failed");
         }
diff --git a/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDWindow.java b/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDWindow.java
index 5f1068cad..f60abb7cd 100755
--- a/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDWindow.java
+++ b/src/newt/classes/com/jogamp/newt/impl/opengl/kd/KDWindow.java
@@ -54,7 +54,7 @@ public class KDWindow extends Window {
     public KDWindow() {
     }
 
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
+    protected void createNativeImpl() {
         if(0!=parentWindowHandle) {
             throw new RuntimeException("Window parenting not supported (yet)");
         }
@@ -66,12 +66,15 @@ public class KDWindow extends Window {
         GLCapabilities eglCaps = (GLCapabilities)config.getChosenCapabilities();
         int[] eglAttribs = EGLGraphicsConfiguration.GLCapabilities2AttribList(eglCaps);
 
-        windowHandle = 0;
         eglWindowHandle = CreateWindow(getDisplayHandle(), eglAttribs);
         if (eglWindowHandle == 0) {
             throw new NativeWindowException("Error creating egl window: "+config);
         }
         setVisible0(eglWindowHandle, false);
+        windowHandle = RealizeWindow(eglWindowHandle);
+        if (0 == windowHandle) {
+            throw new NativeWindowException("Error native Window Handle is null");
+        }
         windowHandleClose = eglWindowHandle;
     }
 
@@ -82,18 +85,9 @@ public class KDWindow extends Window {
         }
     }
 
-    public void setVisible(boolean visible) {
-        if(0!=eglWindowHandle && this.visible!=visible) {
-            this.visible=visible;
-            setVisible0(eglWindowHandle, visible);
-            if ( 0==windowHandle ) {
-                windowHandle = RealizeWindow(eglWindowHandle);
-                if (0 == windowHandle) {
-                    throw new NativeWindowException("Error native Window Handle is null");
-                }
-            }
-            clearEventMask();
-        }
+    protected void setVisibleImpl() {
+        setVisible0(eglWindowHandle, visible);
+        clearEventMask();
     }
 
     public void setSize(int width, int height) {
diff --git a/src/newt/classes/com/jogamp/newt/impl/windows/WindowsDisplay.java b/src/newt/classes/com/jogamp/newt/impl/windows/WindowsDisplay.java
index 000e64b6d..f75c11cfb 100755
--- a/src/newt/classes/com/jogamp/newt/impl/windows/WindowsDisplay.java
+++ b/src/newt/classes/com/jogamp/newt/impl/windows/WindowsDisplay.java
@@ -47,7 +47,7 @@ public class WindowsDisplay extends Display {
     static {
         NEWTJNILibLoader.loadNEWT();
 
-        if (!WindowsWindow.initIDs()) {
+        if (!WindowsWindow.initIDs0()) {
             throw new NativeWindowException("Failed to initialize WindowsWindow jmethodIDs");
         }
     }
@@ -60,22 +60,22 @@ public class WindowsDisplay extends Display {
     public WindowsDisplay() {
     }
 
-    protected void createNative() {
+    protected void createNative(long handle) {
         aDevice = new WindowsGraphicsDevice();
     }
 
     protected void closeNative() { 
         // Can't do .. only at application shutdown 
-        // UnregisterWindowClass(getWindowClassAtom(), getHInstance());
+        // UnregisterWindowClass0(getWindowClassAtom(), getHInstance());
     }
 
     protected void dispatchMessagesNative() {
-        DispatchMessages();
+        DispatchMessages0();
     }
 
     protected static synchronized int getWindowClassAtom() {
         if(0 == windowClassAtom) {
-            windowClassAtom = RegisterWindowClass(WINDOW_CLASS_NAME, getHInstance());
+            windowClassAtom = RegisterWindowClass0(WINDOW_CLASS_NAME, getHInstance());
             if (0 == windowClassAtom) {
                 throw new NativeWindowException("Error while registering window class");
             }
@@ -85,7 +85,7 @@ public class WindowsDisplay extends Display {
 
     protected static synchronized long getHInstance() {
         if(0 == hInstance) {
-            hInstance = LoadLibraryW("newt");
+            hInstance = LoadLibraryW0("newt");
             if (0 == hInstance) {
                 throw new NativeWindowException("Error finding HINSTANCE for \"newt\"");
             }
@@ -96,10 +96,10 @@ public class WindowsDisplay extends Display {
     //----------------------------------------------------------------------
     // Internals only
     //
-    private static native long LoadLibraryW(String libraryName);
-    private static native int  RegisterWindowClass(String windowClassName, long hInstance);
-    private static native void UnregisterWindowClass(int wndClassAtom, long hInstance);
+    private static native long LoadLibraryW0(String libraryName);
+    private static native int  RegisterWindowClass0(String windowClassName, long hInstance);
+    private static native void UnregisterWindowClass0(int wndClassAtom, long hInstance);
 
-    private static native void DispatchMessages();
+    private static native void DispatchMessages0();
 }
 
diff --git a/src/newt/classes/com/jogamp/newt/impl/windows/WindowsScreen.java b/src/newt/classes/com/jogamp/newt/impl/windows/WindowsScreen.java
index b0161cfc2..1b4be0d55 100755
--- a/src/newt/classes/com/jogamp/newt/impl/windows/WindowsScreen.java
+++ b/src/newt/classes/com/jogamp/newt/impl/windows/WindowsScreen.java
@@ -47,11 +47,11 @@ public class WindowsScreen extends Screen {
 
     protected void createNative(int index) {
         aScreen = new DefaultGraphicsScreen(getDisplay().getGraphicsDevice(), index);
-        setScreenSize(getWidthImpl(getIndex()), getHeightImpl(getIndex()));
+        setScreenSize(getWidthImpl0(getIndex()), getHeightImpl0(getIndex()));
     }
 
     protected void closeNative() { }
 
-    private        native int getWidthImpl(int scrn_idx);
-    private        native int getHeightImpl(int scrn_idx);
+    private        native int getWidthImpl0(int scrn_idx);
+    private        native int getHeightImpl0(int scrn_idx);
 }
diff --git a/src/newt/classes/com/jogamp/newt/impl/windows/WindowsWindow.java b/src/newt/classes/com/jogamp/newt/impl/windows/WindowsWindow.java
index bec7bfed2..dad3456d7 100755
--- a/src/newt/classes/com/jogamp/newt/impl/windows/WindowsWindow.java
+++ b/src/newt/classes/com/jogamp/newt/impl/windows/WindowsWindow.java
@@ -42,7 +42,6 @@ public class WindowsWindow extends Window {
     private long hmon;
     private long hdc;
     private long windowHandleClose;
-    private long parentWindowHandle;
     // non fullscreen dimensions ..
     private int nfs_width, nfs_height, nfs_x, nfs_y;
     private final Insets insets = new Insets(0, 0, 0, 0);
@@ -62,8 +61,8 @@ public class WindowsWindow extends Window {
             if(hdc!=0) {
                 throw new NativeWindowException("NEWT Surface handle set HDC "+toHexString(hdc)+" - "+Thread.currentThread().getName()+" ; "+this);
             }
-            hdc = GetDC(windowHandle);
-            hmon = MonitorFromWindow(windowHandle);
+            hdc = GetDC0(windowHandle);
+            hmon = MonitorFromWindow0(windowHandle);
             hdcOwner = Thread.currentThread();
         }
         return res;
@@ -80,7 +79,7 @@ public class WindowsWindow extends Window {
             if(hdcOwner != cur) {
                 throw new NativeWindowException("NEWT Surface handle set HDC "+toHexString(hdc)+" by other thread "+hdcOwner+", this "+cur+" ; "+this);
             }
-            ReleaseDC(windowHandle, hdc);
+            ReleaseDC0(windowHandle, hdc);
             hdc=0;
             hdcOwner=null;
         }
@@ -93,7 +92,7 @@ public class WindowsWindow extends Window {
 
     public boolean hasDeviceChanged() {
         if(0!=windowHandle) {
-            long _hmon = MonitorFromWindow(windowHandle);
+            long _hmon = MonitorFromWindow0(windowHandle);
             if (hmon != _hmon) {
                 if(DEBUG_IMPLEMENTATION || DEBUG_WINDOW_EVENT) {
                     Exception e = new Exception("!!! Window Device Changed "+Thread.currentThread().getName()+
@@ -107,20 +106,19 @@ public class WindowsWindow extends Window {
         return false;
     }
 
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
+    protected void createNativeImpl() {
         WindowsScreen  screen = (WindowsScreen) getScreen();
         WindowsDisplay display = (WindowsDisplay) screen.getDisplay();
         config = GraphicsConfigurationFactory.getFactory(display.getGraphicsDevice()).chooseGraphicsConfiguration(caps, null, screen.getGraphicsScreen());
         if (config == null) {
             throw new NativeWindowException("Error choosing GraphicsConfiguration creating window: "+this);
         }
-        windowHandle = CreateWindow(parentWindowHandle, 
+        windowHandle = CreateWindow0(parentWindowHandle, 
                                     display.getWindowClassAtom(), display.WINDOW_CLASS_NAME, display.getHInstance(), 
                                     0, undecorated, x, y, width, height);
         if (windowHandle == 0) {
             throw new NativeWindowException("Error creating window");
         }
-        this.parentWindowHandle = parentWindowHandle;
         windowHandleClose = windowHandle;
         if(DEBUG_IMPLEMENTATION || DEBUG_WINDOW_EVENT) {
             Exception e = new Exception("!!! Window new window handle "+Thread.currentThread().getName()+
@@ -133,12 +131,12 @@ public class WindowsWindow extends Window {
     protected void closeNative() {
         if (hdc != 0) {
             if(windowHandleClose != 0) {
-                ReleaseDC(windowHandleClose, hdc);
+                ReleaseDC0(windowHandleClose, hdc);
             }
             hdc = 0;
         }
         if(windowHandleClose != 0) {
-            DestroyWindow(windowHandleClose);
+            DestroyWindow0(windowHandleClose);
             windowHandleClose = 0;
         }
     }
@@ -148,23 +146,22 @@ public class WindowsWindow extends Window {
         super.windowDestroyed();
     }
 
-    public void setVisible(boolean visible) {
-        if(this.visible!=visible && 0!=windowHandle) {
-            this.visible=visible;
-            setVisible0(windowHandle, visible);
-        }
+    protected void setVisibleImpl() {
+        setVisible0(windowHandle, visible);
     }
 
     // @Override
     public void setSize(int width, int height) {
         if (width != this.width || this.height != height) {
             if(!fullscreen) {
-                this.width=width;
-                this.height=height;
                 nfs_width=width;
                 nfs_height=height;
                 if(0!=windowHandle) {
+                    // this width/height will be set by sizeChanged, called by Windows
                     setSize0(parentWindowHandle, windowHandle, x, y, width, height);
+                } else {
+                    this.width=width;
+                    this.height=height;
                 }
             }
         }
@@ -174,12 +171,14 @@ public class WindowsWindow extends Window {
     public void setPosition(int x, int y) {
         if ( this.x != x || this.y != y ) {
             if(!fullscreen) {
-                this.x=x;
-                this.y=y;
                 nfs_x=x;
                 nfs_y=y;
                 if(0!=windowHandle) {
+                    // this x/y will be set by positionChanged, called by Windows
                     setPosition0(parentWindowHandle, windowHandle, x , y /*, width, height*/);
+                } else {
+                    this.x=x;
+                    this.y=y;
                 }
             }
         }
@@ -211,7 +210,7 @@ public class WindowsWindow extends Window {
     public void requestFocus() {
         super.requestFocus();
         if (windowHandle != 0L) {
-            requestFocus(windowHandle);
+            requestFocus0(windowHandle);
         }
     }
 
@@ -222,7 +221,7 @@ public class WindowsWindow extends Window {
         }
         if (0!=windowHandle && !title.equals(getTitle())) {
             super.setTitle(title);
-            setTitle(windowHandle, title);
+            setTitle0(windowHandle, title);
         }
     }
 
@@ -233,22 +232,22 @@ public class WindowsWindow extends Window {
     //----------------------------------------------------------------------
     // Internals only
     //
-    protected static native boolean initIDs();
-    private        native long CreateWindow(long parentWindowHandle, 
+    protected static native boolean initIDs0();
+    private        native long CreateWindow0(long parentWindowHandle, 
                                             int wndClassAtom, String wndName, 
                                             long hInstance, long visualID,
                                             boolean isUndecorated,
                                             int x, int y, int width, int height);
-    private        native void DestroyWindow(long windowHandle);
-    private        native long GetDC(long windowHandle);
-    private        native void ReleaseDC(long windowHandle, long hdc);
-    private        native long MonitorFromWindow(long windowHandle);
+    private        native void DestroyWindow0(long windowHandle);
+    private        native long GetDC0(long windowHandle);
+    private        native void ReleaseDC0(long windowHandle, long hdc);
+    private        native long MonitorFromWindow0(long windowHandle);
     private static native void setVisible0(long windowHandle, boolean visible);
     private        native void setSize0(long parentWindowHandle, long windowHandle, int x, int y, int width, int height);
     private static native void setPosition0(long parentWindowHandle, long windowHandle, int x, int y /*, int width, int height*/);
     private        native void setFullscreen0(long parentWindowHandle, long windowHandle, int x, int y, int width, int height, boolean isUndecorated, boolean on);
-    private static native void setTitle(long windowHandle, String title);
-    private static native void requestFocus(long windowHandle);
+    private static native void setTitle0(long windowHandle, String title);
+    private static native void requestFocus0(long windowHandle);
 
     private void insetsChanged(int left, int top, int right, int bottom) {
         if (left != -1 && top != -1 && right != -1 && bottom != -1) {
@@ -258,24 +257,29 @@ public class WindowsWindow extends Window {
             insets.bottom = bottom;
         }
     }
+
     private void sizeChanged(int newWidth, int newHeight) {
-        width = newWidth;
-        height = newHeight;
-        if(!fullscreen) {
-            nfs_width=width;
-            nfs_height=height;
+        if(width != newWidth || height != newHeight) {
+            width = newWidth;
+            height = newHeight;
+            if(!fullscreen) {
+                nfs_width=width;
+                nfs_height=height;
+            }
+            sendWindowEvent(WindowEvent.EVENT_WINDOW_RESIZED);
         }
-        sendWindowEvent(WindowEvent.EVENT_WINDOW_RESIZED);
     }
 
     private void positionChanged(int newX, int newY) {
-        x = newX;
-        y = newY;
-        if(!fullscreen) {
-            nfs_x=x;
-            nfs_y=y;
+        if( 0==parentWindowHandle && ( x != newX || y != newY ) ) {
+            x = newX;
+            y = newY;
+            if(!fullscreen) {
+                nfs_x=x;
+                nfs_y=y;
+            }
+            sendWindowEvent(WindowEvent.EVENT_WINDOW_MOVED);
         }
-        sendWindowEvent(WindowEvent.EVENT_WINDOW_MOVED);
     }
 
     /**
diff --git a/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java b/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java
index c2de0fe18..3b0868620 100755
--- a/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java
+++ b/src/newt/classes/com/jogamp/newt/impl/x11/X11Display.java
@@ -43,11 +43,11 @@ public class X11Display extends Display {
     static {
         NEWTJNILibLoader.loadNEWT();
 
-        if (!initIDs()) {
+        if ( !initIDs0() ) {
             throw new NativeWindowException("Failed to initialize X11Display jmethodIDs");
         }
 
-        if (!X11Window.initIDs()) {
+        if (!X11Window.initIDs0()) {
             throw new NativeWindowException("Failed to initialize X11Window jmethodIDs");
         }
     }
@@ -60,13 +60,24 @@ public class X11Display extends Display {
     public X11Display() {
     }
 
-    protected void createNative() {
-        long handle= X11Util.createThreadLocalDisplay(name);
-        if (handle == 0 ) {
+    protected void createNative(long handle) {
+        if(0 != handle) {
+            // Can't use that Display handle directly,
+            // but we open up a new connection to the same Display by it's name
+            String newName = X11Util.getNameOfDisplay(handle);
+            if(DEBUG) {
+                System.out.println("Changing Display Name (provided handle): "+name+" -> 0x"+
+                    Long.toHexString(handle)+" : "+newName);
+            }
+            handle = 0;
+            name = newName;
+        }
+        handle= X11Util.createThreadLocalDisplay(name);
+        if( 0 == handle ) {
             throw new RuntimeException("Error creating display: "+name);
         }
         try {
-            CompleteDisplay(handle);
+            CompleteDisplay0(handle);
         } catch(RuntimeException e) {
             X11Util.closeThreadLocalDisplay(name);
             throw e;
@@ -82,7 +93,7 @@ public class X11Display extends Display {
         if(0==getHandle()) {
             throw new RuntimeException("display handle null");
         }
-        DispatchMessages(getHandle(), javaObjectAtom, windowDeleteAtom);
+        DispatchMessages0(getHandle(), javaObjectAtom, windowDeleteAtom);
     }
 
     protected void lockDisplay() {
@@ -101,11 +112,11 @@ public class X11Display extends Display {
     //----------------------------------------------------------------------
     // Internals only
     //
-    private static native boolean initIDs();
+    private static native boolean initIDs0();
 
-    private native void CompleteDisplay(long handle);
+    private native void CompleteDisplay0(long handle);
 
-    private native void DispatchMessages(long display, long javaObjectAtom, long windowDeleteAtom);
+    private native void DispatchMessages0(long display, long javaObjectAtom, long windowDeleteAtom);
 
     private void displayCompleted(long javaObjectAtom, long windowDeleteAtom) {
         this.javaObjectAtom=javaObjectAtom;
diff --git a/src/newt/classes/com/jogamp/newt/impl/x11/X11Screen.java b/src/newt/classes/com/jogamp/newt/impl/x11/X11Screen.java
index 3561bec2a..453d8e5e1 100755
--- a/src/newt/classes/com/jogamp/newt/impl/x11/X11Screen.java
+++ b/src/newt/classes/com/jogamp/newt/impl/x11/X11Screen.java
@@ -47,7 +47,7 @@ public class X11Screen extends Screen {
     }
 
     protected void createNative(int index) {
-        long handle = GetScreen(display.getHandle(), index);
+        long handle = GetScreen0(display.getHandle(), index);
         if (handle == 0 ) {
             throw new RuntimeException("Error creating screen: "+index);
         }
@@ -62,7 +62,7 @@ public class X11Screen extends Screen {
     // Internals only
     //
 
-    private native long GetScreen(long dpy, int scrn_idx);
+    private native long GetScreen0(long dpy, int scrn_idx);
     private native int  getWidth0(long display, int scrn_idx);
     private native int  getHeight0(long display, int scrn_idx);
 }
diff --git a/src/newt/classes/com/jogamp/newt/impl/x11/X11Window.java b/src/newt/classes/com/jogamp/newt/impl/x11/X11Window.java
index 4fe9f77ad..085d1cab7 100755
--- a/src/newt/classes/com/jogamp/newt/impl/x11/X11Window.java
+++ b/src/newt/classes/com/jogamp/newt/impl/x11/X11Window.java
@@ -48,7 +48,7 @@ public class X11Window extends Window {
     public X11Window() {
     }
 
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
+    protected void createNativeImpl() {
         X11Screen screen = (X11Screen) getScreen();
         X11Display display = (X11Display) screen.getDisplay();
         config = GraphicsConfigurationFactory.getFactory(display.getGraphicsDevice()).chooseGraphicsConfiguration(caps, null, screen.getGraphicsScreen());
@@ -58,14 +58,13 @@ public class X11Window extends Window {
         attachedToParent = 0 != parentWindowHandle ;
         X11GraphicsConfiguration x11config = (X11GraphicsConfiguration) config;
         long visualID = x11config.getVisualID();
-        long w = CreateWindow(parentWindowHandle, 
+        long w = CreateWindow0(parentWindowHandle, 
                               display.getHandle(), screen.getIndex(), visualID, 
                               display.getJavaObjectAtom(), display.getWindowDeleteAtom(), 
                               x, y, width, height, undecorated());
         if (w == 0 || w!=windowHandle) {
             throw new NativeWindowException("Error creating window: "+w);
         }
-        this.parentWindowHandle = parentWindowHandle;
         windowHandleClose = windowHandle;
         displayHandleClose = display.getHandle();
     }
@@ -73,7 +72,7 @@ public class X11Window extends Window {
     protected void closeNative() {
         if(0!=displayHandleClose && 0!=windowHandleClose && null!=getScreen() ) {
             X11Display display = (X11Display) getScreen().getDisplay();
-            CloseWindow(displayHandleClose, windowHandleClose, display.getJavaObjectAtom());
+            CloseWindow0(displayHandleClose, windowHandleClose, display.getJavaObjectAtom());
             windowHandleClose = 0;
             displayHandleClose = 0;
         }
@@ -85,15 +84,9 @@ public class X11Window extends Window {
         super.windowDestroyed();
     }
 
-    public void setVisible(boolean visible) {
-        if(DEBUG_IMPLEMENTATION) {
-            System.err.println("X11Window setVisible: "+this.x+"/"+this.y+" "+this.width+"x"+this.height+", fs "+fullscreen+", windowHandle "+windowHandle);
-        }
-        if(0!=windowHandle && this.visible!=visible) {
-            this.visible=visible;
-            setVisible0(getDisplayHandle(), windowHandle, visible);
-            clearEventMask();
-        }
+    protected void setVisibleImpl() {
+        setVisible0(getDisplayHandle(), windowHandle, visible);
+        clearEventMask();
     }
 
     public void setSize(int width, int height) {
@@ -102,12 +95,14 @@ public class X11Window extends Window {
         }
         if (width != this.width || this.height != height) {
             if(!fullscreen) {
-                this.width = width;
-                this.height = height;
                 nfs_width=width;
                 nfs_height=height;
                 if(0!=windowHandle) {
+                    // this width/height will be set by windowChanged, called by X11
                     setSize0(getDisplayHandle(), windowHandle, width, height);
+                } else {
+                    this.width = width;
+                    this.height = height;
                 }
             }
         }
@@ -119,12 +114,14 @@ public class X11Window extends Window {
         }
         if ( this.x != x || this.y != y ) {
             if(!fullscreen) {
-                this.x = x;
-                this.y = y;
                 nfs_x=x;
                 nfs_y=y;
                 if(0!=windowHandle) {
+                    // this x/y will be set by windowChanged, called by X11
                     setPosition0(parentWindowHandle, getDisplayHandle(), windowHandle, x, y);
+                } else {
+                    this.x = x;
+                    this.y = y;
                 }
             }
         }
@@ -178,11 +175,11 @@ public class X11Window extends Window {
     // Internals only
     //
 
-    protected static native boolean initIDs();
-    private        native long CreateWindow(long parentWindowHandle, long display, int screen_index, 
+    protected static native boolean initIDs0();
+    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, boolean undecorated);
-    private        native void CloseWindow(long display, long windowHandle, long javaObjectAtom);
+    private        native void CloseWindow0(long display, long windowHandle, long javaObjectAtom);
     private        native void setVisible0(long display, long windowHandle, boolean visible);
     private        native void setSize0(long display, long windowHandle, int width, int height);
     private        native void setPosSizeDecor0(long parentWindowHandle, long display, int screen_index, long windowHandle, 
@@ -235,7 +232,6 @@ public class X11Window extends Window {
 
     private long   windowHandleClose;
     private long   displayHandleClose;
-    private long   parentWindowHandle;
     private boolean attachedToParent;
 
     // non fullscreen dimensions ..
diff --git a/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java b/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
index b47b580ed..b5d55aebd 100644
--- a/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
+++ b/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
@@ -82,49 +82,53 @@ public class GLWindow extends Window implements GLAutoDrawable {
         glwindows=newglw;
     }
 
-    /** Creates a new GLWindow on the local display, screen 0, with a
-        dummy visual ID, and with the default GLCapabilities. */
-    public static GLWindow create() {
-        return create(null, null, false);
+    /** Creates a new GLWindow attaching the given window - not owning the Window. */
+    public static GLWindow create(Window window) {
+        return create(null, window, null, false);
     }
 
-    public static GLWindow create(boolean undecorated) {
-        return create(null, null, undecorated);
+    /** Creates a new GLWindow attaching a new native child Window of the given <code>parentWindowObject</code>
+        with the given GLCapabilities - owning the Window */
+    public static GLWindow create(Object parentWindowObject, GLCapabilities caps) {
+        return create(parentWindowObject, null, caps, true);
     }
 
-    /** Creates a new GLWindow referring to the given window. */
-    public static GLWindow create(Window window) {
-        return create(window, null, false);
-    }
+    /** Creates a new GLWindow attaching a new decorated Window on the local display, screen 0, with a
+        dummy visual ID and given GLCapabilities - owning the window */
     public static GLWindow create(GLCapabilities caps) {
-        return create(null, caps, false);
+        return create(null, null, caps, false);
     }
 
-    /** Creates a new GLWindow on the local display, screen 0, with a
-        dummy visual ID, and with the given GLCapabilities. */
+    /** Creates a new GLWindow attaching a new Window on the local display, screen 0, with a
+        dummy visual ID and given GLCapabilities - owning the window */
     public static GLWindow create(GLCapabilities caps, boolean undecorated) {
-        return create(null, caps, undecorated);
+        return create(null, null, caps, undecorated);
     }
 
     /** Either or: window (prio), or caps and undecorated (2nd choice) */
-    private static GLWindow create(Window window, 
+    private static GLWindow create(Object parentWindowObject, Window window, 
                                    GLCapabilities caps,
                                    boolean undecorated) {
-        Display display;
         boolean ownerOfWinScrDpy=false;
         if (window == null) {
             if (caps == null) {
                 caps = new GLCapabilities(null); // default ..
             }
             ownerOfWinScrDpy = true;
-            display = NewtFactory.createDisplay(null); // local display
-            Screen screen  = NewtFactory.createScreen(display, 0); // screen 0
-            window = NewtFactory.createWindow(screen, caps, undecorated);
+            window = NewtFactory.createWindow(parentWindowObject, caps, undecorated);
         }
 
         return new GLWindow(window, ownerOfWinScrDpy);
     }
     
+    public boolean isDestroyed() {
+        return null == window ;
+    }
+
+    public Window getWindow() {
+        return window;
+    }
+
     /** 
      * EXPERIMENTAL<br> 
      * Enable or disables running the {@link Display#pumpMessages} in the {@link #display()} call.<br>
@@ -150,7 +154,7 @@ public class GLWindow extends Window implements GLAutoDrawable {
         runPumpMessages = onoff;
     }
 
-    protected void createNative(long parentWindowHandle, Capabilities caps) {
+    protected void createNativeImpl() {
         shouldNotCallThis();
     }
 
@@ -204,11 +208,6 @@ public class GLWindow extends Window implements GLAutoDrawable {
 
     /** @param sendDisposeEvent should be false in a [time,reliable] critical shutdown */
     public synchronized void destroy(boolean sendDisposeEvent) {
-        if(Window.DEBUG_WINDOW_EVENT || window.DEBUG_IMPLEMENTATION) {
-            Exception e1 = new Exception("GLWindow.destroy "+Thread.currentThread()+", 1: "+this);
-            e1.printStackTrace();
-        }
-
         List newglw = (List) ((ArrayList) glwindows).clone();
         newglw.remove(this);
         glwindows=newglw;
@@ -224,10 +223,6 @@ public class GLWindow extends Window implements GLAutoDrawable {
         drawable = null;
         context = null;
         window = null;
-
-        if(Window.DEBUG_WINDOW_EVENT || window.DEBUG_IMPLEMENTATION) {
-            System.out.println("GLWindow.destroy "+Thread.currentThread()+", fin: "+this);
-        }
     }
 
     public boolean getPerfLogEnabled() { return perfLog; }
@@ -236,13 +231,13 @@ public class GLWindow extends Window implements GLAutoDrawable {
         perfLog = v;
     }
 
-    public void setVisible(boolean visible) {
-        if(Window.DEBUG_WINDOW_EVENT || window.DEBUG_IMPLEMENTATION) {
-            System.out.println(Thread.currentThread()+" GLWindow.setVisible("+visible+") START ; isVisible "+this.visible+" ; has context "+(null!=context));
-        }
-        this.visible=visible;
+    protected void setVisibleImpl() {
+        shouldNotCallThis();
+    }
+
+    public void setVisible(final boolean visible) {
         window.setVisible(visible);
-        if (visible && context == null) {
+        if (visible && null == context && 0 != window.getWindowHandle()) {
             NativeWindow nw;
             if (window.getWrappedWindow() != null) {
                 nw = NativeWindowFactory.getNativeWindow(window.getWrappedWindow(), window.getGraphicsConfiguration());
@@ -256,9 +251,6 @@ public class GLWindow extends Window implements GLAutoDrawable {
             context = drawable.createContext(null);
             sendReshape = true; // ensure a reshape event is send ..
         }
-        if(Window.DEBUG_WINDOW_EVENT || window.DEBUG_IMPLEMENTATION) {
-            System.out.println(Thread.currentThread()+" GLWindow.setVisible("+visible+") END  ; has context "+(null!=context));
-        }
     }
 
     public Screen getScreen() {
@@ -438,7 +430,14 @@ public class GLWindow extends Window implements GLAutoDrawable {
     }
 
     public void display(boolean forceReshape) {
-        if(window!=null && drawable!=null && context != null) {
+        if( null == window ) { return; }
+
+        if( null == context && window.isVisible() ) {
+            // retry native window and drawable/context creation 
+            setVisible(true);
+        }
+
+        if( null != context ) {
             if(runPumpMessages) {
                 window.getScreen().getDisplay().pumpMessages();
             }
@@ -448,7 +447,7 @@ public class GLWindow extends Window implements GLAutoDrawable {
             if (sendDestroy) {
                 destroy();
                 sendDestroy=false;
-            } else {
+            } else if ( window.isVisible() ) {
                 if(forceReshape) {
                     sendReshape = true;
                 }
@@ -553,13 +552,9 @@ public class GLWindow extends Window implements GLAutoDrawable {
     private SwapBuffersAction swapBuffersAction = new SwapBuffersAction();
 
     //----------------------------------------------------------------------
-    // GLDrawable methods
+    // NativeWindow/Window methods
     //
 
-    public NativeWindow getNativeWindow() {
-        return null!=drawable ? drawable.getNativeWindow() : null;
-    }
-
     public synchronized int lockSurface() throws NativeWindowException {
         if(null!=drawable) return drawable.getNativeWindow().lockSurface();
         return NativeWindow.LOCK_SURFACE_NOT_READY;
@@ -587,12 +582,25 @@ public class GLWindow extends Window implements GLAutoDrawable {
 
     public long getWindowHandle() {
         if(null!=drawable) return drawable.getNativeWindow().getWindowHandle();
-        return super.getWindowHandle();
+        return window.getWindowHandle();
     }
 
     public long getSurfaceHandle() {
         if(null!=drawable) return drawable.getNativeWindow().getSurfaceHandle();
-        return super.getSurfaceHandle();
+        return window.getSurfaceHandle();
+    }
+
+    public AbstractGraphicsConfiguration getGraphicsConfiguration() {
+        if(null!=drawable) return drawable.getNativeWindow().getGraphicsConfiguration();
+        return window.getGraphicsConfiguration();
+    }
+
+    //----------------------------------------------------------------------
+    // GLDrawable methods
+    //
+
+    public NativeWindow getNativeWindow() {
+        return null!=drawable ? drawable.getNativeWindow() : null;
     }
 
     //----------------------------------------------------------------------
diff --git a/src/newt/classes/com/jogamp/newt/util/EDTUtil.java b/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
index 2550eef82..e6af747c8 100644
--- a/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
+++ b/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
@@ -123,11 +123,17 @@ public class EDTUtil {
     }
 
     public void invokeAndWait(Runnable task) {
+        invoke(false, task);
+    }
+
+    public void invoke(boolean deferred, Runnable task) {
         if(task == null) {
             return;
         }
         invokeLater(task);
-        waitOnWorker();
+        if(!deferred) {
+            waitOnWorker();
+        }
     }
 
     public void waitOnWorker() {