Newt: Add generic NativeWindow parenting, inclusive using an AWT Component as a parent

6 files changed, 629 insertions, 50 deletions

diff --git a/src/junit/com/jogamp/test/junit/jogl/demos/gl2/gears/TestGearsNewtAWTWrapper.java b/src/junit/com/jogamp/test/junit/jogl/demos/gl2/gears/TestGearsNewtAWTWrapper.java
new file mode 100755
index 000000000..fb25ae399
--- /dev/null
+++ b/src/junit/com/jogamp/test/junit/jogl/demos/gl2/gears/TestGearsNewtAWTWrapper.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.test.junit.jogl.demos.gl2.gears;
+
+import javax.media.nativewindow.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.Animator;
+
+import com.jogamp.test.junit.jogl.demos.gl2.gears.Gears;
+import com.jogamp.newt.*;
+import com.jogamp.newt.event.*;
+import com.jogamp.newt.opengl.*;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.AfterClass;
+import org.junit.After;
+import org.junit.Test;
+
+public class TestGearsNewtAWTWrapper {
+    static GLProfile glp;
+    static int width, height;
+
+    @BeforeClass
+    public static void initClass() {
+        glp = GLProfile.getDefault();
+        Assert.assertNotNull(glp);
+        width  = 512;
+        height = 512;
+    }
+
+    @AfterClass
+    public static void releaseClass() {
+    }
+
+    protected void runTestGL(GLCapabilities caps) throws InterruptedException {
+        Display nDisplay = NewtFactory.createDisplay(NativeWindowFactory.TYPE_AWT, null); // local display
+        Screen nScreen  = NewtFactory.createScreen(NativeWindowFactory.TYPE_AWT, nDisplay, 0); // screen 0
+        Window nWindow = NewtFactory.createWindow(NativeWindowFactory.TYPE_AWT, nScreen, caps);
+
+        GLWindow glWindow = GLWindow.create(nWindow);
+        Assert.assertNotNull(glWindow);
+        glWindow.setTitle("Gears NewtAWTWrapper Test");
+
+        glWindow.addGLEventListener(new Gears());
+
+        Animator animator = new Animator(glWindow);
+        QuitAdapter quitAdapter = new QuitAdapter();
+
+        glWindow.addKeyListener(new TraceKeyAdapter(quitAdapter));
+        glWindow.addWindowListener(new TraceWindowAdapter(quitAdapter));
+
+        glWindow.setSize(width, height);
+        glWindow.setVisible(true);
+        animator.start();
+
+        while(!quitAdapter.shouldQuit() && animator.isAnimating() && animator.getDuration()<duration) {
+            Thread.sleep(100);
+        }
+
+        animator.stop();
+        glWindow.destroy(true);
+    }
+
+    @Test
+    public void test01() throws InterruptedException {
+        GLCapabilities caps = new GLCapabilities(GLProfile.getDefault());
+        runTestGL(caps);
+    }
+
+    static long duration = 500; // ms
+
+    public static void main(String args[]) {
+        for(int i=0; i<args.length; i++) {
+            if(args[i].equals("-time")) {
+                i++;
+                try {
+                    duration = Integer.parseInt(args[i]);
+                } catch (Exception ex) { ex.printStackTrace(); }
+            }
+        }
+        org.junit.runner.JUnitCore.main(TestGearsNewtAWTWrapper.class.getName());
+    }
+}
diff --git a/src/junit/com/jogamp/test/junit/newt/TestParenting01AWT.java b/src/junit/com/jogamp/test/junit/newt/TestParenting01AWT.java
new file mode 100755
index 000000000..4c21684d3
--- /dev/null
+++ b/src/junit/com/jogamp/test/junit/newt/TestParenting01AWT.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.test.junit.newt;
+
+import java.lang.reflect.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Test;
+
+import java.awt.Button;
+import java.awt.BorderLayout;
+import java.awt.Canvas;
+import java.awt.Component;
+import java.awt.Frame;
+
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+
+import com.jogamp.newt.*;
+import com.jogamp.newt.event.*;
+import com.jogamp.newt.opengl.*;
+
+import java.io.IOException;
+
+import com.jogamp.test.junit.util.*;
+import com.jogamp.test.junit.jogl.demos.es1.RedSquare;
+import com.jogamp.test.junit.jogl.demos.gl2.gears.Gears;
+
+public class TestParenting01AWT {
+    static int width, height;
+    static long durationPerTest = 500;
+
+    @BeforeClass
+    public static void initClass() {
+        width  = 640;
+        height = 480;
+    }
+
+    static void destroyWindow(Display display, Screen screen, Window window, GLWindow glWindow) {
+        if(null!=glWindow) {
+            glWindow.destroy();
+        }
+        if(null!=window) {
+            window.destroy();
+        }
+        if(null!=screen) {
+            screen.destroy();
+        }
+        if(null!=display) {
+            display.destroy();
+        }
+    }
+
+    @Test
+    public void testWindowParenting01NewtChildOnAWTParentLayouted() throws InterruptedException {
+        runNewtChildOnAWTParent(true);
+    }
+
+    @Test
+    public void testWindowParenting02NewtChildOnAWTParentDirect() throws InterruptedException {
+        runNewtChildOnAWTParent(false);
+    }
+
+    public void runNewtChildOnAWTParent(boolean useLayout) throws InterruptedException {
+        Frame frame = new Frame("AWT Parent Frame");
+        Assert.assertNotNull(frame);
+        Component overlayedAWTComponent = null;
+
+        if(useLayout) {
+            overlayedAWTComponent = new Canvas();
+
+            frame.setLayout(new BorderLayout());
+            frame.add(new Button("North"), BorderLayout.NORTH);
+            frame.add(new Button("South"), BorderLayout.SOUTH);
+            frame.add(new Button("East"), BorderLayout.EAST);
+            frame.add(new Button("West"), BorderLayout.WEST);
+            frame.add(overlayedAWTComponent, BorderLayout.CENTER);
+
+        } else {
+            overlayedAWTComponent = frame;
+        }
+
+        Assert.assertNotNull(overlayedAWTComponent);
+        frame.setSize(width, height);
+        frame.setVisible(true); // should have native peers after this!
+
+        GLCapabilities caps = new GLCapabilities(null);
+        Assert.assertNotNull(caps);
+        Display display = NewtFactory.createDisplay(null); // local display
+        Assert.assertNotNull(display);
+        System.out.println("Display: "+display);
+        Screen screen  = NewtFactory.createScreen(display, 0); // screen 0
+        Assert.assertNotNull(screen);
+
+        final NEWTEventFiFo eventFifo = new NEWTEventFiFo();
+
+        Window window2 = NewtFactory.createWindow(overlayedAWTComponent, screen, caps);
+        Assert.assertNotNull(window2);
+
+        GLWindow glWindow2 = GLWindow.create(window2);
+        Assert.assertNotNull(glWindow2);
+
+        glWindow2.setSize(width, height);
+        Assert.assertTrue(false==glWindow2.isVisible());
+        Assert.assertTrue(width==glWindow2.getWidth());
+        Assert.assertTrue(height==glWindow2.getHeight());
+
+        glWindow2.setTitle("NEWT - CHILD");
+        glWindow2.addKeyListener(new TraceKeyAdapter(new KeyAction(eventFifo)));
+        glWindow2.addWindowListener(new TraceWindowAdapter(new WindowAdapter() {
+                    public void windowDestroyNotify(WindowEvent e) {
+                        eventFifo.put(e);
+                    }
+                }));
+
+        GLEventListener demo2 = new Gears();
+        setDemoFields(demo2, window2, glWindow2, false);
+        glWindow2.addGLEventListener(demo2);
+
+        glWindow2.setVisible(true);
+        glWindow2.display();
+
+        long duration = durationPerTest;
+        long step = 20;
+        NEWTEvent event;
+        boolean shouldQuit = false;
+
+        while (duration>0 && !shouldQuit) {
+            glWindow2.display();
+            Thread.sleep(step);
+            duration -= step;
+
+            while( null != ( event = (NEWTEvent) eventFifo.get() ) ) {
+                Window source = (Window) event.getSource();
+                if(WindowEvent.EVENT_WINDOW_DESTROY_NOTIFY == event.getEventType()) {
+                    shouldQuit = true;
+                } else if(event instanceof KeyEvent) {
+                    KeyEvent keyEvent = (KeyEvent) event;
+                    switch(keyEvent.getKeyChar()) {
+                        case 'q':
+                            shouldQuit = true;
+                            break;
+                        case 'f':
+                            source.setFullscreen(!source.isFullscreen());
+                            break;
+                    }
+                } 
+            }
+        }
+        destroyWindow(null, null, window2, glWindow2);
+        frame.dispose();
+    }
+
+    public static void setDemoFields(GLEventListener demo, Window window, GLWindow glWindow, boolean debug) {
+        Assert.assertNotNull(demo);
+        Assert.assertNotNull(window);
+        if(debug) {
+            MiscUtils.setFieldIfExists(demo, "glDebug", true);
+            MiscUtils.setFieldIfExists(demo, "glTrace", true);
+        }
+        if(!MiscUtils.setFieldIfExists(demo, "window", window)) {
+            MiscUtils.setFieldIfExists(demo, "glWindow", glWindow);
+        }
+    }
+
+    public static void main(String args[]) throws IOException {
+        durationPerTest = 5000;
+        String tstname = TestParenting01AWT.class.getName();
+        org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner.main(new String[] {
+            tstname,
+            "filtertrace=true",
+            "haltOnError=false",
+            "haltOnFailure=false",
+            "showoutput=true",
+            "outputtoformatters=true",
+            "logfailedtests=true",
+            "logtestlistenerevents=true",
+            "formatter=org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter",
+            "formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,TEST-"+tstname+".xml" } );
+    }
+
+}
diff --git a/src/junit/com/jogamp/test/junit/newt/TestParenting01NEWT.java b/src/junit/com/jogamp/test/junit/newt/TestParenting01NEWT.java
index 128c4358d..9528009ea 100755
--- a/src/junit/com/jogamp/test/junit/newt/TestParenting01NEWT.java
+++ b/src/junit/com/jogamp/test/junit/newt/TestParenting01NEWT.java
@@ -68,26 +68,18 @@ public class TestParenting01NEWT {
         height = 480;
     }
 
