Merge branch 'master' of github.com:sgothel/jogl

18 files changed, 2280 insertions, 0 deletions

diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/Debug.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/Debug.java
new file mode 100644
index 000000000..edb682392
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/Debug.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.nativewindow.impl;
+
+import java.security.*;
+
+/** Helper routines for logging and debugging. */
+
+public class Debug {
+  // Some common properties
+  private static boolean verbose;
+  private static boolean debugAll;
+  private static AccessControlContext localACC;
+  
+  static {
+    localACC=AccessController.getContext();
+    verbose = isPropertyDefined("nativewindow.verbose", true);
+    debugAll = isPropertyDefined("nativewindow.debug", true);
+    if (verbose) {
+       Package p = Package.getPackage("javax.media.nativewindow");
+       System.err.println("NativeWindow specification version " + p.getSpecificationVersion());
+       System.err.println("NativeWindow implementation version " + p.getImplementationVersion());
+       System.err.println("NativeWindow implementation vendor " + p.getImplementationVendor());
+    }
+  }
+
+  static int getIntProperty(final String property, final boolean jnlpAlias) {
+      return getIntProperty(property, jnlpAlias, localACC);
+  }
+
+  public static int getIntProperty(final String property, final boolean jnlpAlias, final AccessControlContext acc) {
+    int i=0;
+    try {
+        Integer iv = Integer.valueOf(Debug.getProperty(property, jnlpAlias, acc));
+        i = iv.intValue();
+    } catch (NumberFormatException nfe) {}
+    return i;
+  }
+
+  static boolean getBooleanProperty(final String property, final boolean jnlpAlias) {
+    return getBooleanProperty(property, jnlpAlias, localACC);
+  }
+
+  public static boolean getBooleanProperty(final String property, final boolean jnlpAlias, final AccessControlContext acc) {
+    Boolean b = Boolean.valueOf(Debug.getProperty(property, jnlpAlias, acc));
+    return b.booleanValue();
+  }
+
+  static boolean isPropertyDefined(final String property, final boolean jnlpAlias) {
+    return isPropertyDefined(property, jnlpAlias, localACC);
+  }
+
+  public static boolean isPropertyDefined(final String property, final boolean jnlpAlias, final AccessControlContext acc) {
+    return (Debug.getProperty(property, jnlpAlias, acc) != null) ? true : false;
+  }
+
+  static String getProperty(final String property, final boolean jnlpAlias) {
+    return getProperty(property, jnlpAlias, localACC);
+  }
+
+  public static String getProperty(final String property, final boolean jnlpAlias, final AccessControlContext acc) {
+    String s=null;
+    if(null!=acc && acc.equals(localACC)) {
+        s = (String) AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+              String val=null;
+              try {
+                  val = System.getProperty(property);
+              } catch (Exception e) {}
+              if(null==val && jnlpAlias && !property.startsWith(jnlp_prefix)) {
+                  try {
+                      val = System.getProperty(jnlp_prefix + property);
+                  } catch (Exception e) {}
+              }
+              return val;
+            }
+          });
+    } else {
+        try {
+            s = System.getProperty(property);
+        } catch (Exception e) {}
+        if(null==s && jnlpAlias && !property.startsWith(jnlp_prefix)) {
+            try {
+                s = System.getProperty(jnlp_prefix + property);
+            } catch (Exception e) {}
+        }
+    }
+    return s;
+  }
+  public static final String jnlp_prefix = "jnlp." ;
+
+  public static boolean verbose() {
+    return verbose;
+  }
+
+  public static boolean debugAll() {
+    return debugAll;
+  }
+
+  public static boolean debug(String subcomponent) {
+    return debugAll() || isPropertyDefined("nativewindow.debug." + subcomponent, true);
+  }
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/GraphicsConfigurationFactoryImpl.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/GraphicsConfigurationFactoryImpl.java
new file mode 100644
index 000000000..22f2d544f
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/GraphicsConfigurationFactoryImpl.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.nativewindow.impl;
+
+import javax.media.nativewindow.*;
+
+public class GraphicsConfigurationFactoryImpl extends GraphicsConfigurationFactory {
+    public AbstractGraphicsConfiguration chooseGraphicsConfiguration(Capabilities capabilities,
+                                                                     CapabilitiesChooser chooser,
+                                                                     AbstractGraphicsScreen screen) {
+        return new DefaultGraphicsConfiguration(screen, capabilities, capabilities);
+    }
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/InternalBufferUtil.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/InternalBufferUtil.java
new file mode 100644
index 000000000..f590e9b8b
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/InternalBufferUtil.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ */
+
+package com.jogamp.nativewindow.impl;
+
+import java.lang.reflect.*;
+import java.nio.*;
+
+/** Internal copy of selected routines from BufferUtil to avoid
+    outward dependencies on com.jogamp.opengl.util package. */
+public class InternalBufferUtil {
+    public static final int SIZEOF_BYTE = 1;
+    public static final int SIZEOF_SHORT = 2;
+    public static final int SIZEOF_INT = 4;
+    public static final int SIZEOF_FLOAT = 4;
+
+    //----------------------------------------------------------------------
+    // Allocation routines
+    //
+
+    /** Allocates a new direct ByteBuffer with the specified number of
+        elements. The returned buffer will have its byte order set to
+        the host platform's native byte order. */
+    public static ByteBuffer newByteBuffer(int numElements) {
+        ByteBuffer bb = ByteBuffer.allocateDirect(numElements);
+        nativeOrder(bb);
+        return bb;
+    }
+    
+    /** Allocates a new direct IntBuffer with the specified number of
+        elements. The returned buffer will have its byte order set to
+        the host platform's native byte order. */
+    public static IntBuffer newIntBuffer(int numElements) {
+        ByteBuffer bb = newByteBuffer(numElements * SIZEOF_INT);
+        return bb.asIntBuffer();
+    }
+    
+    //----------------------------------------------------------------------
+    // Copy routines (type-to-type)
+    //
+
+    /** Copies the <i>remaining</i> elements (as defined by
+        <code>limit() - position()</code>) in the passed ByteBuffer into
+        a newly-allocated direct ByteBuffer. The returned buffer will
+        have its byte order set to the host platform's native byte
+        order. The position of the newly-allocated buffer will be zero,
+        and the position of the passed buffer is unchanged (though its
+        mark is changed). */
+    public static ByteBuffer copyByteBuffer(ByteBuffer orig) {
+        ByteBuffer dest = newByteBuffer(orig.remaining());
+        dest.put(orig);
+        dest.rewind();
+        return dest;
+    }
+
+    //----------------------------------------------------------------------
+    // Conversion routines 
+    //
+
+    public static ByteBuffer nativeOrder(ByteBuffer buf) {
+        if (!isCDCFP) {
+            try {
+                if (byteOrderClass == null) {
+                    byteOrderClass = Class.forName("java.nio.ByteOrder");
+                    orderMethod = ByteBuffer.class.getMethod("order", new Class[] { byteOrderClass });
+                    Method nativeOrderMethod = byteOrderClass.getMethod("nativeOrder", null);
+                    nativeOrderObject = nativeOrderMethod.invoke(null, null);
+                }
+            } catch (Throwable t) {
+                // Must be running on CDC / FP
+                isCDCFP = true;
+            }
+
+            if (!isCDCFP) {
+                try {
+                    orderMethod.invoke(buf, new Object[] { nativeOrderObject });
+                } catch (Throwable t) {
+                }
+            }
+        }
+        return buf;
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    // NOTE that this work must be done reflectively at the present time
+    // because this code must compile and run correctly on both CDC/FP and J2SE
+    private static boolean isCDCFP;
+    private static Class byteOrderClass;
+    private static Object nativeOrderObject;
+    private static Method orderMethod;
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/LockingNativeWindowFactory.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/LockingNativeWindowFactory.java
new file mode 100644
index 000000000..fd2478ab2
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/LockingNativeWindowFactory.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.nativewindow.impl;
+
+import javax.media.nativewindow.*;
+
+public class LockingNativeWindowFactory extends NativeWindowFactoryImpl {
+    // Provides a generic basic and recursive locking mechanism for your discretion.
+    private ToolkitLock toolkitLock = new ToolkitLock() {
+            private Thread owner;
+            private int recursionCount;
+            
+            public synchronized void lock() {
+                Thread cur = Thread.currentThread();
+                if (owner == cur) {
+                    ++recursionCount;
+                    return;
+                }
+                while (owner != null) {
+                    try {
+                        wait();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+                owner = cur;
+            }
+
+            public synchronized void unlock() {
+                if (owner != Thread.currentThread()) {
+                    throw new RuntimeException("Not owner");
+                }
+                if (recursionCount > 0) {
+                    --recursionCount;
+                    return;
+                }
+                owner = null;
+                notifyAll();
+            }
+        };
+
+    public ToolkitLock getToolkitLock() {
+        return toolkitLock;
+    }
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/NWJNILibLoader.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/NWJNILibLoader.java
new file mode 100644
index 000000000..c3c04287a
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/NWJNILibLoader.java
@@ -0,0 +1,50 @@
+/*
+ * 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:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Sven Gothel nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL Sven Gothel BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.jogamp.nativewindow.impl;
+
+// FIXME: refactor Java SE dependencies
+//import java.awt.Toolkit;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.HashSet;
+import com.jogamp.common.jvm.JNILibLoaderBase;
+
+public class NWJNILibLoader extends JNILibLoaderBase {
+  
+  public static void loadNativeWindow(final String ossuffix) {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        loadLibrary("nativewindow_"+ossuffix, null, false);
+        return null;
+      }
+    });
+  }
+
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/NativeWindowFactoryImpl.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/NativeWindowFactoryImpl.java
new file mode 100644
index 000000000..d2429cdab
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/NativeWindowFactoryImpl.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.nativewindow.impl;
+
+import com.jogamp.common.util.*;
+import java.lang.reflect.*;
+import java.security.*;
+
+import javax.media.nativewindow.*;
+
+public class NativeWindowFactoryImpl extends NativeWindowFactory {
+    protected static final boolean DEBUG = Debug.debug("NativeWindowFactoryImpl");
+
+    // This subclass of NativeWindowFactory handles the case of
+    // NativeWindows being passed in
+    protected NativeWindow getNativeWindowImpl(Object winObj, AbstractGraphicsConfiguration config) throws IllegalArgumentException {
+        if (null == winObj) {
+            throw new IllegalArgumentException("winObj is null");
+        }
+        if (winObj instanceof NativeWindow) {
+            // Use the NativeWindow directly
+            return (NativeWindow) winObj;
+        }
+
+        if (null == config) {
+            throw new IllegalArgumentException("AbstractGraphicsConfiguration is null with a non NativeWindow object");
+        }
+
+        if (ReflectionUtil.instanceOf(winObj, "java.awt.Component")) {
+            return getAWTNativeWindow(winObj, config);
+        }
+
+        throw new IllegalArgumentException("Target window object type " +
+                                           winObj.getClass().getName() + " is unsupported; expected " +
+                                           "javax.media.nativewindow.NativeWindow or java.awt.Component");
+    }
+    
+    private Constructor nativeWindowConstructor = null;
+
+    private NativeWindow getAWTNativeWindow(Object winObj, AbstractGraphicsConfiguration config) {
+        if (nativeWindowConstructor == null) {
+            try {
+                String osType = getNativeWindowType(true);
+                String windowClassName = null;
+
+                // We break compile-time dependencies on the AWT here to
+                // make it easier to run this code on mobile devices
+
+                if (osType.equals(TYPE_WINDOWS)) {
+                    windowClassName = "com.jogamp.nativewindow.impl.jawt.windows.WindowsJAWTWindow";
+                } else if (osType.equals(TYPE_MACOSX)) {
+                    windowClassName = "com.jogamp.nativewindow.impl.jawt.macosx.MacOSXJAWTWindow";
+                } else if (osType.equals(TYPE_X11)) {
+                    // Assume Linux, Solaris, etc. Should probably test for these explicitly.
+                    windowClassName = "com.jogamp.nativewindow.impl.jawt.x11.X11JAWTWindow";
+                } else {
+                    throw new IllegalArgumentException("OS " + getNativeOSName(false) + " not yet supported");
+                }
+
+                nativeWindowConstructor = ReflectionUtil.getConstructor(windowClassName, new Class[] { Object.class, AbstractGraphicsConfiguration.class });
+            } catch (Exception e) {
+                throw (IllegalArgumentException) new IllegalArgumentException().initCause(e);
+            }
+        }
+
+        try {
+            return (NativeWindow) nativeWindowConstructor.newInstance(new Object[] { winObj, config });
+        } catch (Exception ie) {
+            throw (IllegalArgumentException) new IllegalArgumentException().initCause(ie);
+        }
+    }
+
+    // On most platforms the toolkit lock is a no-op
+    private ToolkitLock toolkitLock = new ToolkitLock() {
+            public void lock() {
+            }
+
+            public void unlock() {
+            }
+        };
+
+    public ToolkitLock getToolkitLock() {
+        return toolkitLock;
+    }
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/NullWindow.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/NullWindow.java
new file mode 100644
index 000000000..4458d7b3d
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/NullWindow.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.nativewindow.impl;
+
+import javax.media.nativewindow.*;
+
+public class NullWindow implements NativeWindow, SurfaceChangeable {
+  private Exception lockedStack = null;
+  protected int width, height, scrnIndex;
+  protected long surfaceHandle, displayHandle;
+  protected AbstractGraphicsConfiguration config;
+
+  public NullWindow(AbstractGraphicsConfiguration cfg) {
+    invalidate();
+    config = cfg;
+    displayHandle=cfg.getScreen().getDevice().getHandle();
+    scrnIndex=cfg.getScreen().getIndex();
+  }
+
+  protected void init(Object windowObject) throws NativeWindowException {
+  }
+
+  protected void initNative() throws NativeWindowException {
+  }
+
+  public void destroy() {
+    invalidate();
+  }
+
+  public synchronized void invalidate() {
+    displayHandle=0;
+    scrnIndex=-1;
+    surfaceHandle=0;
+  }
+
+  public synchronized int lockSurface() throws NativeWindowException {
+    if (null!=lockedStack) {
+      lockedStack.printStackTrace();
+      throw new NativeWindowException("Surface already locked - "+this);
+    }
+    lockedStack = new Exception("NullWindow previously locked by "+Thread.currentThread().getName());
+    return LOCK_SUCCESS;
+  }
+
+  public synchronized void unlockSurface() {
+    if (null!=lockedStack) {
+        lockedStack = null;
+    } else {
+        throw new NativeWindowException("NullWindow not locked");
+    }
+  }
+
+  public synchronized boolean isSurfaceLocked() {
+    return null!=lockedStack;
+  }
+
+  public Exception getLockedStack() {
+    return lockedStack;
+  }
+
+  public boolean surfaceSwap() {
+    return false;
+  }
+
+  public void surfaceUpdated(Object updater, NativeWindow window, long when) { }
+
+  public long getDisplayHandle() {
+    return displayHandle;
+  }
+  public int getScreenIndex() {
+    return scrnIndex;
+  }
+  public long getWindowHandle() {
+    return 0;
+  }
+  public long getSurfaceHandle() {
+    return surfaceHandle;
+  }
+  public void setSurfaceHandle(long surfaceHandle) {
+    this.surfaceHandle=surfaceHandle;
+  }
+  public AbstractGraphicsConfiguration getGraphicsConfiguration() {
+    return config;
+  }
+
+  public Object getWrappedWindow() {
+    return null;
+  }
+
+  public final boolean isTerminalObject() {
+    return true;
+  }
+
+  public void setSize(int width, int height) {
+    this.width=width;
+    this.height=height;
+  }
+
+  public int getWidth() {
+    return width;
+  }
+
+  public int getHeight() {
+    return height;
+  }
+
+  public String toString() {
+    return "NullWindow[config "+config+
+                ", displayHandle 0x"+Long.toHexString(getDisplayHandle())+
+                ", surfaceHandle 0x"+Long.toHexString(getSurfaceHandle())+
+                ", size "+getWidth()+"x"+getHeight()+"]";
+  }
+
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTJNILibLoader.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTJNILibLoader.java
new file mode 100644
index 000000000..4ea404c09
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTJNILibLoader.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.nativewindow.impl.jawt;
+
+import javax.media.nativewindow.NativeWindowFactory;
+import com.jogamp.nativewindow.impl.NWJNILibLoader;
+
+import java.awt.Toolkit;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+public class JAWTJNILibLoader extends NWJNILibLoader {
+  public static void loadAWTImpl() {
+    AccessController.doPrivileged(new PrivilegedAction() {
+      public Object run() {
+        // Make sure that awt.dll is loaded before loading jawt.dll. Otherwise
+        // a Dialog with "awt.dll not found" might pop up.
+        // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4481947.
+        Toolkit.getDefaultToolkit();
+        
+        // Must pre-load JAWT on all non-Mac platforms to
+        // ensure references from jogl_awt shared object
+        // will succeed since JAWT shared object isn't in
+        // default library path
+        if ( ! NativeWindowFactory.TYPE_MACOSX.equals( NativeWindowFactory.getNativeWindowType(false) ) ) {
+            try {
+                loadLibrary("jawt", null, true);
+            } catch (Throwable t) {
+                // It might be ok .. if it's already loaded
+                if(DEBUG) {
+                    t.printStackTrace();
+                }
+            }
+        }
+        return null;
+      }
+    });
+  }
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTUtil.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTUtil.java
new file mode 100644
index 000000000..b3c706ed8
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTUtil.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.nativewindow.impl.jawt;
+
+import com.jogamp.nativewindow.impl.*;
+
+import javax.media.nativewindow.*;
+
+import java.awt.GraphicsEnvironment;
+import java.lang.reflect.*;
+
+public class JAWTUtil {
+
+  // See whether we're running in headless mode
+  private static final boolean headlessMode;
+
+  // Java2D magic ..
+  private static final Class j2dClazz;
+  private static final Method isQueueFlusherThread;
+  private static final boolean j2dExist;
+
+  static {
+    JAWTJNILibLoader.loadAWTImpl();
+    JAWTJNILibLoader.loadNativeWindow("awt");
+
+    lockedStack   = null;
+    headlessMode = GraphicsEnvironment.isHeadless();
+
+    boolean ok=false;
+    Class jC=null;
+    Method m=null;
+    if(!headlessMode) {
+        try {
+            jC = Class.forName("com.jogamp.opengl.impl.awt.Java2D");
+            m = jC.getMethod("isQueueFlusherThread", null);
+            ok = true;
+        } catch (Exception e) {}
+    }
+    j2dClazz = jC;
+    isQueueFlusherThread = m;
+    j2dExist = ok;
+  }
+
+  private static Exception lockedStack;
+
+  // Just a hook to let this class being initialized,
+  // ie loading the native libraries ..
+  public static void init() { }
+
+  public static final boolean hasJava2D() {
+    return j2dExist;
+  }
+
+  public static final boolean isJava2DQueueFlusherThread() {
+    boolean b = false;
+    if(j2dExist) {
+        try {
+            b = ((Boolean)isQueueFlusherThread.invoke(null, null)).booleanValue();
+        } catch (Exception e) {}
+    }
+    return b;
+  }
+
+  public static boolean isHeadlessMode() {
+    return headlessMode;
+  }
+
+  public static synchronized void lockToolkit() throws NativeWindowException {
+    if (isJava2DQueueFlusherThread()) return;
+
+    if (null!=lockedStack) {
+      lockedStack.printStackTrace();
+      throw new NativeWindowException("JAWT Toolkit already locked - "+Thread.currentThread().getName());
+    }
+    lockedStack = new Exception("JAWT Toolkit already locked by: "+Thread.currentThread().getName());
+
+    if (headlessMode) {
+      // Workaround for running (to some degree) in headless
+      // environments but still supporting rendering via pbuffers
+      // For full correctness, would need to implement a Lock class
+      return;
+    }
+
+    JAWT.getJAWT().Lock();
+  }
+
+  public static synchronized void unlockToolkit() {
+    if (isJava2DQueueFlusherThread()) return;
+
+    if (null!=lockedStack) {
+        lockedStack = null;
+        if (headlessMode) {
+          // Workaround for running (to some degree) in headless
+          // environments but still supporting rendering via pbuffers
+          // For full correctness, would need to implement a Lock class
+          return;
+        }
+
+        JAWT.getJAWT().Unlock();
+    }
+  }
+
+  public static boolean isToolkitLocked() {
+    return null!=lockedStack;
+  }
+
+  public static Exception getLockedStack() {
+    return lockedStack;
+  }
+}
+
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTWindow.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTWindow.java
new file mode 100644
index 000000000..d0529878f
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWTWindow.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.nativewindow.impl.jawt;
+
+import com.jogamp.nativewindow.impl.*;
+
+import java.awt.Component;
+import java.awt.Window;
+import java.awt.GraphicsEnvironment;
+import javax.media.nativewindow.*;
+import com.jogamp.nativewindow.impl.*;
+
+public abstract class JAWTWindow implements NativeWindow {
+  protected static final boolean DEBUG = Debug.debug("JAWT");
+
+  // See whether we're running in headless mode
+  private static boolean headlessMode;
+
+  static {
+    headlessMode = GraphicsEnvironment.isHeadless();
+  }
+
+  // lifetime: forever
+  protected Component component;
+  protected AbstractGraphicsConfiguration config;
+
+  // lifetime: valid after lock, forever until invalidate
+  protected long drawable;
+
+  public JAWTWindow(Object comp, AbstractGraphicsConfiguration config) {
+    if (config == null) {
+        throw new NativeWindowException("Error: AbstractGraphicsConfiguration is null");
+    }
+    this.config = config;
+    init((Component)comp);
+  }
+
+  protected void init(Component windowObject) throws NativeWindowException {
+    invalidate();
+    this.component = windowObject;
+    initNative();
+  }
+
+  protected abstract void initNative() throws NativeWindowException;
+
+  public synchronized void invalidate() {
+    component = null;
+    drawable= 0;
+  }
+
+  public synchronized void destroy() {
+    if(null!=component) {
+        if(component instanceof Window) {
+            ((Window)component).dispose();
+        }
+    }
+    invalidate();
+  }
+
+  private volatile Exception lockedStack = null;
+
+  public synchronized int lockSurface() throws NativeWindowException {
+    // We have to be the owner of the JAWT ToolkitLock 'lock' to benefit from it's
+    // recursive and blocking lock capabitlites. 
+    // Otherwise a followup ToolkitLock would deadlock, 
+    // since we already have locked JAWT with the surface lock.
+    NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
+
+    // recursion not necessary here, due to the blocking ToolkitLock ..
+    if (null!=lockedStack) {
+      lockedStack.printStackTrace();
+      throw new NativeWindowException("JAWT Surface already locked - "+Thread.currentThread().getName()+" "+this);
+    }
+    lockedStack = new Exception("JAWT Surface previously locked by "+Thread.currentThread().getName());
+
+    return LOCK_SUCCESS;
+  }
+
+  public synchronized void unlockSurface() {
+    if (null!=lockedStack) {
+        lockedStack = null;
+    } else {
+        throw new NativeWindowException("JAWT Surface not locked");
+    }
+    NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
+  }
+
+  public synchronized boolean isSurfaceLocked() {
+    return null!=lockedStack;
+  }
+
+  public Exception getLockedStack() {
+    return lockedStack;
+  }
+
+  public boolean surfaceSwap() {
+    return false;
+  }
+
+  public void surfaceUpdated(Object updater, NativeWindow window, long when) { }
+
+  public long getDisplayHandle() {
+    return config.getScreen().getDevice().getHandle();
+  }
+  public int getScreenIndex() {
+    return config.getScreen().getIndex();
+  }
+  public long getWindowHandle() {
+    return drawable;
+  }
+  public long getSurfaceHandle() {
+    return drawable;
+  }
+  public AbstractGraphicsConfiguration getGraphicsConfiguration() {
+    return config;
+  }
+
+  public Object getWrappedWindow() {
+    return component;
+  }
+
+  public void setSize(int width, int height) {
+    component.setSize(width, height);
+  }
+
+  public int getWidth() {
+    return component.getWidth();
+  }
+
+  public int getHeight() {
+    return component.getHeight();
+  }
+
+  public String toString() {
+    StringBuffer sb = new StringBuffer();
+
+    sb.append("JAWT-Window["+
+                "windowHandle 0x"+Long.toHexString(getWindowHandle())+
+                ", surfaceHandle 0x"+Long.toHexString(getSurfaceHandle()));
+    if(null!=component) {
+      sb.append(", pos "+component.getX()+"/"+component.getY()+", size "+getWidth()+"x"+getHeight()+
+                ", visible "+component.isVisible());
+    } else {
+      sb.append(", component NULL");
+    }
+    sb.append(", locked "+isSurfaceLocked()+
+              ",\n\tconfig "+config+
+              ",\n\twrappedWindow "+getWrappedWindow()+"]");
+
+    return sb.toString();
+  }
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWT_PlatformInfo.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWT_PlatformInfo.java
new file mode 100644
index 000000000..d49e2f8d0
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/JAWT_PlatformInfo.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.nativewindow.impl.jawt;
+
+import com.jogamp.nativewindow.impl.*;
+
+/** Marker class for all window system-specific JAWT data structures. */
+
+public interface JAWT_PlatformInfo {
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/macosx/MacOSXJAWTWindow.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/macosx/MacOSXJAWTWindow.java
new file mode 100644
index 000000000..967d43d60
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/macosx/MacOSXJAWTWindow.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.nativewindow.impl.jawt.macosx;
+
+import com.jogamp.nativewindow.impl.*;
+import com.jogamp.nativewindow.impl.jawt.*;
+
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+
+import javax.media.nativewindow.*;
+import java.security.*;
+
+public class MacOSXJAWTWindow extends JAWTWindow {
+
+  public MacOSXJAWTWindow(Object comp, AbstractGraphicsConfiguration config) {
+    super(comp, config);
+  }
+
+  protected void initNative() throws NativeWindowException {
+  }
+
+  public int lockSurface() throws NativeWindowException {
+    int ret = super.lockSurface();
+    if(NativeWindow.LOCK_SUCCESS != ret) {
+        return ret;
+    }
+    ds = JAWT.getJAWT().GetDrawingSurface(component);
+    if (ds == null) {
+      // Widget not yet realized
+      super.unlockSurface();
+      return NativeWindow.LOCK_SURFACE_NOT_READY;
+    }
+    int res = ds.Lock();
+    if ((res & JAWTFactory.JAWT_LOCK_ERROR) != 0) {
+      super.unlockSurface();
+      throw new NativeWindowException("Unable to lock surface");
+    }
+    // See whether the surface changed and if so destroy the old
+    // OpenGL context so it will be recreated (NOTE: removeNotify
+    // should handle this case, but it may be possible that race
+    // conditions can cause this code to be triggered -- should test
+    // more)
+    if ((res & JAWTFactory.JAWT_LOCK_SURFACE_CHANGED) != 0) {
+      ret = NativeWindow.LOCK_SURFACE_CHANGED;
+    }
+    if (firstLock) {
+      AccessController.doPrivileged(new PrivilegedAction() {
+          public Object run() {
+            dsi = ds.GetDrawingSurfaceInfo();
+            return null;
+          }
+        });
+    } else {
+      dsi = ds.GetDrawingSurfaceInfo();
+    }
+    if (dsi == null) {
+      // Widget not yet realized
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      super.unlockSurface();
+      return NativeWindow.LOCK_SURFACE_NOT_READY;
+    }
+    firstLock = false;
+    macosxdsi = (JAWT_MacOSXDrawingSurfaceInfo) dsi.platformInfo();
+    if (macosxdsi == null) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      super.unlockSurface();
+      return NativeWindow.LOCK_SURFACE_NOT_READY;
+    }
+    drawable = macosxdsi.getCocoaViewRef();
+
+    if (drawable == 0) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      macosxdsi = null;
+      super.unlockSurface();
+      return NativeWindow.LOCK_SURFACE_NOT_READY;
+    }
+    return ret;
+  }
+    
+  public void unlockSurface() throws NativeWindowException {
+    if(!isSurfaceLocked()) {
+        throw new RuntimeException("JAWTWindow not locked");
+    }
+    ds.FreeDrawingSurfaceInfo(dsi);
+    ds.Unlock();
+    JAWT.getJAWT().FreeDrawingSurface(ds);
+    ds = null;
+    dsi = null;
+    macosxdsi = null;
+    super.unlockSurface();
+  }
+
+  // Variables for lockSurface/unlockSurface
+  private JAWT_DrawingSurface ds;
+  private JAWT_DrawingSurfaceInfo dsi;
+  private JAWT_MacOSXDrawingSurfaceInfo macosxdsi;
+
+  // Workaround for instance of 4796548
+  private boolean firstLock = true;
+
+}
+
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/windows/WindowsJAWTWindow.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/windows/WindowsJAWTWindow.java
new file mode 100644
index 000000000..b23ad3f50
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/windows/WindowsJAWTWindow.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.nativewindow.impl.jawt.windows;
+
+import com.jogamp.nativewindow.impl.*;
+import com.jogamp.nativewindow.impl.jawt.*;
+
+import javax.media.nativewindow.*;
+
+public class WindowsJAWTWindow extends JAWTWindow {
+
+  public static final boolean PROFILING = false; // FIXME
+  public static final int PROFILING_TICKS = 600; // FIXME
+
+  public WindowsJAWTWindow(Object comp, AbstractGraphicsConfiguration config) {
+    super(comp, config);
+  }
+
+  protected void initNative() throws NativeWindowException {
+  }
+
+  public int lockSurface() throws NativeWindowException {
+    int ret = super.lockSurface();
+    if(LOCK_SUCCESS != ret) {
+      return ret;
+    }
+
+    long startTime;
+    if (PROFILING) {
+      startTime = System.currentTimeMillis();
+    }
+    ds = JAWT.getJAWT().GetDrawingSurface(component);
+    if (ds == null) {
+      // Widget not yet realized
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    int res = ds.Lock();
+    if ((res & JAWTFactory.JAWT_LOCK_ERROR) != 0) {
+      super.unlockSurface();
+      throw new NativeWindowException("Unable to lock surface");
+    }
+    // See whether the surface changed and if so destroy the old
+    // OpenGL context so it will be recreated (NOTE: removeNotify
+    // should handle this case, but it may be possible that race
+    // conditions can cause this code to be triggered -- should test
+    // more)
+    if ((res & JAWTFactory.JAWT_LOCK_SURFACE_CHANGED) != 0) {
+      ret = LOCK_SURFACE_CHANGED;
+    }
+    dsi = ds.GetDrawingSurfaceInfo();
+    if (dsi == null) {
+      // Widget not yet realized
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    win32dsi = (JAWT_Win32DrawingSurfaceInfo) dsi.platformInfo();
+    if (win32dsi == null) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    drawable = win32dsi.getHdc();
+    if (drawable == 0) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      win32dsi = null;
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    if (PROFILING) {
+      long endTime = System.currentTimeMillis();
+      profilingLockSurfaceTime += (endTime - startTime);
+      if (++profilingLockSurfaceTicks == PROFILING_TICKS) {
+        System.err.println("LockSurface calls: " + profilingLockSurfaceTime + " ms / " + PROFILING_TICKS + " calls (" +
+                           ((float) profilingLockSurfaceTime / (float) PROFILING_TICKS) + " ms/call)");
+        profilingLockSurfaceTime = 0;
+        profilingLockSurfaceTicks = 0;
+      }
+    }
+    return ret;
+  }
+
+  public void unlockSurface() {
+    if(!isSurfaceLocked()) {
+        throw new RuntimeException("JAWTWindow not locked");
+    }
+    long startTime = 0;
+    if (PROFILING) {
+      startTime = System.currentTimeMillis();
+    }
+    ds.FreeDrawingSurfaceInfo(dsi);
+    ds.Unlock();
+    JAWT.getJAWT().FreeDrawingSurface(ds);
+    ds = null;
+    dsi = null;
+    win32dsi = null;
+    super.unlockSurface();
+    if (PROFILING) {
+      long endTime = System.currentTimeMillis();
+      profilingUnlockSurfaceTime += (endTime - startTime);
+      if (++profilingUnlockSurfaceTicks == PROFILING_TICKS) {
+        System.err.println("UnlockSurface calls: " + profilingUnlockSurfaceTime + " ms / " + PROFILING_TICKS + " calls (" +
+                           ((float) profilingUnlockSurfaceTime / (float) PROFILING_TICKS) + " ms/call)");
+        profilingUnlockSurfaceTime = 0;
+        profilingUnlockSurfaceTicks = 0;
+      }
+    }
+  }
+
+  // Variables for lockSurface/unlockSurface
+  private JAWT_DrawingSurface ds;
+  private JAWT_DrawingSurfaceInfo dsi;
+  private JAWT_Win32DrawingSurfaceInfo win32dsi;
+  private long profilingLockSurfaceTime = 0;
+  private int  profilingLockSurfaceTicks = 0;
+  private long profilingUnlockSurfaceTime = 0;
+  private int  profilingUnlockSurfaceTicks = 0;
+  
+}
+
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/x11/X11JAWTWindow.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/x11/X11JAWTWindow.java
new file mode 100644
index 000000000..f2977e8f0
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/x11/X11JAWTWindow.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.nativewindow.impl.jawt.x11;
+
+import javax.media.nativewindow.*;
+import javax.media.nativewindow.x11.*;
+
+import com.jogamp.nativewindow.impl.x11.*;
+import com.jogamp.nativewindow.impl.jawt.*;
+import com.jogamp.nativewindow.impl.*;
+
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+
+public class X11JAWTWindow extends JAWTWindow {
+
+  public X11JAWTWindow(Object comp, AbstractGraphicsConfiguration config) {
+    super(comp, config);
+  }
+
+  protected void initNative() throws NativeWindowException {
+  }
+
+  public synchronized int lockSurface() throws NativeWindowException {
+    int ret = super.lockSurface();
+    if(LOCK_SUCCESS != ret) {
+        return ret;
+    }
+    ds = JAWT.getJAWT().GetDrawingSurface(component);
+    if (ds == null) {
+      // Widget not yet realized
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    int res = ds.Lock();
+    if ((res & JAWTFactory.JAWT_LOCK_ERROR) != 0) {
+      super.unlockSurface();
+      throw new NativeWindowException("Unable to lock surface");
+    }
+    // See whether the surface changed and if so destroy the old
+    // OpenGL context so it will be recreated (NOTE: removeNotify
+    // should handle this case, but it may be possible that race
+    // conditions can cause this code to be triggered -- should test
+    // more)
+    if ((res & JAWTFactory.JAWT_LOCK_SURFACE_CHANGED) != 0) {
+      ret = LOCK_SURFACE_CHANGED;
+    }
+    dsi = ds.GetDrawingSurfaceInfo();
+    if (dsi == null) {
+      // Widget not yet realized
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    x11dsi = (JAWT_X11DrawingSurfaceInfo) dsi.platformInfo();
+    if (x11dsi == null) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    drawable = x11dsi.getDrawable();
+    if (drawable == 0) {
+      // Widget not yet realized
+      ds.FreeDrawingSurfaceInfo(dsi);
+      ds.Unlock();
+      JAWT.getJAWT().FreeDrawingSurface(ds);
+      ds = null;
+      dsi = null;
+      x11dsi = null;
+      drawable = 0;
+      super.unlockSurface();
+      return LOCK_SURFACE_NOT_READY;
+    }
+    return ret;
+  }
+
+  public synchronized void unlockSurface() {
+    if(!isSurfaceLocked()) {
+        throw new RuntimeException("JAWTWindow not locked");
+    }
+    ds.FreeDrawingSurfaceInfo(dsi);
+    ds.Unlock();
+    JAWT.getJAWT().FreeDrawingSurface(ds);
+    ds = null;
+    dsi = null;
+    x11dsi = null;
+    super.unlockSurface();
+  }
+
+  // Variables for lockSurface/unlockSurface
+  private JAWT_DrawingSurface ds;
+  private JAWT_DrawingSurfaceInfo dsi;
+  private JAWT_X11DrawingSurfaceInfo x11dsi;
+  
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/x11/X11SunJDKReflection.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/x11/X11SunJDKReflection.java
new file mode 100644
index 000000000..7cca6f9f3
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/jawt/x11/X11SunJDKReflection.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.nativewindow.impl.jawt.x11;
+
+import com.jogamp.nativewindow.impl.x11.*;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.lang.reflect.*;
+import java.security.*;
+
+import javax.media.nativewindow.AbstractGraphicsConfiguration;
+import javax.media.nativewindow.awt.AWTGraphicsConfiguration;
+
+/** This class encapsulates the reflection routines necessary to peek
+    inside a few data structures in the AWT implementation on X11 for
+    the purposes of correctly enumerating the available visuals. */
+
+public class X11SunJDKReflection {
+  private static Class   x11GraphicsDeviceClass;
+  private static Method  x11GraphicsDeviceGetScreenMethod;
+  private static Method  x11GraphicsDeviceGetDisplayMethod;
+  private static Class   x11GraphicsConfigClass;
+  private static Method  x11GraphicsConfigGetVisualMethod;
+  private static boolean initted;
+
+  static {
+    AccessController.doPrivileged(new PrivilegedAction() {
+        public Object run() {
+          try {
+            x11GraphicsDeviceClass = Class.forName("sun.awt.X11GraphicsDevice");
+            x11GraphicsDeviceGetScreenMethod = x11GraphicsDeviceClass.getDeclaredMethod("getScreen", new Class[] {});
+            x11GraphicsDeviceGetScreenMethod.setAccessible(true);
+            x11GraphicsDeviceGetDisplayMethod = x11GraphicsDeviceClass.getDeclaredMethod("getDisplay", new Class[] {});
+            x11GraphicsDeviceGetDisplayMethod.setAccessible(true);
+
+            x11GraphicsConfigClass = Class.forName("sun.awt.X11GraphicsConfig");
+            x11GraphicsConfigGetVisualMethod = x11GraphicsConfigClass.getDeclaredMethod("getVisual", new Class[] {});
+            x11GraphicsConfigGetVisualMethod.setAccessible(true);
+            initted = true;
+          } catch (Exception e) {
+            // Either not a Sun JDK or the interfaces have changed since 1.4.2 / 1.5
+          }
+          return null;
+        }
+      });
+  }
+
+  public static int graphicsDeviceGetScreen(GraphicsDevice device) {
+    if (!initted) {
+      return 0;
+    }
+
+    try {
+      return ((Integer) x11GraphicsDeviceGetScreenMethod.invoke(device, new Object[] {})).intValue();
+    } catch (Exception e) {
+      return 0;
+    }
+  }
+
+  public static long graphicsDeviceGetDisplay(GraphicsDevice device) {
+    if (!initted) {
+      return 0;
+    }
+
+    try {
+      return ((Long) x11GraphicsDeviceGetDisplayMethod.invoke(device, new Object[] {})).longValue();
+    } catch (Exception e) {
+      return 0;
+    }
+  }
+
+  public static int graphicsConfigurationGetVisualID(AbstractGraphicsConfiguration config) {
+      try {
+          if (config instanceof AWTGraphicsConfiguration) {
+              return graphicsConfigurationGetVisualID(((AWTGraphicsConfiguration) config).getGraphicsConfiguration());
+          }
+          return 0;
+      } catch (Exception e) {
+          return 0;
+      }
+  }
+
+  public static int graphicsConfigurationGetVisualID(GraphicsConfiguration config) {
+    if (!initted) {
+      return 0;
+    }
+
+    try {
+      return ((Integer) x11GraphicsConfigGetVisualMethod.invoke(config, new Object[] {})).intValue();
+    } catch (Exception e) {
+      return 0;
+    }
+  }
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/X11GraphicsConfigurationFactory.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/X11GraphicsConfigurationFactory.java
new file mode 100644
index 000000000..a6f52f3c0
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/X11GraphicsConfigurationFactory.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.nativewindow.impl.x11;
+
+import javax.media.nativewindow.*;
+import javax.media.nativewindow.x11.*;
+import com.jogamp.nativewindow.impl.x11.XVisualInfo;
+import com.jogamp.nativewindow.impl.x11.X11Lib;
+
+public class X11GraphicsConfigurationFactory extends GraphicsConfigurationFactory {
+    public AbstractGraphicsConfiguration
+        chooseGraphicsConfiguration(Capabilities capabilities,
+                                    CapabilitiesChooser chooser,
+                                    AbstractGraphicsScreen screen)
+        throws IllegalArgumentException, NativeWindowException {
+
+        if(null==screen || !(screen instanceof X11GraphicsScreen)) {
+            throw new NativeWindowException("Only valid X11GraphicsScreen are allowed");
+        }
+        return new X11GraphicsConfiguration((X11GraphicsScreen)screen, capabilities, capabilities, getXVisualInfo(screen, capabilities));
+    }
+
+    public static XVisualInfo getXVisualInfo(AbstractGraphicsScreen screen, long visualID)
+    {
+        XVisualInfo xvi_temp = XVisualInfo.create();
+        xvi_temp.setVisualid(visualID);
+        xvi_temp.setScreen(screen.getIndex());
+        int num[] = { -1 };
+        long display = screen.getDevice().getHandle();
+
+        X11Lib.XLockDisplay(display);
+        try {
+            XVisualInfo[] xvis = X11Lib.XGetVisualInfoCopied(display, X11Lib.VisualIDMask|X11Lib.VisualScreenMask, xvi_temp, num, 0);
+
+            if(xvis==null || num[0]<1) {
+                return null;
+            }
+
+            return XVisualInfo.create(xvis[0]);
+        } finally {
+            X11Lib.XUnlockDisplay(display);
+        }
+
+    }
+
+    public static XVisualInfo getXVisualInfo(AbstractGraphicsScreen screen, Capabilities capabilities)
+    {
+        XVisualInfo xv = getXVisualInfoImpl(screen, capabilities, 4 /* TrueColor */);
+        if(null!=xv) return xv;
+        return getXVisualInfoImpl(screen, capabilities, 5 /* DirectColor */);
+    }
+
+    private static XVisualInfo getXVisualInfoImpl(AbstractGraphicsScreen screen, Capabilities capabilities, int c_class)
+    {
+        XVisualInfo ret = null;
+        int[] num = { -1 };
+
+        XVisualInfo vinfo_template = XVisualInfo.create();
+        vinfo_template.setScreen(screen.getIndex());
+        vinfo_template.setC_class(c_class);
+        long display = screen.getDevice().getHandle();
+
+        X11Lib.XLockDisplay(display);
+        try {
+            XVisualInfo[] vinfos = X11Lib.XGetVisualInfoCopied(display, X11Lib.VisualScreenMask, vinfo_template, num, 0);
+            XVisualInfo best=null;
+            int rdepth = capabilities.getRedBits() + capabilities.getGreenBits() + capabilities.getBlueBits() + capabilities.getAlphaBits();
+            for (int i = 0; vinfos!=null && i < num[0]; i++) {
+                if ( best == null || 
+                     best.getDepth() < vinfos[i].getDepth() )
+                {
+                    best = vinfos[i];
+                    if(rdepth <= best.getDepth())
+                        break;
+                }
+            }
+            if ( null!=best && ( rdepth <= best.getDepth() || 24 == best.getDepth()) ) {
+                ret = XVisualInfo.create(best);
+            }
+            best = null;
+
+            return ret;
+        } finally {
+            X11Lib.XUnlockDisplay(display);
+        }
+    }
+}
+
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/X11Util.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/X11Util.java
new file mode 100644
index 000000000..5f5c10885
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/X11Util.java
@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.nativewindow.impl.x11;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Collection;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import javax.media.nativewindow.*;
+
+import com.jogamp.nativewindow.impl.*;
+
+/**
+ * Contains a thread safe X11 utility to retrieve thread local display connection,<br>
+ * as well as the static global display connection.<br>
+ *
+ * The TLS variant is thread safe per se, but be aware of the memory leak risk 
+ * where an application heavily utilizing this class on temporary new threads.<br>
+ */
+public class X11Util {
+    private static final boolean DEBUG = Debug.debug("X11Util");
+
+    static {
+        NWJNILibLoader.loadNativeWindow("x11");
+        installIOErrorHandler();
+    }
+
+    private X11Util() {}
+
+    private static ThreadLocal currentDisplayMap = new ThreadLocal();
+
+    // not exactly thread safe, but good enough for our purpose,
+    // which is to tag a NamedDisplay uncloseable after creation.
+    private static Object globalLock = new Object(); 
+    private static Collection globalNamedDisplayActive = new ArrayList(); 
+    private static Collection globalNamedDisplayPassive = new ArrayList(); 
+
+    public static final String nullDeviceName = "nil" ;
+
+    public static class NamedDisplay implements Cloneable {
+        String name;
+        long   handle;
+        int    refCount;
+        boolean unCloseable;
+
+        protected NamedDisplay(String name, long handle) {
+            this.name=name;
+            this.handle=handle;
+            this.refCount=1;
+            this.unCloseable=false;
+        }
+
+        public final String getName() { return name; }
+        public final String getNameSafe() { return null == name ? nullDeviceName : name; }
+        public final long   getHandle() { return handle; }
+        public final int    getRefCount() { return refCount; }
+        public final boolean isUncloseable() { return unCloseable; }
+
+        public Object clone() throws CloneNotSupportedException {
+          return super.clone();
+        }
+
+        public String toString() {
+            return "NamedX11Display["+name+", 0x"+Long.toHexString(handle)+", refCount "+refCount+", unCloseable "+unCloseable+"]";
+        }
+    }
+
+    /** Returns the number of unclosed X11 Displays.
+      * @param realXClosePendingDisplays if true, call XCloseDisplay on the remaining ones
+      */
+    public static int shutdown(boolean realXClosePendingDisplays, boolean verbose) {
+        int num=0;
+        String msg;
+        if(DEBUG||verbose) {
+            msg = "X11Util.Display: Shutdown (active: "+globalNamedDisplayActive.size()+
+                                           ", passive: "+globalNamedDisplayPassive.size() + ")";
+            if(DEBUG) {
+                Exception e = new Exception(msg);
+                e.printStackTrace();
+            } else if(verbose) {
+                System.err.println(msg);
+            }
+        }
+
+        msg = realXClosePendingDisplays ? "Close" : "Keep" ;
+
+        synchronized(globalLock) {
+            // for all passive displays ..
+            Collection namedDisplays = globalNamedDisplayPassive;
+            globalNamedDisplayPassive = new ArrayList(); 
+            for(Iterator iter=namedDisplays.iterator(); iter.hasNext(); ) {
+                NamedDisplay ndpy = (NamedDisplay)iter.next();
+                if(DEBUG||verbose) {
+                    System.err.println(msg+" passive: "+ndpy);
+                }
+                if(realXClosePendingDisplays) {
+                    X11Lib.XCloseDisplay(ndpy.getHandle());
+                }
+                num++;
+            }
+
+            // for all active displays ..
+            namedDisplays = globalNamedDisplayActive;
+            globalNamedDisplayActive = new ArrayList(); 
+            for(Iterator iter=namedDisplays.iterator(); iter.hasNext(); ) {
+                NamedDisplay ndpy = (NamedDisplay)iter.next();
+                if(DEBUG||verbose) {
+                    System.err.println(msg+" active: "+ndpy);
+                }
+                if(realXClosePendingDisplays) {
+                    X11Lib.XCloseDisplay(ndpy.getHandle());
+                }
+                num++;
+            }
+        }
+        return num;
+    }
+
+    /** Returns a clone of the thread local display map, you may {@link Object#wait()} on it */
+    public static Map getCurrentDisplayMap() {
+        return (Map) ((HashMap)getCurrentDisplayMapImpl()).clone();
+    }
+
+    /** Returns this thread current default display.  If it doesn not exist, it is being created, otherwise the reference count is increased */
+    public static long createThreadLocalDefaultDisplay() {
+        return createThreadLocalDisplay(null);
+    }
+
+    /** Returns this thread named display. If it doesn not exist, it is being created, otherwise the reference count is increased */
+    public static long createThreadLocalDisplay(String name) {
+        NamedDisplay namedDpy = getCurrentDisplay(name);
+        if(null==namedDpy) {
+            synchronized(globalLock) {
+                namedDpy = getNamedDisplay(globalNamedDisplayPassive, name);
+                if(null != namedDpy) {
+                    if(!globalNamedDisplayPassive.remove(namedDpy)) { throw new RuntimeException("Internal: "+namedDpy); }
+                    globalNamedDisplayActive.add(namedDpy);
+                    addCurrentDisplay( namedDpy );
+                }
+            }
+        }
+        if(null==namedDpy) {
+            long dpy = X11Lib.XOpenDisplay(name);
+            if(0==dpy) {
+                throw new NativeWindowException("X11Util.Display: Unable to create a display("+name+") connection in Thread "+Thread.currentThread().getName());
+            }
+            namedDpy = new NamedDisplay(name, dpy);
+            synchronized(globalLock) {
+                globalNamedDisplayActive.add(namedDpy);
+                addCurrentDisplay( namedDpy );
+            }
+            if(DEBUG) {
+                Exception e = new Exception("X11Util.Display: Created new TLS "+namedDpy+" in thread "+Thread.currentThread().getName());
+                e.printStackTrace();
+            }
+        } else {
+            namedDpy.refCount++;
+            if(DEBUG) {
+                Exception e = new Exception("X11Util.Display: Reused TLS "+namedDpy+" in thread "+Thread.currentThread().getName());
+                e.printStackTrace();
+            }
+        }
+        return namedDpy.getHandle();
+    }
+
+    /** Decrease the reference count of this thread named display. If it reaches 0, close it. 
+        It returns the handle of the to be closed display.
+        It throws a RuntimeException in case the named display does not exist, 
+        or the reference count goes below 0.
+     */
+    public static long closeThreadLocalDisplay(String name) {
+        NamedDisplay namedDpy = getCurrentDisplay(name);
+        if(null==namedDpy) {
+            throw new RuntimeException("X11Util.Display: Display("+name+") with given handle is not mapped to TLS in thread "+Thread.currentThread().getName());
+        }
+        if(0==namedDpy.refCount) {
+            throw new RuntimeException("X11Util.Display: "+namedDpy+" has refCount already 0 in thread "+Thread.currentThread().getName());
+        }
+        long dpy = namedDpy.getHandle();
+        namedDpy.refCount--;
+        if(0==namedDpy.refCount) {
+            synchronized(globalLock) {
+                if(!globalNamedDisplayActive.remove(namedDpy)) { throw new RuntimeException("Internal: "+namedDpy); }
+                if(namedDpy.isUncloseable()) {
+                    globalNamedDisplayPassive.add(namedDpy);
+                } else {
+                    X11Lib.XCloseDisplay(dpy);
+                }
+                removeCurrentDisplay(namedDpy);
+            }
+            if(DEBUG) {
+                String type = namedDpy.isUncloseable() ? "passive" : "real" ;
+                Exception e = new Exception("X11Util.Display: Closing ( "+type+" ) TLS "+namedDpy+" in thread "+Thread.currentThread().getName());
+                e.printStackTrace();
+            }
+        } else if(DEBUG) {
+            Exception e = new Exception("X11Util.Display: Keep TLS "+namedDpy+" in thread "+Thread.currentThread().getName());
+            e.printStackTrace();
+        }
+        return dpy;
+    }
+
+    public static String getThreadLocalDisplayName(long handle) {
+        NamedDisplay ndpy = getNamedDisplay(getCurrentDisplayMapImpl().values(), handle);
+        return null != ndpy ? ndpy.getName() : null;
+    }
+
+    public static boolean markThreadLocalDisplayUndeletable(long handle) {
+        NamedDisplay ndpy = getNamedDisplay(getCurrentDisplayMapImpl().values(), handle);
+        if( null != ndpy ) {
+            ndpy.unCloseable=true;
+            return true;
+        }
+        return false;
+    }
+
+    public static String getGlobalDisplayName(long handle, boolean active) {
+        String name;
+        synchronized(globalLock) {
+            NamedDisplay ndpy = getNamedDisplay(active ? globalNamedDisplayActive : globalNamedDisplayPassive, handle);
+            name = null != ndpy ? ndpy.getName() : null;
+        }
+        return name;
+    }
+
+    public static boolean markGlobalDisplayUndeletable(long handle) {
+        boolean r=false;
+        synchronized(globalLock) {
+            NamedDisplay ndpy = getNamedDisplay(globalNamedDisplayActive, handle);
+            if( null != ndpy ) {
+                ndpy.unCloseable=true;
+                r=true;
+            }
+        }
+        return r;
+    }
+
+    private static Map getCurrentDisplayMapImpl() {
+        Map displayMap = (Map) currentDisplayMap.get();
+        if(null==displayMap) {
+            displayMap = new HashMap();
+            currentDisplayMap.set( displayMap );
+        }
+        return displayMap;
+    }
+
+    /** maps the given display to the thread local display map
+      * and notifies all threads synchronized to this display map. */
+    private static NamedDisplay addCurrentDisplay(NamedDisplay newDisplay) {
+        Map displayMap = getCurrentDisplayMapImpl();
+        NamedDisplay oldDisplay = null;
+        synchronized(displayMap) {
+            oldDisplay = (NamedDisplay) displayMap.put(newDisplay.getNameSafe(), newDisplay);
+            displayMap.notifyAll();
+        }
+        return oldDisplay;
+    }
+
+    /** removes the mapping of the given name from the thread local display map
+      * and notifies all threads synchronized to this display map. */
+    private static NamedDisplay removeCurrentDisplay(NamedDisplay ndpy) {
+        Map displayMap = getCurrentDisplayMapImpl();
+        synchronized(displayMap) {
+            NamedDisplay ndpyDel = (NamedDisplay) displayMap.remove(ndpy.getNameSafe());
+            if(ndpyDel!=ndpy) {
+                throw new RuntimeException("Wrong mapping req: "+ndpy+", got "+ndpyDel);
+            }
+            displayMap.notifyAll();
+        }
+        return ndpy;
+    }
+
+    /** Returns the thread local display mapped to the given name */
+    private static NamedDisplay getCurrentDisplay(String name) {
+        if(null==name) name=nullDeviceName;
+        Map displayMap = getCurrentDisplayMapImpl();
+        return (NamedDisplay) displayMap.get(name);
+    }
+
+    private static NamedDisplay getNamedDisplay(Collection namedDisplays, String name) {
+        if(null==name) name=nullDeviceName;
+        for(Iterator iter=namedDisplays.iterator(); iter.hasNext(); ) {
+            NamedDisplay ndpy = (NamedDisplay)iter.next();
+            if (ndpy.getNameSafe().equals(name)) {
+                return ndpy;
+            }
+        }
+        return null;
+    }
+
+    private static NamedDisplay getNamedDisplay(Collection namedDisplays, long handle) {
+        for(Iterator iter=namedDisplays.iterator(); iter.hasNext(); ) {
+            NamedDisplay ndpy = (NamedDisplay)iter.next();
+            if (ndpy.getHandle()==handle) {
+                return ndpy;
+            }
+        }
+        return null;
+    }
+
+    private static native void installIOErrorHandler();
+}
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/awt/X11AWTNativeWindowFactory.java b/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/awt/X11AWTNativeWindowFactory.java
new file mode 100644
index 000000000..616220e14
--- /dev/null
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/impl/x11/awt/X11AWTNativeWindowFactory.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2008-2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.nativewindow.impl.x11.awt;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import javax.media.nativewindow.*;
+
+import com.jogamp.nativewindow.impl.*;
+import com.jogamp.nativewindow.impl.jawt.*;
+import com.jogamp.nativewindow.impl.jawt.x11.*;
+import com.jogamp.nativewindow.impl.x11.*;
+
+public class X11AWTNativeWindowFactory extends NativeWindowFactoryImpl {
+
+    // When running the AWT on X11 platforms, we use the AWT native
+    // interface (JAWT) to lock and unlock the toolkit
+    private ToolkitLock toolkitLock = new ToolkitLock() {
+            private Thread owner;
+            private int recursionCount;
+            
+            public synchronized void lock() {
+                Thread cur = Thread.currentThread();
+                if (owner == cur) {
+                    ++recursionCount;
+                    return;
+                }
+                while (owner != null) {
+                    try {
+                        wait();
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+                owner = cur;
+                JAWTUtil.lockToolkit();
+            }
+
+            public synchronized void unlock() {
+                if (owner != Thread.currentThread()) {
+                    throw new RuntimeException("Not owner");
+                }
+                if (recursionCount > 0) {
+                    --recursionCount;
+                    return;
+                }
+                owner = null;
+                JAWTUtil.unlockToolkit();
+                notifyAll();
+            }
+        };
+
+    public ToolkitLock getToolkitLock() {
+        return toolkitLock;
+    }
+}