Copied JOGL_2_SANDBOX r1957 on to trunk; JOGL_2_SANDBOX branch is now closed

git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@1959 232f8b59-042b-4e1e-8c03-345bb8c30851

24 files changed, 2585 insertions, 0 deletions

diff --git a/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsConfiguration.java b/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsConfiguration.java
new file mode 100644
index 000000000..e53f75251
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsConfiguration.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 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 javax.media.nativewindow;
+
+/** A marker interface describing a graphics configuration, visual, or
+    pixel format in a toolkit-independent manner. */
+
+public interface AbstractGraphicsConfiguration extends Cloneable {
+    /**
+     * Return the screen this graphics configuration is valid for
+     */
+    public AbstractGraphicsScreen getScreen();
+
+    /**
+     * Return the capabilities reflecting this graphics configuration,
+     * which may differ from the capabilites used to choose this configuration.
+     *
+     * @return A copy of the Capabilities to avoid mutation by the user.
+     */
+    public Capabilities getChosenCapabilities();
+
+    /**
+     * Return the capabilities used to choose this graphics configuration.
+     *
+     * These may be used to reconfigure the NativeWindow in case
+     * the device changes in a multi screen environment.
+     *
+     * @return A copy of the Capabilities to avoid mutation by the user.
+     */
+    public Capabilities getRequestedCapabilities();
+
+    /**
+     * In case this instance already reflects a native configuration,
+     * return this one.
+     * Otherwise return the encapsuled native configuration, 
+     * as it shall be included e.g. in the AWT case.
+     */
+    public AbstractGraphicsConfiguration getNativeGraphicsConfiguration();
+}
+
diff --git a/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsDevice.java b/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsDevice.java
new file mode 100644
index 000000000..4240ec81e
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsDevice.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 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 javax.media.nativewindow;
+
+/** A interface describing a graphics device in a
+    toolkit-independent manner.
+ */
+
+public interface AbstractGraphicsDevice extends Cloneable {
+    /**
+     * Returns the type of the underlying subsystem, ie
+     * NativeWindowFactory.TYPE_KD, NativeWindowFactory.TYPE_X11, ..
+     */
+    public String getType();
+
+    /**
+     * Returns the native handle of the underlying native device,
+     * if such thing exist.
+     */
+    public long getHandle();
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsScreen.java b/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsScreen.java
new file mode 100644
index 000000000..eb2cc9120
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/AbstractGraphicsScreen.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 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 javax.media.nativewindow;
+
+/** A interface describing a graphics screen in a
+    toolkit-independent manner.
+ */
+
+public interface AbstractGraphicsScreen extends Cloneable {
+    /**
+     * Return the device this graphics configuration is valid for
+     */
+    public AbstractGraphicsDevice getDevice();
+
+    /** Returns the screen index this graphics screen is valid for
+     */
+    public int getIndex();
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/Capabilities.java b/src/nativewindow/classes/javax/media/nativewindow/Capabilities.java
new file mode 100644
index 000000000..6c4c93003
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/Capabilities.java
@@ -0,0 +1,259 @@
+/*
+ * 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 javax.media.nativewindow;
+
+/** Specifies a set of capabilities that a window's rendering context
+    must support, such as color depth per channel. It currently
+    contains the minimal number of routines which allow configuration
+    on all supported window systems. */
+
+public class Capabilities implements Cloneable {
+  private int     redBits        = 8;
+  private int     greenBits      = 8;
+  private int     blueBits       = 8;
+  private int     alphaBits      = 0;
+
+  // Support for transparent windows containing OpenGL content
+  private boolean backgroundOpaque = true;
+  private int     transparentValueRed = -1;
+  private int     transparentValueGreen = -1;
+  private int     transparentValueBlue = -1;
+  private int     transparentValueAlpha = -1;
+
+  /** Creates a Capabilities object. All attributes are in a default
+      state.
+    */
+  public Capabilities() {}
+
+  public Object clone() {
+    try {
+      return super.clone();
+    } catch (CloneNotSupportedException e) {
+      throw new NativeWindowException(e);
+    }
+  }
+
+  public boolean equals(Object obj) {
+    if(!(obj instanceof Capabilities)) {
+        return false;
+    }
+    Capabilities other = (Capabilities)obj;
+    boolean res = other.getRedBits()==redBits &&
+                  other.getGreenBits()==greenBits &&
+                  other.getBlueBits()==blueBits &&
+                  other.getAlphaBits()==alphaBits &&
+                  other.isBackgroundOpaque()==backgroundOpaque;
+    if(!backgroundOpaque) {
+     res = res && other.getTransparentRedValue()==transparentValueRed &&
+                  other.getTransparentGreenValue()==transparentValueGreen &&
+                  other.getTransparentBlueValue()==transparentValueBlue &&
+                  other.getTransparentAlphaValue()==transparentValueAlpha;
+    }
+
+    return res;
+  }
+
+  /** Returns the number of bits requested for the color buffer's red
+      component. On some systems only the color depth, which is the
+      sum of the red, green, and blue bits, is considered. */
+  public int getRedBits() {
+    return redBits;
+  }
+
+  /** Sets the number of bits requested for the color buffer's red
+      component. On some systems only the color depth, which is the
+      sum of the red, green, and blue bits, is considered. */
+  public void setRedBits(int redBits) {
+    this.redBits = redBits;
+  }
+
+  /** Returns the number of bits requested for the color buffer's
+      green component. On some systems only the color depth, which is
+      the sum of the red, green, and blue bits, is considered. */
+  public int getGreenBits() {
+    return greenBits;
+  }
+
+  /** Sets the number of bits requested for the color buffer's green
+      component. On some systems only the color depth, which is the
+      sum of the red, green, and blue bits, is considered. */
+  public void setGreenBits(int greenBits) {
+    this.greenBits = greenBits;
+  }
+
+  /** Returns the number of bits requested for the color buffer's blue
+      component. On some systems only the color depth, which is the
+      sum of the red, green, and blue bits, is considered. */
+  public int getBlueBits() {
+    return blueBits;
+  }
+
+  /** Sets the number of bits requested for the color buffer's blue
+      component. On some systems only the color depth, which is the
+      sum of the red, green, and blue bits, is considered. */
+  public void setBlueBits(int blueBits) {
+    this.blueBits = blueBits;
+  }
+  
+  /** Returns the number of bits requested for the color buffer's
+      alpha component. On some systems only the color depth, which is
+      the sum of the red, green, and blue bits, is considered. */
+  public int getAlphaBits() {
+    return alphaBits;
+  }
+
+  /** Sets the number of bits requested for the color buffer's alpha
+      component. On some systems only the color depth, which is the
+      sum of the red, green, and blue bits, is considered. */
+  public void setAlphaBits(int alphaBits) {
+    this.alphaBits = alphaBits;
+  }
+
+  /** For on-screen OpenGL contexts on some platforms, sets whether
+      the background of the context should be considered opaque. On
+      supported platforms, setting this to false, in conjunction with
+      the transparency values, may allow
+      hardware-accelerated OpenGL content inside of windows of
+      arbitrary shape. To achieve this effect it is necessary to use
+      an OpenGL clear color with an alpha less than 1.0. The default
+      value for this flag is <code>true</code>; setting it to false
+      may incur a certain performance penalty, so it is not
+      recommended to arbitrarily set it to false.<br>
+      If not set already, the transparency values for red, green, blue and alpha
+      are set to their default value, which is half of the value range
+      of the framebuffer's corresponding component,
+      ie <code> redValue = ( 1 << ( redBits - 1 ) ) -1 </code>.
+    */
+  public void setBackgroundOpaque(boolean opaque) {
+    backgroundOpaque = opaque;
+    if(!opaque) {
+        if(transparentValueRed<0)
+            transparentValueRed = ( 1 << ( getRedBits() - 1 ) )  - 1 ;
+        if(transparentValueGreen<0)
+            transparentValueGreen = ( 1 << ( getGreenBits() - 1 ) )  - 1 ;
+        if(transparentValueBlue<0)
+            transparentValueBlue = ( 1 << ( getBlueBits() - 1 ) )  - 1 ;
+        if(transparentValueAlpha<0)
+            transparentValueAlpha = ( 1 << ( getAlphaBits() - 1 ) )  - 1 ;
+    }
+  }
+
+  /** Indicates whether the background of this OpenGL context should
+      be considered opaque. Defaults to true.
+
+      @see #setBackgroundOpaque
+  */
+  public boolean isBackgroundOpaque() {
+    return backgroundOpaque;
+  }
+
+  /** Gets the transparent red value for the frame buffer configuration.
+    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
+    * @see #setTransparentRedValue
+    */
+  public int getTransparentRedValue() { return transparentValueRed; }
+
+  /** Gets the transparent green value for the frame buffer configuration.
+    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
+    * @see #setTransparentGreenValue
+    */
+  public int getTransparentGreenValue() { return transparentValueGreen; }
+
+  /** Gets the transparent blue value for the frame buffer configuration.
+    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
+    * @see #setTransparentBlueValue
+    */
+  public int getTransparentBlueValue() { return transparentValueBlue; }
+
+  /** Gets the transparent alpha value for the frame buffer configuration.
+    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
+    * @see #setTransparentAlphaValue
+    */
+  public int getTransparentAlphaValue() { return transparentValueAlpha; }
+
+  /** Sets the transparent red value for the frame buffer configuration,
+      ranging from 0 to the maximum frame buffer value for red.
+      This value is ignored if {@link #isBackgroundOpaque()} equals true.<br>
+      It defaults to half of the frambuffer value for red. <br>
+      A value of -1 is interpreted as any value. */
+  public void setTransparentRedValue(int transValueRed) { transparentValueRed=transValueRed; }
+
+  /** Sets the transparent green value for the frame buffer configuration,
+      ranging from 0 to the maximum frame buffer value for green.
+      This value is ignored if {@link #isBackgroundOpaque()} equals true.<br>
+      It defaults to half of the frambuffer value for green.<br>
+      A value of -1 is interpreted as any value. */
+  public void setTransparentGreenValue(int transValueGreen) { transparentValueGreen=transValueGreen; }
+
+  /** Sets the transparent blue value for the frame buffer configuration,
+      ranging from 0 to the maximum frame buffer value for blue.
+      This value is ignored if {@link #isBackgroundOpaque()} equals true.<br>
+      It defaults to half of the frambuffer value for blue.<br>
+      A value of -1 is interpreted as any value. */
+  public void setTransparentBlueValue(int transValueBlue) { transparentValueBlue=transValueBlue; }
+
+  /** Sets the transparent alpha value for the frame buffer configuration,
+      ranging from 0 to the maximum frame buffer value for alpha.
+      This value is ignored if {@link #isBackgroundOpaque()} equals true.<br>
+      It defaults to half of the frambuffer value for alpha.<br>
+      A value of -1 is interpreted as any value. */
+  public void setTransparentAlphaValue(int transValueAlpha) { transparentValueAlpha=transValueAlpha; }
+
+
+  /** Returns a textual representation of this Capabilities
+      object. */ 
+  public String toString() {
+    StringBuffer msg = new StringBuffer();
+    msg.append("Capabilities[");
+	msg.append("Red: " + redBits +
+	    ", Green: " + greenBits +
+	    ", Blue: " + blueBits +
+	    ", Alpha: " + alphaBits +
+        ", Opaque: " + backgroundOpaque);
+    if(!backgroundOpaque) {
+        msg.append(", Transparent RGBA: [0x"+ Integer.toHexString(transparentValueRed)+
+                   " 0x"+ Integer.toHexString(transparentValueGreen)+
+                   " 0x"+ Integer.toHexString(transparentValueBlue)+
+                   " 0x"+ Integer.toHexString(transparentValueAlpha)+"] ");
+    }
+	msg.append("]");
+    return msg.toString();
+  }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/CapabilitiesChooser.java b/src/nativewindow/classes/javax/media/nativewindow/CapabilitiesChooser.java
new file mode 100644
index 000000000..d61ebd4ef
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/CapabilitiesChooser.java
@@ -0,0 +1,68 @@
+/*
+ * 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 javax.media.nativewindow;
+
+/** Provides a mechanism by which applications can customize the
+    window type selection for a given {@link Capabilities}.
+    Developers can implement this interface and pass an instance into
+    the method {@link GraphicsConfigurationFactory#chooseGraphicsConfiguration}; the chooser
+    will be called at window creation time. */
+
+public interface CapabilitiesChooser {
+  /** Chooses the index (0..available.length - 1) of the {@link
+      Capabilities} most closely matching the desired one from the
+      list of all supported. Some of the entries in the
+      <code>available</code> array may be null; the chooser must
+      ignore these. The <em>windowSystemRecommendedChoice</em>
+      parameter may be provided to the chooser by the underlying
+      window system; if this index is valid, it is recommended, but
+      not necessarily required, that the chooser select that entry.
+
+      <P> <em>Note:</em> this method is called automatically by the
+      {@link GraphicsConfigurationFactory#chooseGraphicsConfiguration} method 
+      when an instance of this class is passed in to it.
+      It should generally not be
+      invoked by users directly, unless it is desired to delegate the
+      choice to some other CapabilitiesChooser object.
+  */
+  public int chooseCapabilities(Capabilities desired,
+                                Capabilities[] available,
+                                int windowSystemRecommendedChoice);
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/DefaultCapabilitiesChooser.java b/src/nativewindow/classes/javax/media/nativewindow/DefaultCapabilitiesChooser.java
new file mode 100644
index 000000000..cead0a4a8
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/DefaultCapabilitiesChooser.java
@@ -0,0 +1,153 @@
+/*
+ * 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 javax.media.nativewindow;
+
+/** <P> The default implementation of the {@link
+    CapabilitiesChooser} interface, which provides consistent visual
+    selection behavior across platforms. The precise algorithm is
+    deliberately left loosely specified. Some properties are: </P>
+
+    <LI> Attempts to match as closely as possible the given
+    Capabilities, but will select one with fewer capabilities (i.e.,
+    lower color depth) if necessary.
+
+    <LI> If there is no exact match, prefers a more-capable visual to
+    a less-capable one.
+
+    <LI> If there is more than one exact match, chooses an arbitrary
+    one.
+
+    <LI> If a valid windowSystemRecommendedChoice parameter is
+    supplied, chooses that instead of using the cross-platform code.
+
+    </UL>
+*/
+
+public class DefaultCapabilitiesChooser implements CapabilitiesChooser {
+  private static final boolean DEBUG = false; // FIXME: Debug.debug("DefaultCapabilitiesChooser");
+
+  public int chooseCapabilities(Capabilities desired,
+                                Capabilities[] available,
+                                int windowSystemRecommendedChoice) {
+    if (DEBUG) {
+      System.err.println("Desired: " + desired);
+      for (int i = 0; i < available.length; i++) {
+        System.err.println("Available " + i + ": " + available[i]);
+      }
+      System.err.println("Window system's recommended choice: " + windowSystemRecommendedChoice);
+    }
+
+    if (windowSystemRecommendedChoice >= 0 &&
+        windowSystemRecommendedChoice < available.length &&
+        available[windowSystemRecommendedChoice] != null) {
+      if (DEBUG) {
+        System.err.println("Choosing window system's recommended choice of " + windowSystemRecommendedChoice);
+        System.err.println(available[windowSystemRecommendedChoice]);
+      }
+      return windowSystemRecommendedChoice;
+    }
+
+    // Create score array
+    int[] scores = new int[available.length];
+    int NO_SCORE = -9999999;
+    int COLOR_MISMATCH_PENALTY_SCALE     = 36;
+    for (int i = 0; i < scores.length; i++) {
+      scores[i] = NO_SCORE;
+    }
+    // Compute score for each
+    for (int i = 0; i < scores.length; i++) {
+      Capabilities cur = available[i];
+      if (cur == null) {
+        continue;
+      }
+      int score = 0;
+      // Compute difference in color depth
+      score += (COLOR_MISMATCH_PENALTY_SCALE *
+                ((cur.getRedBits() + cur.getGreenBits() + cur.getBlueBits() + cur.getAlphaBits()) -
+                 (desired.getRedBits() + desired.getGreenBits() + desired.getBlueBits() + desired.getAlphaBits())));
+      scores[i] = score;
+    }
+
+    if (DEBUG) {
+      System.err.print("Scores: [");
+      for (int i = 0; i < available.length; i++) {
+        if (i > 0) {
+          System.err.print(",");
+        }
+        System.err.print(" " + scores[i]);
+      }
+      System.err.println(" ]");
+    }
+
+    // Ready to select. Choose score closest to 0. 
+    int scoreClosestToZero = NO_SCORE;
+    int chosenIndex = -1;
+    for (int i = 0; i < scores.length; i++) {
+      int score = scores[i];
+      if (score == NO_SCORE) {
+        continue;
+      }
+      // Don't substitute a positive score for a smaller negative score
+      if ((scoreClosestToZero == NO_SCORE) ||
+          (Math.abs(score) < Math.abs(scoreClosestToZero) &&
+	   ((sign(scoreClosestToZero) < 0) || (sign(score) > 0)))) {
+        scoreClosestToZero = score;
+        chosenIndex = i;
+      }
+    }
+    if (chosenIndex < 0) {
+      throw new NativeWindowException("Unable to select one of the provided Capabilities");
+    }
+    if (DEBUG) {
+      System.err.println("Chosen index: " + chosenIndex);
+      System.err.println("Chosen capabilities:");
+      System.err.println(available[chosenIndex]);
+    }
+
+    return chosenIndex;
+  }
+
+  private static int sign(int score) {
+    if (score < 0) {
+      return -1;
+    }
+    return 1;
+  }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsConfiguration.java b/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsConfiguration.java
new file mode 100644
index 000000000..f88632476
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsConfiguration.java
@@ -0,0 +1,103 @@
+/*
+ * 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 javax.media.nativewindow;
+
+public class DefaultGraphicsConfiguration implements Cloneable, AbstractGraphicsConfiguration {
+    private AbstractGraphicsScreen screen;
+    protected Capabilities capabilitiesChosen;
+    protected Capabilities capabilitiesRequested;
+
+    public DefaultGraphicsConfiguration(AbstractGraphicsScreen screen, 
+                                        Capabilities capsChosen, Capabilities capsRequested) {
+        this.screen = screen;
+        this.capabilitiesChosen = capsChosen;
+        this.capabilitiesRequested = capsRequested;
+    }
+
+    public Object clone() {
+        try {
+          return super.clone();
+        } catch (CloneNotSupportedException e) {
+          throw new NativeWindowException(e);
+        }
+    }
+
+    public AbstractGraphicsScreen getScreen() {
+        return screen;
+    }
+
+    public Capabilities getChosenCapabilities() {
+        return (Capabilities)capabilitiesChosen.clone();
+    }
+
+    public Capabilities getRequestedCapabilities() {
+        return (Capabilities)capabilitiesRequested.clone();
+    }
+
+    public AbstractGraphicsConfiguration getNativeGraphicsConfiguration() {
+        return this;
+    }
+
+    /**
+     * Set the capabilities to a new value.
+     *
+     * The use case for setting the Capabilities at a later time is
+     * a change of the graphics device in a multi-screen environment.<br>
+     *
+     * A copy of the passed object is being used.
+     *
+     * @see javax.media.nativewindow.GraphicsConfigurationFactory#chooseGraphicsConfiguration(Capabilities, CapabilitiesChooser, AbstractGraphicsScreen)
+     */
+    protected void setChosenCapabilities(Capabilities capsChosen) {
+        capabilitiesChosen = (Capabilities) capsChosen.clone();
+    }
+
+    /**
+     * Set a new screen.
+     *
+     * the use case for setting a new screen at a later time is
+     * a change of the graphics device in a multi-screen environment.<br>
+     *
+     * A copy of the passed object is being used.
+     */
+    protected void setScreen(DefaultGraphicsScreen screen) {
+        this.screen = (AbstractGraphicsScreen) screen.clone();
+    }
+
+    public String toString() {
+        return getClass().toString()+"[" + screen +
+                                       ",\n\tchosen    " + capabilitiesChosen+
+                                       ",\n\trequested " + capabilitiesRequested+ 
+                                       "]";
+    }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsDevice.java b/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsDevice.java
new file mode 100644
index 000000000..fdc849d0f
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsDevice.java
@@ -0,0 +1,68 @@
+/*
+ * 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 javax.media.nativewindow;
+
+public class DefaultGraphicsDevice implements Cloneable, AbstractGraphicsDevice {
+    private String type;
+    protected long handle;
+
+    public DefaultGraphicsDevice(String type) {
+        this.type = type;
+        this.handle = 0;
+    }
+
+    public DefaultGraphicsDevice(String type, long handle) {
+        this.type = type;
+        this.handle = handle;
+    }
+
+    public Object clone() {
+        try {
+          return super.clone();
+        } catch (CloneNotSupportedException e) {
+          throw new NativeWindowException(e);
+        }
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public long getHandle() {
+        return handle;
+    }
+
+    public String toString() {
+        return getClass().toString()+"[type "+getType()+", handle 0x"+Long.toHexString(getHandle())+"]";
+    }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsScreen.java b/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsScreen.java
new file mode 100644
index 000000000..0af32c9ec
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/DefaultGraphicsScreen.java
@@ -0,0 +1,71 @@
+/*
+ * 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 javax.media.nativewindow;
+
+public class DefaultGraphicsScreen implements Cloneable, AbstractGraphicsScreen {
+    AbstractGraphicsDevice device;
+    private int idx;
+
+    public DefaultGraphicsScreen(AbstractGraphicsDevice device, int idx) {
+        this.device = device;
+        this.idx = idx;
+    }
+
+    public static AbstractGraphicsScreen createScreenDevice(int screenIdx) {
+        return new DefaultGraphicsScreen(new DefaultGraphicsDevice(NativeWindowFactory.TYPE_DEFAULT), screenIdx);
+    }
+
+    public static AbstractGraphicsScreen createDefault() {
+        return createScreenDevice(0);
+    }
+
+    public Object clone() {
+        try {
+          return super.clone();
+        } catch (CloneNotSupportedException e) {
+          throw new NativeWindowException(e);
+        }
+    }
+
+    public AbstractGraphicsDevice getDevice() {
+        return device;
+    }
+
+    public int getIndex() {
+      return idx;
+    }
+
+    public String toString() {
+        return getClass().toString()+"["+device+", idx "+idx+"]";
+    }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/GraphicsConfigurationFactory.java b/src/nativewindow/classes/javax/media/nativewindow/GraphicsConfigurationFactory.java
new file mode 100644
index 000000000..023a9d488
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/GraphicsConfigurationFactory.java
@@ -0,0 +1,208 @@
+/*
+ * 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 javax.media.nativewindow;
+
+import java.lang.reflect.*;
+import java.util.*;
+
+import com.sun.nativewindow.impl.*;
+
+/**
+ * Provides the mechanism by which the graphics configuration for a
+ * window can be chosen before the window is created. The graphics 
+ * configuration decides parameters related to hardware accelerated rendering such
+ * as the OpenGL pixel format. <br>
+ * On some window systems (EGL/OpenKODE and X11 in particular) it is necessary to
+ * choose the graphics configuration early at window creation time. <br>
+ * Note that the selection of the graphics configuration is an algorithm which does not have
+ * strong dependencies on the particular Java window toolkit in use
+ * (e.g., AWT) and therefore it is strongly desirable to factor this
+ * functionality out of the core {@link NativeWindowFactory} so that
+ * new window toolkits can replace just the {@link
+ * NativeWindowFactory} and reuse the graphics configuration selection
+ * algorithm provided by, for example, an OpenGL binding.
+ */
+
+public abstract class GraphicsConfigurationFactory {
+    protected static final boolean DEBUG = Debug.debug("GraphicsConfiguration");
+
+    private static Map/*<Class, NativeWindowFactory>*/ registeredFactories =
+        Collections.synchronizedMap(new HashMap());
+    private static Class abstractGraphicsDeviceClass;
+
+    static {
+        initialize();
+    }
+
+    /** Creates a new NativeWindowFactory instance. End users do not
+        need to call this method. */
+    protected GraphicsConfigurationFactory() {
+    }
+
+    private static void initialize() {
+        String osName = System.getProperty("os.name");
+        String osNameLowerCase = osName.toLowerCase();
+        String factoryClassName = null;
+
+        abstractGraphicsDeviceClass = javax.media.nativewindow.AbstractGraphicsDevice.class;
+        
+        if (!osNameLowerCase.startsWith("wind") &&
+            !osNameLowerCase.startsWith("mac os x")) {
+            // Assume X11 platform -- should probably test for these explicitly
+            try {
+                GraphicsConfigurationFactory factory = (GraphicsConfigurationFactory)
+                    NWReflection.createInstance("com.sun.nativewindow.impl.x11.X11GraphicsConfigurationFactory", new Object[] {});
+                registerFactory(javax.media.nativewindow.x11.X11GraphicsDevice.class, factory);
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+        // Register the default no-op factory for arbitrary
+        // AbstractGraphicsDevice implementations, including
+        // AWTGraphicsDevice instances -- the OpenGL binding will take
+        // care of handling AWTGraphicsDevices on X11 platforms (as
+        // well as X11GraphicsDevices in non-AWT situations)
+        registerFactory(abstractGraphicsDeviceClass, new GraphicsConfigurationFactoryImpl());
+    }
+
+    /** Returns the factory for use with the given type of
+        AbstractGraphicsDevice. */
+    public static GraphicsConfigurationFactory getFactory(AbstractGraphicsDevice device) {
+        if (device == null) {
+            return getFactory(AbstractGraphicsDevice.class);
+        }
+        return getFactory(device.getClass());
+    }
+
+    /**
+     * Returns the graphics configuration factory for use with the
+     * given class, which must implement the {@link
+     * AbstractGraphicsDevice} interface.
+     *
+     * @throws IllegalArgumentException if the given class does not implement AbstractGraphicsDevice
+     */
+    public static GraphicsConfigurationFactory getFactory(Class abstractGraphicsDeviceImplementor)
+        throws IllegalArgumentException, NativeWindowException
+    {
+        if (!(abstractGraphicsDeviceClass.isAssignableFrom(abstractGraphicsDeviceImplementor))) {
+            throw new IllegalArgumentException("Given class must implement AbstractGraphicsDevice");
+        }
+
+        GraphicsConfigurationFactory factory = null;
+        Class clazz = abstractGraphicsDeviceImplementor;
+        while (clazz != null) {
+            factory =
+                (GraphicsConfigurationFactory) registeredFactories.get(clazz);
+            if (factory != null) {
+                if(DEBUG) {
+                    System.err.println("GraphicsConfigurationFactory.getFactory() "+abstractGraphicsDeviceImplementor+" -> "+factory);
+                }
+                return factory;
+            }
+            clazz = clazz.getSuperclass();
+        }
+        // Return the default
+        factory = (GraphicsConfigurationFactory)registeredFactories.get(abstractGraphicsDeviceClass);
+        if(DEBUG) {
+            System.err.println("GraphicsConfigurationFactory.getFactory() DEFAULT "+abstractGraphicsDeviceClass+" -> "+factory);
+        }
+        return factory;
+    }
+
+    /** Registers a GraphicsConfigurationFactory handling graphics
+     * device objects of the given class. This does not need to be
+     * called by end users, only implementors of new
+     * GraphicsConfigurationFactory subclasses.
+     *
+     * @throws IllegalArgumentException if the given class does not implement AbstractGraphicsDevice
+     */
+    protected static void registerFactory(Class abstractGraphicsDeviceImplementor, GraphicsConfigurationFactory factory)
+        throws IllegalArgumentException
+    {
+        if (!(abstractGraphicsDeviceClass.isAssignableFrom(abstractGraphicsDeviceImplementor))) {
+            throw new IllegalArgumentException("Given class must implement AbstractGraphicsDevice");
+        }
+        if(DEBUG) {
+            System.err.println("GraphicsConfigurationFactory.registerFactory() "+abstractGraphicsDeviceImplementor+" -> "+factory);
+        }
+        registeredFactories.put(abstractGraphicsDeviceImplementor, factory);
+    }
+
+    /**
+     * <P> Selects a graphics configuration on the specified graphics
+     * device compatible with the supplied {@link Capabilities}. Some
+     * platforms (e.g.: X11, EGL, KD) require the graphics configuration
+     * to be specified when the native window is created. 
+     * These architectures have seperated their device, screen, window and drawable
+     * context and hence are capable of quering the capabilities for each screen.
+     * A fully established window is not required.</P>
+     *
+     * <P>Other platforms (e.g. Windows, MacOSX) don't offer the mentioned seperation
+     * and hence need a fully established window and it's drawable.
+     * Here the validation of the capabilities is performed later.
+     * In this case, the AbstractGraphicsConfiguration implementation 
+     * must allow an overwrite of the Capabilites, for example
+     * {@link DefaultGraphicsConfiguration#setChosenCapabilities DefaultGraphicsConfiguration.setChosenCapabilities(..)}.
+     * </P>
+     *
+     * <P>
+     * This method is mainly intended to be both used and implemented by the
+     * OpenGL binding.</P>
+     *
+     * <P> The concrete data type of the passed graphics device and
+     * returned graphics configuration must be specified in the
+     * documentation binding this particular API to the underlying
+     * window toolkit. The Reference Implementation accepts {@link
+     * javax.media.nativewindow.awt.AWTGraphicsDevice AWTGraphicsDevice} objects and returns {@link
+     * javax.media.nativewindow.awt.AWTGraphicsConfiguration AWTGraphicsConfiguration} objects. On
+     * X11 platforms where the AWT is not in use, it also accepts
+     * {@link javax.media.nativewindow.x11.X11GraphicsDevice
+     * X11GraphicsDevice} objects and returns {@link
+     * javax.media.nativewindow.x11.X11GraphicsConfiguration
+     * X11GraphicsConfiguration} objects.</P>
+     *
+     * @throws IllegalArgumentException if the data type of the passed
+     *         AbstractGraphicsDevice is not supported by this
+     *         NativeWindowFactory.
+     * @throws NativeWindowException if any window system-specific errors caused
+     *         the selection of the graphics configuration to fail.
+     *
+     * @see javax.media.nativewindow.GraphicsConfigurationFactory#chooseGraphicsConfiguration(Capabilities, CapabilitiesChooser, AbstractGraphicsScreen)
+     * @see javax.media.nativewindow.DefaultGraphicsConfiguration#setChosenCapabilities(Capabilities caps)
+     */
+    public abstract AbstractGraphicsConfiguration
+        chooseGraphicsConfiguration(Capabilities capabilities,
+                                    CapabilitiesChooser chooser,
+                                    AbstractGraphicsScreen screen)
+        throws IllegalArgumentException, NativeWindowException;
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/NativeWindow.java b/src/nativewindow/classes/javax/media/nativewindow/NativeWindow.java
new file mode 100644
index 000000000..2a9782c12
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/NativeWindow.java
@@ -0,0 +1,176 @@
+/*
+ * 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 javax.media.nativewindow;
+
+/** Provides the low-level information required for
+    hardware-accelerated rendering in a platform-independent manner. A
+    window toolkit such as the AWT may either implement this interface
+    directly with one of its components, or provide and register an
+    implementation of {@link NativeWindowFactory NativeWindowFactory}
+    which can create NativeWindow objects for its components. <P>
+
+    A NativeWindow created for a particular on-screen component is
+    expected to have the same lifetime as that component. As long as
+    the component is alive, the NativeWindow must be able to control
+    it, and any time it is visible and locked, provide information
+    such as the window handle.
+*/
+public interface NativeWindow {
+  /** Returned by {@link #lockSurface()} if the surface is not ready to be locked. */
+  public static final int LOCK_SURFACE_NOT_READY = 1;
+
+  /** Returned by {@link #lockSurface()} if the surface is locked, but has changed. */
+  public static final int LOCK_SURFACE_CHANGED = 2;
+
+  /** Returned by {@link #lockSurface()} if the surface is locked, and is unchanged. */
+  public static final int LOCK_SUCCESS = 3;
+
+  /**
+   * Lock the surface of this native window<P>
+   *
+   * The window handle, see {@link #getWindowHandle()},
+   * and the surface handle, see {@link #lockSurface()}, <br>
+   * shall be set and be valid after a successfull call,
+   * ie a return value other than {@link #LOCK_SURFACE_NOT_READY}.<P>
+   *
+   * The semantics of the underlying native locked resource
+   * may be related to the {@link ToolkitLock} one. Hence it is 
+   * important that implementation of both harmonize well.<br>
+   * The implementation may want to aquire the {@link ToolkitLock}
+   * first to become it's owner before proceeding with it's
+   * actual surface lock. <P>
+   *
+   * @return {@link #LOCK_SUCCESS}, {@link #LOCK_SURFACE_CHANGED} or {@link #LOCK_SURFACE_NOT_READY}.
+   *
+   * @throws NativeWindowException if surface is already locked
+   *
+   * @see ToolkitLock
+   */
+  public int lockSurface() throws NativeWindowException ;
+
+  /**
+   * Unlock the surface of this native window
+   *
+   * Shall not modify the window handle, see {@link #getWindowHandle()},
+   * or the surface handle, see {@link #lockSurface()} <P>
+   *
+   * @throws NativeWindowException if surface is not locked
+   *
+   * @see #lockSurface
+   * @see ToolkitLock
+   */
+  public void unlockSurface() throws NativeWindowException ;
+
+  /**
+   * Return if surface is locked
+   */
+  public boolean isSurfaceLocked();
+
+  /**
+   * Return the lock-exception, or null if not locked.
+   *
+   * The lock-exception is created at {@link #lockSurface()}
+   * and hence holds the locker's call stack.
+   */
+  public Exception getLockedStack();
+
+  /** 
+   * render all native window information invalid,
+   * as if the native window was destroyed
+   */
+  public void invalidate();
+
+  /**
+   * Returns the window handle for this NativeWindow. <P>
+   *
+   * The window handle should be set/update by {@link #lockSurface()},
+   * where {@link #unlockSurface()} is not allowed to modify it.<br>
+   * After {@link #unlockSurface()} it is no more guaranteed 
+   * that the window handle is still valid.<p>
+   *
+   * The window handle shall reflect the platform one 
+   * for all window related operations, e.g. open, close, resize. <P>
+   *
+   * On X11 this returns an entity of type Window. <BR>
+   * On Microsoft Windows this returns an entity of type HWND. 
+   */
+  public long getWindowHandle();
+
+  /**
+   * Returns the handle to the surface for this NativeWindow. <P>
+   * 
+   * The surface handle should be set/update by {@link #lockSurface()},
+   * where {@link #unlockSurface()} is not allowed to modify it.
+   * After {@link #unlockSurface()} it is no more guaranteed 
+   * that the surface handle is still valid.
+   *
+   * The surface handle shall reflect the platform one
+   * for all drawable surface operations, e.g. opengl, swap-buffer. <P>
+   *
+   * On X11 this returns an entity of type Window,
+   * since there is no differentiation of surface and window there. <BR>
+   * On Microsoft Windows this returns an entity of type HDC.
+   */
+  public long getSurfaceHandle();
+
+  /** Returns the current width of this window. */
+  public int getWidth();
+
+  /** Returns the current height of this window. */
+  public int getHeight();
+
+  /**
+   * Returns the graphics configuration corresponding to this window.
+   * @see javax.media.nativewindow.GraphicsConfigurationFactory#chooseGraphicsConfiguration(Capabilities, CapabilitiesChooser, AbstractGraphicsScreen)
+   */
+  public AbstractGraphicsConfiguration getGraphicsConfiguration();
+
+  /**
+   * Convenience: Get display handle from 
+   *   AbstractGraphicsConfiguration . AbstractGraphicsScreen . AbstractGraphicsDevice
+   */
+  public long getDisplayHandle();
+
+  /**
+   * Convenience: Get display handle from 
+   *   AbstractGraphicsConfiguration . AbstractGraphicsScreen
+   */
+  public int  getScreenIndex();
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/NativeWindowException.java b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowException.java
new file mode 100644
index 000000000..593c1e7d6
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowException.java
@@ -0,0 +1,68 @@
+/*
+ * 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 javax.media.nativewindow;
+
+/** A generic exception for OpenGL errors used throughout the binding
+    as a substitute for {@link RuntimeException}. */
+
+public class NativeWindowException extends RuntimeException {
+  /** Constructs a NativeWindowException object. */
+  public NativeWindowException() {
+    super();
+  }
+
+  /** Constructs a NativeWindowException object with the specified detail
+      message. */
+  public NativeWindowException(String message) {
+    super(message);
+  }
+
+  /** Constructs a NativeWindowException object with the specified detail
+      message and root cause. */
+  public NativeWindowException(String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  /** Constructs a NativeWindowException object with the specified root
+      cause. */
+  public NativeWindowException(Throwable cause) {
+    super(cause);
+  }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
new file mode 100644
index 000000000..39ec18bc4
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
@@ -0,0 +1,352 @@
+/*
+ * 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 javax.media.nativewindow;
+
+import java.lang.reflect.*;
+import java.security.*;
+import java.util.*;
+
+import com.sun.nativewindow.impl.*;
+
+/** Provides a pluggable mechanism for arbitrary window toolkits to
+    adapt their components to the {@link NativeWindow} interface,
+    which provides a platform-independent mechanism of accessing the
+    information required to perform operations like
+    hardware-accelerated rendering using the OpenGL API. */
+
+public abstract class NativeWindowFactory {
+    protected static final boolean DEBUG = Debug.debug("NativeWindow");
+
+    /** OpenKODE/EGL type */
+    public static final String TYPE_EGL = "EGL";
+
+    /** Microsoft Windows type */
+    public static final String TYPE_WINDOWS = "Windows";
+
+    /** X11 type */
+    public static final String TYPE_X11 = "X11";
+
+    /** Mac OS X type */
+    public static final String TYPE_MACOSX = "MacOSX";
+
+    /** Generic AWT type */
+    public static final String TYPE_AWT = "AWT";
+
+    /** Generic DEFAULT type, where platform implementation don't care */
+    public static final String TYPE_DEFAULT = "default";
+
+    private static NativeWindowFactory defaultFactory;
+    private static Map/*<Class, NativeWindowFactory>*/ registeredFactories;
+    private static Class nativeWindowClass;
+    private static String nativeWindowingTypePure;
+    private static String nativeOSNamePure;
+    private static String nativeWindowingTypeCustom;
+    private static String nativeOSNameCustom;
+
+    /** Creates a new NativeWindowFactory instance. End users do not
+        need to call this method. */
+    protected NativeWindowFactory() {
+    }
+
+    private static String _getNativeWindowingType(String osNameLowerCase) {
+        if (osNameLowerCase.startsWith("kd")) {
+              return TYPE_EGL;
+        } else if (osNameLowerCase.startsWith("wind")) {
+              return TYPE_WINDOWS;
+        } else if (osNameLowerCase.startsWith("mac os x") ||
+                     osNameLowerCase.startsWith("darwin")) {
+              return TYPE_MACOSX;
+        } else if (osNameLowerCase.equals("awt")) {
+              return TYPE_AWT;
+        } else {
+              return TYPE_X11;
+        }
+    }
+
+    static {
+        // Gather the windowing OS first
+        nativeOSNamePure = System.getProperty("os.name");
+        nativeOSNameCustom = System.getProperty("nativewindow.ws.name");
+        if(null==nativeOSNameCustom||nativeOSNameCustom.length()==0) {
+              nativeOSNameCustom = nativeOSNamePure;
+        }
+        nativeWindowingTypePure = _getNativeWindowingType(nativeOSNamePure.toLowerCase());
+        nativeWindowingTypeCustom = _getNativeWindowingType(nativeOSNameCustom.toLowerCase());
+
+        registeredFactories = Collections.synchronizedMap(new HashMap());
+
+        String factoryClassName = null;
+
+        // register our default factory -> NativeWindow
+        NativeWindowFactory factory = new NativeWindowFactoryImpl();
+        nativeWindowClass = javax.media.nativewindow.NativeWindow.class;
+        registerFactory(nativeWindowClass, factory);
+        defaultFactory = factory;
+    
+        // We break compile-time dependencies on the AWT here to
+        // make it easier to run this code on mobile devices
+
+        Class componentClass = null;
+        if ( NWReflection.isClassAvailable("java.awt.Component") &&
+             NWReflection.isClassAvailable("javax.media.nativewindow.awt.AWTGraphicsDevice") ) {
+            try {
+                componentClass = NWReflection.getClass("java.awt.Component", false);
+            } catch (Exception e) { }
+        }
+
+        boolean toolkitLockDisabled = Boolean.getBoolean("nativewindow.toolkitlock.disabled"); // test ..
+        
+        if(TYPE_X11.equals(nativeWindowingTypeCustom) && !toolkitLockDisabled) {
+            NativeWindowFactory _factory = null;
+
+            // FIXME: there are regressions in functionality in the
+            // JOGL 2 rewrite compared to JOGL 1.1.1 which are
+            // described in the writeup below.
+            //
+            // There are certain operations that may be done by
+            // user-level native code which must share the display
+            // connection with the underlying window toolkit. In JOGL,
+            // for example, the AWT GLCanvas makes GLX and OpenGL
+            // calls against an X Drawable that was created by the
+            // AWT. In this case, the AWT Native Interface ("JAWT") is
+            // used to lock and unlock this surface, which grabs and
+            // releases a lock which is also used internally to the
+            // AWT implementation. This is required because the AWT
+            // makes X calls from multiple threads: for example, the
+            // AWT Toolkit thread and one or more Event Dispatch
+            // Threads.
+            // CHECK: OK
+            //
+            // In the JOGL API, there are other operations that use an
+            // X display connection which do not involve locking an
+            // on-screen window created by the toolkit: visual
+            // selection, pbuffers, external contexts and external
+            // drawables.
+            //
+            // The JOGL GLPbuffer implementation uses its own display
+            // connection via "XOpenDisplay(null)". This was true even
+            // in JOGL 1.1.1. It is believed, but not 100% clear,
+            // whether X implementations are robust enough to handle
+            // the opening of a new display connection in a
+            // multithreaded fashion with no synchronization.
+            // (Semantically this should be allowed, but practically,
+            // it is unclear.) Currently the JOGL implementation locks
+            // the ToolkitLock around pbuffer-related operations.
+            // CHECK: OK - Using X11GraphicsScreen.createDefault() now,
+            //        utilizing one display per thread.
+            //        However, locking code is still intact.
+            //        FIXME: Shall it really have one new display per 
+            //               Pbuffer ?
+            //
+            // Even if the pbuffer case is over-synchronized, there
+            // are definitely cases where synchronization with the
+            // toolkit is required. From recollection, visual
+            // selection is performed outside of the cover of the
+            // toolkit's lock, and the toolkit's display connection is
+            // used for this operation, so for correctness the toolkit
+            // must be locked during glXChooseFBConfig /
+            // glXChooseVisual. Synchronization with the toolkit is
+            // definitely needed for support of external GLDrawables,
+            // where JOGL creates additional OpenGL contexts on a
+            // surface that was created by a third party. External
+            // GLDrawables are the foundation of the Java 2D / JOGL
+            // bridge. While this bridge may be historical at this
+            // point, support for external GLDrawables on platforms
+            // that can support them (namely, WGL and X11 platforms;
+            // Mac OS X does not currently have the required
+            // primitives in its OpenGL window system binding) makes
+            // the JOGL library more powerful.
+            // 
+            // (FIXME: from code examination, it looks like there are
+            // regressions in the support for external GLDrawables in
+            // JOGL 2 compared to JOGL 1.1.1. Note that the "default"
+            // X display connection from X11Util is being used during
+            // construction of the X11ExternalGLXDrawable instead of
+            // the result of glXGetCurrentDisplay().)
+            //
+            // The X11AWTNativeWindowFactory provides a locking
+            // mechanism compatible with the AWT. It may be desirable
+            // to replace this window factory when using third-party
+            // toolkits like Newt even when running on Java SE when
+            // the AWT is available.
+
+            if (componentClass != null) {
+                try {
+                    Constructor factoryConstructor =
+                        NWReflection.getConstructor("com.sun.nativewindow.impl.x11.awt.X11AWTNativeWindowFactory", new Class[] {});
+                    _factory = (NativeWindowFactory) factoryConstructor.newInstance(null);
+                } catch (Exception e) { }
+            }
+
+            // If it turns out that the AWT is not available, for
+            // example on embedded profiles (CDC / FP), then
+            // synchronization is still needed, for example among
+            // multiple threads that might create pbuffers 
+            // or for threads using the static default display to query information. 
+            // The X11NativeWindowFactory provides a simple reentrant lock
+            // for this purpose. It is expected that third-party
+            // toolkits will either replace this factory, and thereby
+            // the implementation of this lock, if stronger
+            // interoperability is desired, for example full support
+            // for external GLDrawables.
+            if (null ==_factory) {
+                // Try the non-AWT X11 native window factory
+                try {
+                    Constructor factoryConstructor =
+                        NWReflection.getConstructor("com.sun.nativewindow.impl.x11.X11NativeWindowFactory", new Class[] {});
+                    _factory = (NativeWindowFactory) factoryConstructor.newInstance(null);
+                } catch (Exception e) { }
+            }
+
+            if (null !=_factory) {
+                factory = _factory;
+            }
+        }
+
+        if(null!=componentClass) {
+            // register either our default factory or (if exist) the X11/AWT one -> AWT Component
+            registerFactory(componentClass, factory);
+        }
+        defaultFactory = factory;
+        if(DEBUG) {
+            System.err.println("NativeWindowFactory defaultFactory "+factory);
+        }
+    }
+
+    public static String getNativeOSName(boolean useCustom) {
+        return useCustom?nativeOSNameCustom:nativeOSNamePure;
+    }
+
+    public static String getNativeWindowType(boolean useCustom) {
+        return useCustom?nativeWindowingTypeCustom:nativeWindowingTypePure;
+    }
+
+    /** Sets the default NativeWindowFactory. Certain operations on
+        X11 platforms require synchronization, and the implementation
+        of this synchronization may be specific to the window toolkit
+        in use. It is impractical to require that all of the APIs that
+        might require synchronization receive a {@link ToolkitLock
+        ToolkitLock} as argument. For this reason the concept of a
+        default NativeWindowFactory is introduced. The toolkit lock
+        provided via {@link #getToolkitLock getToolkitLock} from this
+        default NativeWindowFactory will be used for synchronization
+        within the Java binding to OpenGL. By default, if the AWT is
+        available, the default toolkit will support the AWT. */
+    public static void setDefaultFactory(NativeWindowFactory factory) {
+        defaultFactory = factory;
+    }
+
+    /** Gets the default NativeWindowFactory. Certain operations on
+        X11 platforms require synchronization, and the implementation
+        of this synchronization may be specific to the window toolkit
+        in use. It is impractical to require that all of the APIs that
+        might require synchronization receive a {@link ToolkitLock
+        ToolkitLock} as argument. For this reason the concept of a
+        default NativeWindowFactory is introduced. The toolkit lock
+        provided via {@link #getToolkitLock getToolkitLock} from this
+        default NativeWindowFactory will be used for synchronization
+        within the Java binding to OpenGL. By default, if the AWT is
+        available, the default toolkit will support the AWT. */
+    public static NativeWindowFactory getDefaultFactory() {
+        return defaultFactory;
+    }
+
+    /** Returns the appropriate NativeWindowFactory to handle window
+        objects of the given type. The windowClass might be {@link
+        NativeWindow NativeWindow}, in which case the client has
+        already assumed the responsibility of creating a compatible
+        NativeWindow implementation, or it might be that of a toolkit
+        class like {@link java.awt.Component Component}. */
+    public static NativeWindowFactory getFactory(Class windowClass) throws IllegalArgumentException {
+        if (nativeWindowClass.isAssignableFrom(windowClass)) {
+            return (NativeWindowFactory) registeredFactories.get(nativeWindowClass);
+        }
+        Class clazz = windowClass;
+        while (clazz != null) {
+            NativeWindowFactory factory = (NativeWindowFactory) registeredFactories.get(clazz);
+            if (factory != null) {
+                return factory;
+            }
+            clazz = clazz.getSuperclass();
+        }
+        throw new IllegalArgumentException("No registered NativeWindowFactory for class " + windowClass.getName());
+    }
+
+    /** Registers a NativeWindowFactory handling window objects of the
+        given class. This does not need to be called by end users,
+        only implementors of new NativeWindowFactory subclasses. */
+    protected static void registerFactory(Class windowClass, NativeWindowFactory factory) {
+        if(DEBUG) {
+            System.err.println("NativeWindowFactory.registerFactory() "+windowClass+" -> "+factory);
+        }
+        registeredFactories.put(windowClass, factory);
+    }
+
+    /** Converts the given window object and it's
+        {@link AbstractGraphicsConfiguration AbstractGraphicsConfiguration} into a 
+        {@link NativeWindow NativeWindow} which can be operated upon by a custom
+        toolkit, e.g. {@link javax.media.opengl.GLDrawableFactory javax.media.opengl.GLDrawableFactory}.<br>
+        The object may be a component for a particular window toolkit, such as an AWT
+        Canvas.  It may also be a NativeWindow object itself.<br>
+        You shall utilize {@link javax.media.nativewindow.GraphicsConfigurationFactory GraphicsConfigurationFactory}
+        to construct a proper {@link AbstractGraphicsConfiguration AbstractGraphicsConfiguration}.<br>
+        The particular implementation of the
+        NativeWindowFactory is responsible for handling objects from a
+        particular window toolkit. The built-in NativeWindowFactory
+        handles NativeWindow instances as well as AWT Components.<br>
+    
+        @throws IllegalArgumentException if the given window object
+        could not be handled by any of the registered
+        NativeWindowFactory instances
+
+        @see javax.media.nativewindow.GraphicsConfigurationFactory#chooseGraphicsConfiguration(Capabilities, CapabilitiesChooser, AbstractGraphicsScreen)
+    */
+    public static NativeWindow getNativeWindow(Object winObj, AbstractGraphicsConfiguration config) throws IllegalArgumentException, NativeWindowException {
+        if (winObj == null) {
+            throw new IllegalArgumentException("Null window object");
+        }
+
+        return getFactory(winObj.getClass()).getNativeWindowImpl(winObj, config);
+    }
+
+    /** Performs the conversion from a toolkit's window object to a
+        NativeWindow. Implementors of concrete NativeWindowFactory
+        subclasses should override this method. */
+    protected abstract NativeWindow getNativeWindowImpl(Object winObj, AbstractGraphicsConfiguration config) throws IllegalArgumentException;
+
+    /** Returns the object which provides support for synchronizing
+        with the underlying window toolkit.<br>
+        @see ToolkitLock
+      */
+    public abstract ToolkitLock getToolkitLock();
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/ToolkitLock.java b/src/nativewindow/classes/javax/media/nativewindow/ToolkitLock.java
new file mode 100644
index 000000000..27e59d8c8
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/ToolkitLock.java
@@ -0,0 +1,73 @@
+/*
+ * 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 javax.media.nativewindow;
+
+/** Provides an interface for locking and unlocking the underlying
+    window toolkit, where this is necessary in the OpenGL
+    implementation. This mechanism is generally only needed on X11
+    platforms. Currently it is only used when the AWT is in use.
+    Implementations of this lock, if they are not no-ops, must support
+    reentrant locking and unlocking. <P>
+    
+    The ToolkitLock implementation can be aquired by 
+    {@link NativeWindowFactory#getToolkitLock NativeWindowFactory's getToolkitLock()}.<P>
+
+    All toolkit shared resources shall be accessed by encapsulating the
+    code with a locking block as follows.
+    <PRE>
+    NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
+    try {
+      long displayHandle = X11Util.getStaticDefaultDisplay();
+      ...
+    } finally {
+      NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
+    }
+    </PRE><P>
+
+    The underlying toolkit's locking mechanism may relate to {@link NativeWindow}'s 
+    {@link NativeWindow#lockSurface lockSurface()}. Hence it is important
+    that both implementation harmonize well, ie {@link NativeWindow#lockSurface lockSurface()}
+    shall issue a ToolkitLock lock befor it aquires it's surface lock. This is true
+    in the AWT implementation for example. Otherwise the surface lock would <i>steal</i>
+    the ToolkitLock's lock and a deadlock would be unavoidable.<P>
+
+    However the necessity of needing a global state synchronization will of course
+    impact your performance very much, especially in case of a multithreaded/multiwindow case.
+    */
+public interface ToolkitLock {
+    /** Locks the toolkit. */
+    public void lock();
+
+    /** Unlocks the toolkit. */
+    public void unlock();
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsConfiguration.java b/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsConfiguration.java
new file mode 100644
index 000000000..7373e7b97
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsConfiguration.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 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 javax.media.nativewindow.awt;
+
+import javax.media.nativewindow.*;
+import java.awt.GraphicsConfiguration;
+import java.awt.Transparency;
+import java.awt.image.ColorModel;
+import javax.media.nativewindow.AbstractGraphicsConfiguration;
+import com.sun.nativewindow.impl.Debug;
+
+/** A wrapper for an AWT GraphicsConfiguration allowing it to be
+    handled in a toolkit-independent manner. */
+
+public class AWTGraphicsConfiguration extends DefaultGraphicsConfiguration implements Cloneable {
+  private GraphicsConfiguration config;
+  AbstractGraphicsConfiguration encapsulated;
+
+  public AWTGraphicsConfiguration(AWTGraphicsScreen screen, 
+                                  Capabilities capsChosen, Capabilities capsRequested,
+                                  GraphicsConfiguration config, AbstractGraphicsConfiguration encapsulated) {
+    super(screen, capsChosen, capsRequested);
+    this.config = config;
+    this.encapsulated=encapsulated;
+  }
+
+  public AWTGraphicsConfiguration(AWTGraphicsScreen screen, Capabilities capsChosen, Capabilities capsRequested, GraphicsConfiguration config) {
+    super(screen, capsChosen, capsRequested);
+    this.config = config;
+    this.encapsulated=null;
+  }
+
+  public Object clone() {
+      return super.clone();
+  }
+
+  public GraphicsConfiguration getGraphicsConfiguration() {
+    return config;
+  }
+
+  public AbstractGraphicsConfiguration getNativeGraphicsConfiguration() {
+    return (null!=encapsulated)?encapsulated:this;
+  }
+
+  /**
+   * Sets up the Capabilities' RGBA size based on the given GraphicsConfiguration's ColorModel.
+   *
+   * @param capabilities the Capabilities object whose red, green, blue, and alpha bits will be set
+   * @param gc the GraphicsConfiguration from which to derive the RGBA bit depths
+   * @return the passed Capabilities
+   */
+  public static Capabilities setupCapabilitiesRGBABits(Capabilities capabilities, GraphicsConfiguration gc) {
+    int cmTransparency = capabilities.isBackgroundOpaque()?Transparency.OPAQUE:Transparency.TRANSLUCENT;
+    ColorModel cm = gc.getColorModel(cmTransparency);
+    if(null==cm && !capabilities.isBackgroundOpaque()) {
+        capabilities.setBackgroundOpaque(true);
+        cmTransparency = Transparency.OPAQUE;
+        cm = gc.getColorModel(cmTransparency);
+    }
+    if(null==cm) {
+        throw new NativeWindowException("Could not determine AWT ColorModel");
+    }
+    int cmBitsPerPixel = cm.getPixelSize();
+    int bitsPerPixel = 0;
+    int[] bitesPerComponent = cm.getComponentSize();
+    if(bitesPerComponent.length>=3) {
+        capabilities.setRedBits(bitesPerComponent[0]);
+        bitsPerPixel += bitesPerComponent[0];
+        capabilities.setGreenBits(bitesPerComponent[1]);
+        bitsPerPixel += bitesPerComponent[1];
+        capabilities.setBlueBits(bitesPerComponent[2]);
+        bitsPerPixel += bitesPerComponent[2];
+    }
+    if(bitesPerComponent.length>=4) {
+        capabilities.setAlphaBits(bitesPerComponent[3]);
+        bitsPerPixel += bitesPerComponent[3];
+    } else {
+        capabilities.setAlphaBits(0);
+    }
+    if(Debug.debugAll()) {
+        if(cmBitsPerPixel!=bitsPerPixel) {
+            System.err.println("AWT Colormodel bits per components/pixel mismatch: "+bitsPerPixel+" != "+cmBitsPerPixel);
+        }
+    }
+    return capabilities;
+  }
+
+  public String toString() {
+    return getClass().toString()+"[" + getScreen() + 
+                                   ",\n\tchosen    " + capabilitiesChosen+
+                                   ",\n\trequested " + capabilitiesRequested+ 
+                                   ",\n\t" + config +
+                                   ",\n\tencapsulated "+encapsulated+"]";
+  }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsDevice.java b/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsDevice.java
new file mode 100644
index 000000000..077cbf8aa
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsDevice.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 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 javax.media.nativewindow.awt;
+
+import javax.media.nativewindow.*;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import javax.media.nativewindow.AbstractGraphicsDevice;
+import com.sun.nativewindow.impl.*;
+
+/** A wrapper for an AWT GraphicsDevice allowing it to be
+    handled in a toolkit-independent manner. */
+
+public class AWTGraphicsDevice extends DefaultGraphicsDevice implements Cloneable {
+  private GraphicsDevice device;
+
+  protected AWTGraphicsDevice(GraphicsDevice device) {
+    super(NativeWindowFactory.TYPE_AWT);
+    this.device = device;
+  }
+
+  public static AbstractGraphicsDevice createDevice(GraphicsDevice awtDevice) {
+    if(null==awtDevice) {
+        awtDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
+    }
+    return new AWTGraphicsDevice(awtDevice);
+  }
+
+  public Object clone() {
+      return super.clone();
+  }
+
+  public GraphicsDevice getGraphicsDevice() {
+    return device;
+  }
+
+  /**
+   * In case the native handle was specified, e.g. using X11,
+   * we shall be able to mark it.
+   */
+  public void setHandle(long handle) {
+    this.handle = handle;
+  }
+
+  public String toString() {
+    return getClass().toString()+"[type "+getType()+", awtDevice "+device+", handle 0x"+Long.toHexString(getHandle())+"]";
+  }
+}
+
diff --git a/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsScreen.java b/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsScreen.java
new file mode 100644
index 000000000..2ad8a99af
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/awt/AWTGraphicsScreen.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 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 javax.media.nativewindow.awt;
+
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import javax.media.nativewindow.*;
+import javax.media.nativewindow.AbstractGraphicsDevice;
+import com.sun.nativewindow.impl.*;
+
+/** A wrapper for an AWT GraphicsDevice (screen) allowing it to be
+    handled in a toolkit-independent manner. */
+
+public class AWTGraphicsScreen extends DefaultGraphicsScreen implements Cloneable {
+
+  public AWTGraphicsScreen(AWTGraphicsDevice device) {
+    super(device, findScreenIndex(device.getGraphicsDevice()));
+  }
+
+  public static GraphicsDevice getScreenDevice(int index) {
+    if(index<0) return null;
+    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+    GraphicsDevice[] gs = ge.getScreenDevices();
+    if(index<gs.length) {
+        return gs[index];
+    }
+    return null;
+  }
+
+  public static int findScreenIndex(GraphicsDevice awtDevice) {
+    if(null==awtDevice) return -1;
+    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+    GraphicsDevice[] gs = ge.getScreenDevices();
+    for (int j = 0; j < gs.length; j++) {
+        if(gs[j] == awtDevice) return j;
+    }
+    return -1;
+  }
+
+  public static AbstractGraphicsScreen createScreenDevice(GraphicsDevice awtDevice) {
+    AWTGraphicsDevice device = (AWTGraphicsDevice) AWTGraphicsDevice.createDevice(awtDevice);
+    return new AWTGraphicsScreen(device);
+  }
+
+  public static AbstractGraphicsScreen createScreenDevice(int index) {
+    GraphicsDevice awtDevice = getScreenDevice(index);
+    return createScreenDevice(awtDevice);
+  }
+
+  public static AbstractGraphicsScreen createDefault() {
+    return createScreenDevice(-1);
+  }
+
+  public Object clone() {
+      return super.clone();
+  }
+}
+
diff --git a/src/nativewindow/classes/javax/media/nativewindow/egl/EGLGraphicsDevice.java b/src/nativewindow/classes/javax/media/nativewindow/egl/EGLGraphicsDevice.java
new file mode 100644
index 000000000..49c337359
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/egl/EGLGraphicsDevice.java
@@ -0,0 +1,50 @@
+/*
+ * 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 javax.media.nativewindow.egl;
+
+import javax.media.nativewindow.*;
+
+/** Encapsulates a graphics device on EGL platforms.
+ */
+
+public class EGLGraphicsDevice extends DefaultGraphicsDevice implements Cloneable {
+    /** Constructs a new EGLGraphicsDevice corresponding to the given EGL display handle. */
+    public EGLGraphicsDevice(long eglDisplay) {
+        super(NativeWindowFactory.TYPE_EGL, eglDisplay);
+    }
+
+    public Object clone() {
+      return super.clone();
+    }
+}
+
diff --git a/src/nativewindow/classes/javax/media/nativewindow/macosx/MacOSXGraphicsDevice.java b/src/nativewindow/classes/javax/media/nativewindow/macosx/MacOSXGraphicsDevice.java
new file mode 100644
index 000000000..3669ebd12
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/macosx/MacOSXGraphicsDevice.java
@@ -0,0 +1,50 @@
+/*
+ * 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 javax.media.nativewindow.macosx;
+
+import javax.media.nativewindow.*;
+
+/** Encapsulates a graphics device on MacOSX platforms.
+ */
+
+public class MacOSXGraphicsDevice extends DefaultGraphicsDevice implements Cloneable {
+    /** Constructs a new MacOSXGraphicsDevice */
+    public MacOSXGraphicsDevice() {
+        super(NativeWindowFactory.TYPE_MACOSX);
+    }
+
+    public Object clone() {
+      return super.clone();
+    }
+}
+
diff --git a/src/nativewindow/classes/javax/media/nativewindow/package.html b/src/nativewindow/classes/javax/media/nativewindow/package.html
new file mode 100644
index 000000000..ce9dbbb7a
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/package.html
@@ -0,0 +1,111 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+  <title>NativeWindow Protocol Draft Public Review Specification</title>
+</head>
+  <body>
+   
+<h2><i>NativeWindow Protocol</i> Specification Overview</h2>
+   
+<h3>Preface</h3>
+  This specification, an optional set of packages, describing a <i>protocol</i> for a 
+  <i>native windowing interface</i> binding to Java(TM).<br>
+  Currently specified <i>native windowing systems</i> are:<br><br>
+  <ul>
+    <li> EGL/OpenKODE Windowing System</li>
+    <li> X11 Windowing System</li>
+    <li> Microsoft Windows</li>
+    <li> Apple MacOSX</li>
+    <li> Java's AWT</li>
+  </ul>
+  <br>
+  However, any other native windowing system may be added to the implementation,
+  using a generic string identifier and an optional specialisation of:<br><br>
+  <ul>
+    <li>{@link javax.media.nativewindow.AbstractGraphicsDevice AbstractGraphicsDevice},<br>
+       <br>
+       Shall return the new string identifier with {@link javax.media.nativewindow.AbstractGraphicsDevice#getType() getType()}</li><br>
+    <li>{@link javax.media.nativewindow.AbstractGraphicsScreen AbstractGraphicsScreen}</li>
+    <li>{@link javax.media.nativewindow.AbstractGraphicsConfiguration AbstractGraphicsConfiguration}</li><br>
+  </ul>
+  <br>
+  The implementor has to provide the following:<br><br>
+  <ul>
+    <li> The specialisation of the abstract class {@link javax.media.nativewindow.NativeWindowFactory NativeWindowFactory}<br>
+         <br>
+         shall be registered with {@link javax.media.nativewindow.NativeWindowFactory#registerFactory NativeWindowFactory.registerFactory(..)}.</li><br>
+
+    <li> The specialisation of the abstract class {@link javax.media.nativewindow.GraphicsConfigurationFactory GraphicsConfigurationFactory}<br>
+         <br>
+         shall be registered with {@link javax.media.nativewindow.GraphicsConfigurationFactory#registerFactory GraphicsConfigurationFactory.registerFactory(..)}.</li><br>
+  </ul><br>
+  This protocol <i>does not</i> describe how to <i>create</i> native windows, but how to <i>bind</i> a native window to an implementation of
+  {@link javax.media.nativewindow.NativeWindow NativeWindow}.<br>
+  However, an implementation of this protocol (e.g. {@link com.sun.javafx.newt}) may support the creation.<br>
+   
+<h3>Dependencies</h3>
+  This binding has dependencies to the following:<br><br>
+  <ul>
+    <li> Either of the following Java implementations:<br>
+    <ul>
+        <li> <a href="http://java.sun.com/j2se/1.4.2/docs/api/">Java SE 1.4 or later</a> </li><br>
+        <li> <a href="http://java.sun.com/javame/technology/cdc/">Java ME CDC 1.1.2 (JSR 218)</a> and 
+             <a href="http://java.sun.com/products/foundation/">Foundation Profile 1.1.2 (JSR 219)</a><br>
+             and either of the following <i>java.nio</i> implementations:<br>
+             <ul>
+                <li> <a href="http://java.sun.com/javame/reference/apis/jsr239/java/nio/package-summary.html"> JSR239 <i>java.nio</i> subset</a> </li>
+                <li> <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/package-summary.html"> Java 1.4 <i>java.nio</i> implementation</a> </li>
+             </ul><br>
+    </ul>    
+  </ul>
+  <br>
+
+<h3>Package Structure</h3>
+  The packages defined by this specification include:<br><br>
+<ul>
+    <li>The <b>javax.media.nativewindow</b> package<br>
+      <br>
+  This package contains Java bindings for a native windowing system.<br>
+  Subsequent packages contain marker type classes, containing native characteristics of the windowing system.</li><br><br>
+  <ul>
+    <li>The <b>javax.media.nativewindow.awt</b> package<br>
+      <br>
+  This sub package contains classes to cover the native characteristics of the AWT windowing system.</li><br>
+
+    <li>The <b>javax.media.nativewindow.x11</b> package<br>
+      <br>
+  This sub package contains classes to cover the native characteristics of the X11 windowing system.</li><br>
+
+    <li>The <b>javax.media.nativewindow.windows</b> package<br>
+      <br>
+  This sub package contains classes to cover the native characteristics of the Windows windowing system.</li><br>
+
+    <li>The <b>javax.media.nativewindow.macosx</b> package<br>
+      <br>
+  This sub package contains classes to cover the native characteristics of the MacOSX windowing system.</li><br>
+
+    <li>The <b>javax.media.nativewindow.egl</b> package<br>
+      <br>
+  This sub package contains classes to cover the native characteristics of the EGL/OpenKODE windowing system.</li><br>
+  </ul>
+</ul>
+
+<h3>Factory Model</h3>
+Running on a platform with a supported windowing system, the factory model shall be used
+to instantiate a native window, see {@link javax.media.nativewindow.NativeWindowFactory NativeWindowFactory}.<br>
+The implementor has to specialize 
+All supported 
+Regardless of the knowledge of the underly
+<br>
+
+<h3>Revision History<br>
+  </h3>
+   
+<ul>
+<li> Early Draft Review, June 2009
+</ul>
+  <br>
+  <br>
+ <br>
+</body>
+</html>
diff --git a/src/nativewindow/classes/javax/media/nativewindow/windows/WindowsGraphicsDevice.java b/src/nativewindow/classes/javax/media/nativewindow/windows/WindowsGraphicsDevice.java
new file mode 100644
index 000000000..69dde49af
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/windows/WindowsGraphicsDevice.java
@@ -0,0 +1,50 @@
+/*
+ * 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 javax.media.nativewindow.windows;
+
+import javax.media.nativewindow.*;
+
+/** Encapsulates a graphics device on Windows platforms.
+ */
+
+public class WindowsGraphicsDevice extends DefaultGraphicsDevice implements Cloneable {
+    /** Constructs a new WindowsGraphicsDevice */
+    public WindowsGraphicsDevice() {
+        super(NativeWindowFactory.TYPE_WINDOWS);
+    }
+
+    public Object clone() {
+      return super.clone();
+    }
+}
+
diff --git a/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsConfiguration.java b/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsConfiguration.java
new file mode 100644
index 000000000..fdecac8fc
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsConfiguration.java
@@ -0,0 +1,76 @@
+/*
+ * 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 javax.media.nativewindow.x11;
+
+import javax.media.nativewindow.*;
+import com.sun.nativewindow.impl.x11.XVisualInfo;
+
+/** Encapsulates a graphics configuration, or OpenGL pixel format, on
+    X11 platforms. Objects of this type are returned from {@link
+    javax.media.nativewindow.GraphicsConfigurationFactory#chooseGraphicsConfiguration
+    GraphicsConfigurationFactory.chooseGraphicsConfiguration()} on X11
+    platforms when toolkits other than the AWT are being used.  */
+
+public class X11GraphicsConfiguration extends DefaultGraphicsConfiguration implements Cloneable {
+    private XVisualInfo info;
+
+    public X11GraphicsConfiguration(X11GraphicsScreen screen, 
+                                    Capabilities capsChosen, Capabilities capsRequested,
+                                    XVisualInfo info) {
+        super(screen, capsChosen, capsRequested);
+        this.info = info;
+    }
+
+    public Object clone() {
+      return super.clone();
+    }
+
+    public XVisualInfo getXVisualInfo() {
+        return info;
+    }
+
+    protected void setXVisualInfo(XVisualInfo info) {
+        this.info = info;
+    }
+
+    public long getVisualID() {
+        return (null!=info)?info.visualid():0;
+    }
+    
+    public String toString() {
+        return getClass().toString()+"["+getScreen()+", visualID 0x" + Long.toHexString(getVisualID()) + 
+                                       ",\n\tchosen    " + capabilitiesChosen+
+                                       ",\n\trequested " + capabilitiesRequested+ 
+                                       "]";
+    }
+}
diff --git a/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsDevice.java b/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsDevice.java
new file mode 100644
index 000000000..911b8f416
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsDevice.java
@@ -0,0 +1,55 @@
+/*
+ * 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 javax.media.nativewindow.x11;
+
+import javax.media.nativewindow.*;
+
+import com.sun.nativewindow.impl.x11.*;
+
+/** Encapsulates a graphics device on X11 platforms.
+ */
+
+public class X11GraphicsDevice extends DefaultGraphicsDevice implements Cloneable {
+    /** Constructs a new X11GraphicsDevice corresponding to the given native display handle. */
+    public X11GraphicsDevice(long display) {
+        super(NativeWindowFactory.TYPE_X11, display);
+        if(0==display) {
+            throw new NativeWindowException("null display");
+        }
+    }
+
+    public Object clone() {
+      return super.clone();
+    }
+}
+
diff --git a/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsScreen.java b/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsScreen.java
new file mode 100644
index 000000000..f434050f2
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/x11/X11GraphicsScreen.java
@@ -0,0 +1,91 @@
+/*
+ * 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 javax.media.nativewindow.x11;
+
+import javax.media.nativewindow.*;
+
+import com.sun.nativewindow.impl.x11.*;
+
+/** Encapsulates a screen index on X11
+    platforms. Objects of this type are passed to {@link
+    javax.media.nativewindow.GraphicsConfigurationFactory#chooseGraphicsConfiguration
+    GraphicsConfigurationFactory.chooseGraphicsConfiguration()} on X11
+    platforms when toolkits other than the AWT are being used.  */
+
+public class X11GraphicsScreen extends DefaultGraphicsScreen implements Cloneable {
+
+    /** Constructs a new X11GraphicsScreen corresponding to the given native screen index. */
+    public X11GraphicsScreen(X11GraphicsDevice device, int screen) {
+        super(device, fetchScreen(screen));
+    }
+
+    public static AbstractGraphicsScreen createScreenDevice(long display, int screenIdx) {
+        if(0==display) throw new NativeWindowException("display is null");
+        return new X11GraphicsScreen(new X11GraphicsDevice(display), screenIdx);
+    }
+
+    /** Creates a new X11GraphicsScreen using a thread local display connection */
+    public static AbstractGraphicsScreen createDefault() {
+        long display = X11Util.getThreadLocalDefaultDisplay();
+        int scrnIdx = X11Lib.DefaultScreen(display);
+        return createScreenDevice(display, scrnIdx);
+    }
+
+    public long getDefaultVisualID() {
+        // It still could be an AWT hold handle ..
+        NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
+        try {
+            long display = getDevice().getHandle();
+            int scrnIdx = X11Lib.DefaultScreen(display);
+            return X11Lib.DefaultVisualID(display, scrnIdx);
+        } finally {
+            NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
+        }
+    }
+
+    private static int fetchScreen(int screen) {
+        NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
+        try {
+            if(!com.sun.nativewindow.impl.x11.X11Util.isXineramaEnabledOnStaticDefaultDisplay()) {
+                return screen;
+            }
+        } finally {
+            NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
+        }
+        return 0;
+    }
+
+    public Object clone() {
+      return super.clone();
+    }
+}