-    static Window createWindow(NativeWindow parent, Screen screen, Capabilities caps, int width, int height, boolean onscreen, boolean undecorated) {
+    static Window createWindow(NativeWindow parent, Screen screen, Capabilities caps, int width, int height) {
         Assert.assertNotNull(caps);
-        caps.setOnscreen(onscreen);
-        // System.out.println("Requested: "+caps);
-
         //
         // Create native windowing resources .. X11/Win/OSX
         // 
         Window window;
-        if(null==parent) {
-            window = NewtFactory.createWindow(screen, caps, onscreen && undecorated);
-        } else {
-            window = NewtFactory.createWindow(parent.getWindowHandle(), screen, caps, onscreen && undecorated);
-        }
+        window = ( null == parent ) ? NewtFactory.createWindow(screen, caps) : NewtFactory.createWindow(parent, screen, caps) ;
         Assert.assertNotNull(window);
         window.setSize(width, height);
         Assert.assertTrue(false==window.isVisible());
         Assert.assertTrue(width==window.getWidth());
         Assert.assertTrue(height==window.getHeight());
-        System.out.println("Created: "+window);
 
         //
         // Create native OpenGL resources .. XGL/WGL/CGL .. 
@@ -98,7 +90,7 @@ public class TestParenting01NEWT {
         Assert.assertTrue(caps.getGreenBits()>5);
         Assert.assertTrue(caps.getBlueBits()>5);
         Assert.assertTrue(caps.getRedBits()>5);
-        Assert.assertTrue(caps.isOnscreen()==onscreen);
+        Assert.assertTrue(caps.isOnscreen()==true);
 
         return window;
     }
@@ -130,28 +122,34 @@ public class TestParenting01NEWT {
         int x = 1;
         int y = 1;
 
-        NEWTEventFiFo eventFifo = new NEWTEventFiFo();
+        final NEWTEventFiFo eventFifo = new NEWTEventFiFo();
 
-        Window window1 = createWindow(   null, screen, caps, width, height, true /* onscreen */, false /* undecorated */);
+        Window window1 = createWindow( null, screen, caps, width, height );
         Assert.assertNotNull(window1);
-        window1.setTitle("testWindowParenting01NewtOnNewtParentChildDraw - PARENT");
-        window1.setPosition(x,y);
-        window1.addKeyListener(new TraceKeyAdapter(new KeyAction(eventFifo)));
         GLWindow glWindow1 = GLWindow.create(window1);
         Assert.assertNotNull(glWindow1);
-
-        Window window2 = createWindow(window1, screen, caps, width/2, height/2, true /* onscreen */, false /* undecorated */);
+        Assert.assertTrue(width==glWindow1.getWidth());
+        Assert.assertTrue(height==glWindow1.getHeight());
+        glWindow1.setTitle("testWindowParenting01NewtOnNewtParentChildDraw - PARENT");
+        glWindow1.setPosition(x,y);
+        glWindow1.addKeyListener(new TraceKeyAdapter(new KeyAction(eventFifo)));
+        glWindow1.addWindowListener(new TraceWindowAdapter());
+
+        Window window2 = createWindow(window1, screen, caps, width/2, height/2);
         Assert.assertNotNull(window2);
-        window2.setTitle("testWindowParenting01NewtOnNewtParentChildDraw - CHILD");
-        System.out.println("Window1: "+window1);
-        Assert.assertTrue(width==window1.getWidth());
-        Assert.assertTrue(height==window1.getHeight());
-        window2.setPosition(window1.getWidth()/2, window1.getHeight()/2);
-        window2.addKeyListener(new TraceKeyAdapter(new KeyAction(eventFifo)));
-        // window2.addMouseListener(new TraceMouseAdapter());
-        window2.requestFocus();
         GLWindow glWindow2 = GLWindow.create(window2);
         Assert.assertNotNull(glWindow2);
+        Assert.assertTrue(width/2==glWindow2.getWidth());
+        Assert.assertTrue(height/2==glWindow2.getHeight());
+        glWindow2.setTitle("testWindowParenting01NewtOnNewtParentChildDraw - CHILD");
+        glWindow2.setPosition(glWindow1.getWidth()/2, glWindow1.getHeight()/2);
+        glWindow2.addKeyListener(new TraceKeyAdapter(new KeyAction(eventFifo)));
+        glWindow2.addWindowListener(new TraceWindowAdapter(new WindowAdapter() {
+                    public void windowDestroyNotify(WindowEvent e) {
+                        eventFifo.put(e);
+                    }
+                }));
+        // glWindow2.addMouseListener(new TraceMouseAdapter());
 
         GLEventListener demo1 = new RedSquare();
         setDemoFields(demo1, window1, glWindow1, false);
@@ -161,8 +159,8 @@ public class TestParenting01NEWT {
         setDemoFields(demo2, window2, glWindow2, false);
         glWindow2.addGLEventListener(demo2);
 
-        window2.setVisible(true);
-        window1.setVisible(true);
+        glWindow2.setVisible(true);
+        glWindow1.setVisible(true);
 
         glWindow2.setVisible(true);
         glWindow1.setVisible(true);
@@ -170,34 +168,37 @@ public class TestParenting01NEWT {
         glWindow2.display();
         glWindow1.display();
 
+        boolean shouldQuit = false;
         long duration = durationPerTest;
         long step = 20;
-        KeyEvent keyEvent;
-        boolean shouldQuit = false;
+        NEWTEvent event;
 
         while (duration>0 && !shouldQuit) {
-            while( null != ( keyEvent = (KeyEvent) eventFifo.get() ) ) {
-                Window source = (Window) keyEvent.getSource();
-                switch(keyEvent.getKeyChar()) {
-                    case 'q':
-                        System.out.println(keyEvent);
-                        shouldQuit = true;
-                        break;
-                    case 'f':
-                        System.out.println(keyEvent);
-                        source.setFullscreen(!source.isFullscreen());
-                        break;
-                }
-            }
-            
             glWindow1.display();
             glWindow2.display();
-            Thread.sleep(step); // 1000 ms
+            Thread.sleep(step);
             duration -= step;
             x += 1;
             y += 1;
-            window1.setPosition(x,y);
-            window2.setPosition(window1.getWidth()/2,window1.getHeight()/2-y);
+            glWindow1.setPosition(x,y);
+            glWindow2.setPosition(glWindow1.getWidth()/2,glWindow1.getHeight()/2-y);
+
+            while( null != ( event = (NEWTEvent) eventFifo.get() ) ) {
+                Window source = (Window) event.getSource();
+                if(WindowEvent.EVENT_WINDOW_DESTROY_NOTIFY == event.getEventType()) {
+                    shouldQuit = true;
+                } else if(event instanceof KeyEvent) {
+                    KeyEvent keyEvent = (KeyEvent) event;
+                    switch(keyEvent.getKeyChar()) {
+                        case 'q':
+                            shouldQuit = true;
+                            break;
+                        case 'f':
+                            source.setFullscreen(!source.isFullscreen());
+                            break;
+                    }
+                } 
+            }
         }
         destroyWindow(null, null, window2, glWindow2);
         destroyWindow(display, screen, window1, glWindow1);
diff --git a/src/newt/classes/com/jogamp/newt/NewtFactory.java b/src/newt/classes/com/jogamp/newt/NewtFactory.java
index 2d5c10c52..531d686b2 100755
--- a/src/newt/classes/com/jogamp/newt/NewtFactory.java
+++ b/src/newt/classes/com/jogamp/newt/NewtFactory.java
@@ -33,10 +33,13 @@
 
 package com.jogamp.newt;
 
+import com.jogamp.common.util.ReflectionUtil;
 import javax.media.nativewindow.*;
 import java.util.ArrayList;
 import java.util.Iterator;
 import com.jogamp.common.jvm.JVMUtil;
+import com.jogamp.newt.event.WindowAdapter;
+import com.jogamp.newt.event.WindowEvent;
 
 public abstract class NewtFactory {
     // Work-around for initialization order problems on Mac OS X
@@ -100,18 +103,87 @@ public abstract class NewtFactory {
     }
 
     /**
-     * Create a Window entity, incl native creation
+     * 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);
     }
 
+    /**
+     * 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);
     }
 
-    public static Window createWindow(long parentWindowHandle, Screen screen, Capabilities caps, boolean undecorated) {
-        return Window.create(NativeWindowFactory.getNativeWindowType(true), parentWindowHandle, screen, caps, undecorated);
+    /**
+     * Create a child Window entity attached to the given parent, incl native creation<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, com.jogamp.newt.Capabilities)}, 
+     * passing the parent's native window handle retrieved via {@link javax.media.nativewindow.NativeWindow#getWindowHandle()}.<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>
+     * 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)}
+     * 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>
+     *
+     * @param parentWindowObject either a NativeWindow or java.awt.Component 
+     *
+     * @see com.jogamp.newt.NewtFactory#createWindow(long, com.jogamp.newt.Screen, com.jogamp.newt.Capabilities)
+     * @see com.jogamp.newt.impl.awt.AWTNewtFactory#createNativeChildWindow(Object, com.jogamp.newt.Screen, com.jogamp.newt.Capabilities)
+     */
+    public static Window createWindow(Object parentWindowObject, Screen screen, Capabilities caps) {
+        if(null==parentWindowObject) {
+            throw new RuntimeException("Null parentWindowObject");
+        }
+        if(parentWindowObject instanceof NativeWindow) {
+            NativeWindow nativeParentWindow = (NativeWindow) parentWindowObject;
+            nativeParentWindow.lockSurface();
+            long parentWindowHandle = nativeParentWindow.getWindowHandle();
+            nativeParentWindow.unlockSurface();
+            final Window win = createWindow(parentWindowHandle, screen, caps);
+            if ( nativeParentWindow instanceof Window) {
+                final Window f_nativeParentWindow = (Window) nativeParentWindow ;
+                f_nativeParentWindow.addWindowListener(new WindowAdapter() {
+                    public void windowDestroyNotify(WindowEvent e) {
+                        win.sendEvent(e);
+                    }
+                });
+            }
+            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 },
+                                                                    new Object[] { parentWindowObject, screen, caps } );
+                }
+            }
+        }
+        throw new RuntimeException("No NEWT child Window factory method for parent object: "+parentWindowObject);
+    }
+
+    /**
+     * Create a child Window entity attached to the given parent, incl native creation<br>
+     *
+     * @param parentWindowObject the native parent window handle
+     */
+    public static Window createWindow(long parentWindowHandle, Screen screen, Capabilities caps) {
+        if(0==parentWindowHandle) {
+            throw new RuntimeException("Null parentWindowHandle");
+        }
+        return Window.create(NativeWindowFactory.getNativeWindowType(true), parentWindowHandle, screen, caps, true);
     }
 
     /**
diff --git a/src/newt/classes/com/jogamp/newt/event/awt/AWTParentWindowAdapter.java b/src/newt/classes/com/jogamp/newt/event/awt/AWTParentWindowAdapter.java
new file mode 100644
index 000000000..49d9bf0f2
--- /dev/null
+++ b/src/newt/classes/com/jogamp/newt/event/awt/AWTParentWindowAdapter.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+package com.jogamp.newt.event.awt;
+
+/**
+ * Specialized parent/client adapter,
+ * where the NEWT child window really gets resized,
+ * and the parent move window event gets discarded. */
+public class AWTParentWindowAdapter extends AWTWindowAdapter
+{
+    public AWTParentWindowAdapter(com.jogamp.newt.Window downstream) {
+        super(downstream);
+    }
+
+    public void componentResized(java.awt.event.ComponentEvent e) {
+        // need to really resize the NEWT child window
+        java.awt.Component comp = e.getComponent();
+        newtWindow.setSize(comp.getWidth(), comp.getHeight());
+    }
+
+    public void componentMoved(java.awt.event.ComponentEvent e) {
+        // no propagation to NEWT child window
+    }
+
+    public void windowActivated(java.awt.event.WindowEvent e) {
+        // no propagation to NEWT child window ?? FIXME: Maybe yes in case of a 100% Opaque one ?
+    }
+
+    public void windowDeactivated(java.awt.event.WindowEvent e) {
+        // no propagation to NEWT child window ?? FIXME: Maybe yes in case of a 100% Opaque one ?
+    }
+}
+
diff --git a/src/newt/classes/com/jogamp/newt/impl/awt/AWTNewtFactory.java b/src/newt/classes/com/jogamp/newt/impl/awt/AWTNewtFactory.java
new file mode 100644
index 000000000..f3296d9d5
--- /dev/null
+++ b/src/newt/classes/com/jogamp/newt/impl/awt/AWTNewtFactory.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.newt.impl.awt;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.Component;
+import java.awt.Canvas;
+
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+import javax.media.nativewindow.awt.*;
+
+import com.jogamp.newt.event.awt.AWTParentWindowAdapter;
+import com.jogamp.newt.Screen;
+import com.jogamp.newt.Window;
+import com.jogamp.newt.NewtFactory;
+
+public class AWTNewtFactory {
+
+  /**
+   * Wraps an AWT component into a {@link javax.media.nativewindow.NativeWindow} utilizing the {@link javax.media.nativewindow.NativeWindowFactory},<br>
+   * using a configuration agnostic dummy {@link javax.media.nativewindow.DefaultGraphicsConfiguration}.<br>
+   * <p>
+   * The actual wrapping implementation is {@link com.jogamp.nativewindow.impl.jawt.JAWTWindow}.<br></p>
+   * <p>
+   * Purpose of this wrapping is to access the AWT window handle,<br>
+   * not to actually render into it.<br>
+   * Hence the dummy configuration only.</p>
+   *
+   * @param awtCompObject must be of type java.awt.Component
+   */
+  public static NativeWindow getNativeWindow(Object awtCompObject) {
+      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 awtNative;
+  }
+
+  /**
+   * Creates a native NEWT child window to a AWT parent window.<br>
+   * <p>
+   * First we create a {@link javax.media.nativewindow.NativeWindow} presentation of the given {@link java.awt.Component},
+   * utilizing {@link #getNativeWindow(java.awt.Component)}.<br>
+   * 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, com.jogamp.newt.Capabilities)}, passing the AWT parent's native window handle retrieved via {@link com.jogamp.nativewindow.impl.jawt.JAWTWindow#getWindowHandle()}.<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>
+   *
+   * @param awtParentObject must be of type java.awt.Component
+   */ 
+  public static Window createNativeChildWindow(Object awtParentObject, Screen newtScreen, Capabilities newtCaps) {
+      NativeWindow parent = getNativeWindow(awtParentObject); // also checks java.awt.Component type
+      java.awt.Component awtParent = (java.awt.Component) awtParentObject;
+      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);
+      new AWTParentWindowAdapter(window).addTo(awtParent);
+      return window;
+  }
+}
+