Fix GraphicsConfigurationFactory: Map factory to device-type _and_ capabilities-type; Add a pre-set nativeVisualID to chooseGraphicsConfiguration(..)

Map factory to device-type _and_ capabilities-type:
  - Allows using different GraphicsConfigurationFactory implementations for different capabilities-types.
    Previous impl. failed to use an OpenGL agnostic CapabilitiesImmutable for 'chooseGraphicsConfiguration(..)'
    since only the GL aware factory was mapped. The latter failed since it expected a GLCapabilitiesImmutable.

  - The passed capabilities-type as well as device-type given at getFactory(..)
    is traversed top-to-down to find a most suitable factory:
        For-All devT := getTopDownDeviceTypes(deviceType)
            For-All capsT := getTopDownCapabilitiesTypes(capabilitiesType)
               f = factory.get(devT, capsT);
               if(f) { return f; }
            end
        end

Add a pre-set nativeVisualID to chooseGraphicsConfiguration(..)
  - In situations where a native visualID is already chosen [by external means for example],
    but we still need to query a matching GraphicsConfiguration - we require to pass
    a non VisualIDHolder.VID_UNDEFINED nativeVisualID.

    We had a hack implemented before within some implementations and their static calls,
    however an agnostic mechanism is required to implement new NativeSurface/Window's
    platform agnostic.

  - X11GLXGraphicsConfigurationFactory: respect a pre-set xvisualID

  - X11GLXDrawableFactory.createProxySurfaceImpl(..) queries the given windowHandle's
    visualID and 'chooses' the configuration accordingly. If the visualID is undefined
    an exception is thrown, since window is invalid.
    These mechanics are implicit for Windows and OSX.

Fix X11GLXGraphicsConfiguration.updateGraphicsConfiguration():
  - Skip any action if a valid X11GLCapabilities is already chosen, i.e. w/ visualID.
    Otherwise choose a suitable configuration incl. visualID.
    The latter is quite impossible and invalid, since visualID must be defined at window creation time
    and the update method is issued with a valid window.

X11 - Misc:
  - Added 'int jogamp.nativewindow.x11.X11Lib.GetVisualIDFromWindow(..)'

  - All returned visualID's are of type 'int'

8 files changed, 237 insertions, 63 deletions

diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/awt/AWTGraphicsConfiguration.java b/src/nativewindow/classes/com/jogamp/nativewindow/awt/AWTGraphicsConfiguration.java
index 61d5e5c0d..2a152ff35 100644
--- a/src/nativewindow/classes/com/jogamp/nativewindow/awt/AWTGraphicsConfiguration.java
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/awt/AWTGraphicsConfiguration.java
@@ -95,8 +95,8 @@ public class AWTGraphicsConfiguration extends DefaultGraphicsConfiguration imple
           GraphicsConfiguration gc = awtGraphicsDevice.getDefaultConfiguration();
           capsChosen = AWTGraphicsConfiguration.setupCapabilitiesRGBABits(capsRequested, gc);
       }
-      final GraphicsConfigurationFactory factory = GraphicsConfigurationFactory.getFactory(awtDevice);
-      final AbstractGraphicsConfiguration config = factory.chooseGraphicsConfiguration(capsChosen, capsRequested, null, awtScreen);
+      final GraphicsConfigurationFactory factory = GraphicsConfigurationFactory.getFactory(awtDevice, capsChosen);
+      final AbstractGraphicsConfiguration config = factory.chooseGraphicsConfiguration(capsChosen, capsRequested, null, awtScreen, VisualIDHolder.VID_UNDEFINED);
       if(config instanceof AWTGraphicsConfiguration) {
           return (AWTGraphicsConfiguration) config;
       }
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsDevice.java b/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsDevice.java
index 7a98e3c25..5e4d6f41a 100644
--- a/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsDevice.java
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsDevice.java
@@ -88,7 +88,7 @@ public class X11GraphicsDevice extends DefaultGraphicsDevice implements Cloneabl
         // It still could be an AWT hold handle ..
         final long display = getHandle();
         final int scrnIdx = X11Lib.DefaultScreen(display);
-        return (int) X11Lib.DefaultVisualID(display, scrnIdx);
+        return X11Lib.DefaultVisualID(display, scrnIdx);
     }
     
     @Override
diff --git a/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsScreen.java b/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsScreen.java
index 014f4f688..5f3c220ca 100644
--- a/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsScreen.java
+++ b/src/nativewindow/classes/com/jogamp/nativewindow/x11/X11GraphicsScreen.java
@@ -58,7 +58,7 @@ public class X11GraphicsScreen extends DefaultGraphicsScreen implements Cloneabl
 
     public int getVisualID() {
         // It still could be an AWT hold handle ..
-        return (int) X11Lib.DefaultVisualID(getDevice().getHandle(), getIndex());
+        return X11Lib.DefaultVisualID(getDevice().getHandle(), getIndex());
     }
     
     private static int fetchScreen(X11GraphicsDevice device, int screen) {
diff --git a/src/nativewindow/classes/javax/media/nativewindow/GraphicsConfigurationFactory.java b/src/nativewindow/classes/javax/media/nativewindow/GraphicsConfigurationFactory.java
index 2610f2cfa..c3fdc6798 100644
--- a/src/nativewindow/classes/javax/media/nativewindow/GraphicsConfigurationFactory.java
+++ b/src/nativewindow/classes/javax/media/nativewindow/GraphicsConfigurationFactory.java
@@ -36,9 +36,15 @@ package javax.media.nativewindow;
 import com.jogamp.common.util.ReflectionUtil;
 import jogamp.nativewindow.Debug;
 import jogamp.nativewindow.DefaultGraphicsConfigurationFactoryImpl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * Provides the mechanism by which the graphics configuration for a
@@ -59,8 +65,43 @@ import java.util.Map;
 public abstract class GraphicsConfigurationFactory {
     protected static final boolean DEBUG;
 
-    private static Map<Class<?>, GraphicsConfigurationFactory> registeredFactories;
-    private static Class<?> abstractGraphicsDeviceClass;
+    private static class DeviceCapsType {
+        public final Class<?> deviceType;
+        public final Class<?> capsType;
+        private final int hash32;
+        
+        public DeviceCapsType(Class<?> deviceType, Class<?> capsType) {
+            this.deviceType = deviceType;
+            this.capsType = capsType;
+            
+            // 31 * x == (x << 5) - x
+            int hash32 = 31 + deviceType.hashCode();
+            hash32 = ((hash32 << 5) - hash32) + capsType.hashCode();
+            this.hash32 = hash32;
+        }
+        
+        public final int hashCode() {
+            return hash32;
+        }
+        
+        public final boolean equals(Object obj) {
+            if(this == obj)  { return true; }
+            if (obj instanceof DeviceCapsType) {
+                DeviceCapsType dct = (DeviceCapsType)obj;
+                return deviceType == dct.deviceType && capsType == dct.capsType;
+            }
+            return false;
+        }
+        
+        @Override
+        public final String toString() {
+            return "DeviceCapsType["+deviceType.getName()+", "+capsType.getName()+"]";
+        }
+        
+    }
+    
+    private static final Map<DeviceCapsType, GraphicsConfigurationFactory> registeredFactories;
+    private static final DeviceCapsType defaultDeviceCapsType; 
     static boolean initialized = false;
     
     static {
@@ -69,7 +110,8 @@ public abstract class GraphicsConfigurationFactory {
             System.err.println(Thread.currentThread().getName()+" - Info: GraphicsConfigurationFactory.<init>");
             // Thread.dumpStack();
         }
-        abstractGraphicsDeviceClass = javax.media.nativewindow.AbstractGraphicsDevice.class;        
+        registeredFactories = Collections.synchronizedMap(new HashMap<DeviceCapsType, GraphicsConfigurationFactory>());
+        defaultDeviceCapsType = new DeviceCapsType(AbstractGraphicsDevice.class, CapabilitiesImmutable.class);
     }
         
     public static synchronized void initSingleton() {
@@ -79,14 +121,13 @@ public abstract class GraphicsConfigurationFactory {
             if(DEBUG) {
                 System.err.println(Thread.currentThread().getName()+" - GraphicsConfigurationFactory.initSingleton()");
             }
-            registeredFactories = Collections.synchronizedMap(new HashMap<Class<?>, GraphicsConfigurationFactory>());
             
             // 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 DefaultGraphicsConfigurationFactoryImpl());
+            registerFactory(defaultDeviceCapsType.deviceType, defaultDeviceCapsType.capsType, new DefaultGraphicsConfigurationFactoryImpl());
             
             if (NativeWindowFactory.TYPE_X11.equals(NativeWindowFactory.getNativeWindowType(true))) {
                 try {
@@ -112,7 +153,6 @@ public abstract class GraphicsConfigurationFactory {
                 System.err.println(Thread.currentThread().getName()+" - GraphicsConfigurationFactory.shutdown()");
             }
             registeredFactories.clear();
-            registeredFactories = null;
         }
     }
     
@@ -133,74 +173,175 @@ public abstract class GraphicsConfigurationFactory {
     protected GraphicsConfigurationFactory() {
     }
 
-    /** Returns the factory for use with the given type of
-        AbstractGraphicsDevice. */
-    public static GraphicsConfigurationFactory getFactory(AbstractGraphicsDevice device) {
+    /**
+     * Returns the graphics configuration factory for use with the
+     * given device and capability.
+     * 
+     * @see #getFactory(Class, Class)
+     */
+    public static GraphicsConfigurationFactory getFactory(AbstractGraphicsDevice device, CapabilitiesImmutable caps) {        
         if (device == null) {
-            return getFactory(AbstractGraphicsDevice.class);
+            throw new IllegalArgumentException("null device");
+        }
+        if (caps == null) {
+            throw new IllegalArgumentException("null caps");
         }
-        return getFactory(device.getClass());
+        return getFactory(device.getClass(), caps.getClass());
     }
 
     /**
      * Returns the graphics configuration factory for use with the
-     * given class, which must implement the {@link
-     * AbstractGraphicsDevice} interface.
+     * given device and capability class.
+     * <p>
+     * Note: Registered device types maybe classes or interfaces, where capabilities types are interfaces only.
+     * </p>
+     *  
+     * <p>
+     * Pseudo code for finding a suitable factory is:
+     * <pre>
+        For-All devT := getTopDownDeviceTypes(deviceType)
+            For-All capsT := getTopDownCapabilitiesTypes(capabilitiesType)
+               f = factory.get(devT, capsT);
+               if(f) { return f; }
+            end
+        end
+     * </pre>
+     * </p>
      *
-     * @throws IllegalArgumentException if the given class does not implement AbstractGraphicsDevice
+     * @param deviceType the minimum capabilities class type accepted, must implement or extend {@link AbstractGraphicsDevice}
+     * @param capabilitiesType the minimum capabilities class type accepted, must implement or extend {@link CapabilitiesImmutable}
+     *
+     * @throws IllegalArgumentException if the deviceType does not implement {@link AbstractGraphicsDevice} or 
+     *                                  capabilitiesType does not implement {@link CapabilitiesImmutable}
      */
-    public static GraphicsConfigurationFactory getFactory(Class<?> abstractGraphicsDeviceImplementor)
+    public static GraphicsConfigurationFactory getFactory(Class<?> deviceType, Class<?> capabilitiesType)
         throws IllegalArgumentException, NativeWindowException
     {
-        if (!(abstractGraphicsDeviceClass.isAssignableFrom(abstractGraphicsDeviceImplementor))) {
+        if (!(defaultDeviceCapsType.deviceType.isAssignableFrom(deviceType))) {
             throw new IllegalArgumentException("Given class must implement AbstractGraphicsDevice");
         }
-
-        GraphicsConfigurationFactory factory = null;
-        Class<?> clazz = abstractGraphicsDeviceImplementor;
-        while (clazz != null) {
-            factory = registeredFactories.get(clazz);
-            if (factory != null) {
-                if(DEBUG) {
-                    System.err.println("GraphicsConfigurationFactory.getFactory() "+abstractGraphicsDeviceImplementor+" -> "+factory);
+        if (!(defaultDeviceCapsType.capsType.isAssignableFrom(capabilitiesType))) {
+            throw new IllegalArgumentException("Given capabilities class must implement CapabilitiesImmutable");
+        }
+        if(DEBUG) {
+            Thread.dumpStack();
+            System.err.println("GraphicsConfigurationFactory.getFactory: "+deviceType.getName()+", "+capabilitiesType.getName());
+            dumpFactories();
+        }
+        
+        final List<Class<?>> deviceTypes = getAllAssignableClassesFrom(defaultDeviceCapsType.deviceType, deviceType, false);        
+        if(DEBUG) {
+            System.err.println("GraphicsConfigurationFactory.getFactory() deviceTypes: " + deviceTypes);
+        }
+        final List<Class<?>> capabilitiesTypes = getAllAssignableClassesFrom(defaultDeviceCapsType.capsType, capabilitiesType, true);        
+        if(DEBUG) {
+            System.err.println("GraphicsConfigurationFactory.getFactory() capabilitiesTypes: " + capabilitiesTypes);
+        }
+        for(int j=0; j<deviceTypes.size(); j++) {
+            final Class<?> interfaceDevice = deviceTypes.get(j);
+            for(int i=0; i<capabilitiesTypes.size(); i++) {
+                Class<?> interfaceCaps = capabilitiesTypes.get(i);
+                final DeviceCapsType dct = new DeviceCapsType(interfaceDevice, interfaceCaps);
+                final GraphicsConfigurationFactory factory = registeredFactories.get(dct);
+                if (factory != null) {
+                    if(DEBUG) {
+                        System.err.println("GraphicsConfigurationFactory.getFactory() found "+dct+" -> "+factory);
+                    }
+                    return factory;
                 }
-                return factory;
             }
-            clazz = clazz.getSuperclass();
         }
         // Return the default
-        factory = registeredFactories.get(abstractGraphicsDeviceClass);
+        final GraphicsConfigurationFactory factory = registeredFactories.get(defaultDeviceCapsType);
         if(DEBUG) {
-            System.err.println("GraphicsConfigurationFactory.getFactory() DEFAULT "+abstractGraphicsDeviceClass+" -> "+factory);
+            System.err.println("GraphicsConfigurationFactory.getFactory() DEFAULT "+defaultDeviceCapsType+" -> "+factory);
         }
         return factory;
     }
+    private static ArrayList<Class<?>> getAllAssignableClassesFrom(Class<?> superClassOrInterface, Class<?> fromClass, boolean interfacesOnly) {
+        // Using a todo list avoiding a recursive loop! 
+        final ArrayList<Class<?>> inspectClasses  = new ArrayList<Class<?>>();
+        final ArrayList<Class<?>> resolvedInterfaces = new ArrayList<Class<?>>();
+        inspectClasses.add(fromClass);
+        for(int j=0; j<inspectClasses.size(); j++) {
+            final Class<?> clazz = inspectClasses.get(j);
+            getAllAssignableClassesFrom(superClassOrInterface, clazz, interfacesOnly, resolvedInterfaces, inspectClasses);
+        }
+        return resolvedInterfaces;
+    }
+    private static void getAllAssignableClassesFrom(Class<?> superClassOrInterface, Class<?> fromClass, boolean interfacesOnly, List<Class<?>> resolvedInterfaces, List<Class<?>> inspectClasses) {
+        final ArrayList<Class<?>> types = new ArrayList<Class<?>>();
+        if( superClassOrInterface.isAssignableFrom(fromClass) && !resolvedInterfaces.contains(fromClass)) {
+            if( !interfacesOnly || fromClass.isInterface() ) {
+                types.add(fromClass);
+            }
+        }
+        types.addAll(Arrays.asList(fromClass.getInterfaces()));
+                
+        for(int i=0; i<types.size(); i++) {
+            final Class<?> iface = types.get(i);
+            if( superClassOrInterface.isAssignableFrom(iface) && !resolvedInterfaces.contains(iface) ) {
+                resolvedInterfaces.add(iface);
+                if( !superClassOrInterface.equals(iface) && !inspectClasses.contains(iface) ) {
+                    inspectClasses.add(iface); // safe add to todo list, avoiding a recursive nature
+                }
+            }
+        }
+        final Class<?> parentClass = fromClass.getSuperclass();
+        if( null != parentClass && superClassOrInterface.isAssignableFrom(parentClass) && !inspectClasses.contains(parentClass) ) {
+            inspectClasses.add(parentClass); // safe add to todo list, avoiding a recursive nature
+        }
+    }
+    private static void dumpFactories() {
+        Set<DeviceCapsType> dcts = registeredFactories.keySet();
+        int i=0;
+        for(Iterator<DeviceCapsType> iter = dcts.iterator(); iter.hasNext(); ) {
+            DeviceCapsType dct = iter.next();
+            System.err.println("Factory #"+i+": "+dct+" -> "+registeredFactories.get(dct));
+            i++;
+        }
+    }
 
-    /** 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
+    /** 
+     * Registers a GraphicsConfigurationFactory handling
+     * the given graphics device and capability class.
+     * <p>
+     * This does not need to be called by end users, only implementors of new
      * GraphicsConfigurationFactory subclasses.
-     *
+     * </p>
+     * 
+     * <p>
+     * Note: Registered device types maybe classes or interfaces, where capabilities types are interfaces only.
+     * </p> 
+     * 
+     * <p>See {@link #getFactory(Class, Class)} for a description of the find algorithm.</p>
+     * 
+     * @param deviceType the minimum capabilities class type accepted, must implement or extend interface {@link AbstractGraphicsDevice}
+     * @param capabilitiesType the minimum capabilities class type accepted, must extend interface {@link CapabilitiesImmutable}
      * @return the previous registered factory, or null if none
      * @throws IllegalArgumentException if the given class does not implement AbstractGraphicsDevice
      */
-    protected static GraphicsConfigurationFactory registerFactory(Class<?> abstractGraphicsDeviceImplementor, GraphicsConfigurationFactory factory)
+    protected static GraphicsConfigurationFactory registerFactory(Class<?> abstractGraphicsDeviceImplementor, Class<?> capabilitiesType, GraphicsConfigurationFactory factory)
         throws IllegalArgumentException
     {
-        if (!(abstractGraphicsDeviceClass.isAssignableFrom(abstractGraphicsDeviceImplementor))) {
-            throw new IllegalArgumentException("Given class must implement AbstractGraphicsDevice");
+        if (!(defaultDeviceCapsType.deviceType.isAssignableFrom(abstractGraphicsDeviceImplementor))) {
+            throw new IllegalArgumentException("Given device class must implement AbstractGraphicsDevice");
         }
+        if (!(defaultDeviceCapsType.capsType.isAssignableFrom(capabilitiesType))) {
+            throw new IllegalArgumentException("Given capabilities class must implement CapabilitiesImmutable");
+        }        
+        final DeviceCapsType dct = new DeviceCapsType(abstractGraphicsDeviceImplementor, capabilitiesType);
         final GraphicsConfigurationFactory prevFactory;
         if(null == factory) {
-            prevFactory = registeredFactories.remove(abstractGraphicsDeviceImplementor);
+            prevFactory = registeredFactories.remove(dct);
             if(DEBUG) {
-                System.err.println("GraphicsConfigurationFactory.registerFactory() remove "+abstractGraphicsDeviceImplementor+
+                System.err.println("GraphicsConfigurationFactory.registerFactory() remove "+dct+
                                    ", deleting: "+prevFactory);
             }
         } else {
-            prevFactory = registeredFactories.put(abstractGraphicsDeviceImplementor, factory);
+            prevFactory = registeredFactories.put(dct, factory);
             if(DEBUG) {
-                System.err.println("GraphicsConfigurationFactory.registerFactory() put "+abstractGraphicsDeviceImplementor+" -> "+factory+
+                System.err.println("GraphicsConfigurationFactory.registerFactory() put "+dct+" -> "+factory+
                                    ", overridding: "+prevFactory);
             }
         }
@@ -244,6 +385,7 @@ public abstract class GraphicsConfigurationFactory {
      * @param capsRequested  the original requested capabilities
      * @param chooser        the choosing implementation
      * @param screen         the referring Screen
+     * @param nativeVisualID if not {@link VisualIDHolder#VID_UNDEFINED} it reflects a pre-chosen visualID of the native platform's windowing system. 
      * @return               the complete GraphicsConfiguration
      *
      * @throws IllegalArgumentException if the data type of the passed
@@ -258,7 +400,7 @@ public abstract class GraphicsConfigurationFactory {
     public final AbstractGraphicsConfiguration
         chooseGraphicsConfiguration(CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested,
                                     CapabilitiesChooser chooser,
-                                    AbstractGraphicsScreen screen)
+                                    AbstractGraphicsScreen screen, int nativeVisualID)
         throws IllegalArgumentException, NativeWindowException {
         if(null==capsChosen) {
             throw new NativeWindowException("Chosen Capabilities are null");
@@ -275,7 +417,7 @@ public abstract class GraphicsConfigurationFactory {
         }
         device.lock();
         try {
-            return chooseGraphicsConfigurationImpl(capsChosen, capsRequested, chooser, screen);
+            return chooseGraphicsConfigurationImpl(capsChosen, capsRequested, chooser, screen, nativeVisualID);
         } finally {
             device.unlock();
         }
@@ -283,7 +425,7 @@ public abstract class GraphicsConfigurationFactory {
 
     protected abstract AbstractGraphicsConfiguration
         chooseGraphicsConfigurationImpl(CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested,
-                                        CapabilitiesChooser chooser, AbstractGraphicsScreen screen)
+                                        CapabilitiesChooser chooser, AbstractGraphicsScreen screen, int nativeVisualID)
         throws IllegalArgumentException, NativeWindowException;
 
 }
diff --git a/src/nativewindow/classes/jogamp/nativewindow/DefaultGraphicsConfigurationFactoryImpl.java b/src/nativewindow/classes/jogamp/nativewindow/DefaultGraphicsConfigurationFactoryImpl.java
index f34b740d4..52e9c8308 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/DefaultGraphicsConfigurationFactoryImpl.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/DefaultGraphicsConfigurationFactoryImpl.java
@@ -37,7 +37,7 @@ import javax.media.nativewindow.*;
 
 public class DefaultGraphicsConfigurationFactoryImpl extends GraphicsConfigurationFactory {
     protected AbstractGraphicsConfiguration chooseGraphicsConfigurationImpl(
-            CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested, CapabilitiesChooser chooser, AbstractGraphicsScreen screen) {
+            CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested, CapabilitiesChooser chooser, AbstractGraphicsScreen screen, int nativeVisualID) {
         return new DefaultGraphicsConfiguration(screen, capsChosen, capsRequested);
     }
 }
diff --git a/src/nativewindow/classes/jogamp/nativewindow/x11/X11GraphicsConfigurationFactory.java b/src/nativewindow/classes/jogamp/nativewindow/x11/X11GraphicsConfigurationFactory.java
index 070f87216..b11dd1df1 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/x11/X11GraphicsConfigurationFactory.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/x11/X11GraphicsConfigurationFactory.java
@@ -39,33 +39,39 @@ import javax.media.nativewindow.CapabilitiesChooser;
 import javax.media.nativewindow.CapabilitiesImmutable;
 import javax.media.nativewindow.GraphicsConfigurationFactory;
 import javax.media.nativewindow.NativeWindowException;
+import javax.media.nativewindow.VisualIDHolder;
 
 import com.jogamp.nativewindow.x11.X11GraphicsConfiguration;
 import com.jogamp.nativewindow.x11.X11GraphicsScreen;
 
 public class X11GraphicsConfigurationFactory extends GraphicsConfigurationFactory {
     public static void registerFactory() {
-        GraphicsConfigurationFactory.registerFactory(com.jogamp.nativewindow.x11.X11GraphicsDevice.class, new X11GraphicsConfigurationFactory());
+        GraphicsConfigurationFactory.registerFactory(com.jogamp.nativewindow.x11.X11GraphicsDevice.class, CapabilitiesImmutable.class, new X11GraphicsConfigurationFactory());
     }    
     private X11GraphicsConfigurationFactory() {
     }
     
     protected AbstractGraphicsConfiguration chooseGraphicsConfigurationImpl(
-        CapabilitiesImmutable  capsChosen, CapabilitiesImmutable capsRequested, CapabilitiesChooser chooser, AbstractGraphicsScreen screen)
+        CapabilitiesImmutable  capsChosen, CapabilitiesImmutable capsRequested, CapabilitiesChooser chooser, AbstractGraphicsScreen screen, int nativeVisualID)
         throws IllegalArgumentException, NativeWindowException {
 
         if(!(screen instanceof X11GraphicsScreen)) {
             throw new NativeWindowException("Only valid X11GraphicsScreen are allowed");
         }
-        final X11Capabilities x11CapsChosen = new X11Capabilities(getXVisualInfo(screen, capsChosen)); 
-        AbstractGraphicsConfiguration res = new X11GraphicsConfiguration((X11GraphicsScreen)screen,  x11CapsChosen, capsRequested, x11CapsChosen.getXVisualInfo());
+        final X11Capabilities x11CapsChosen;
+        if(VisualIDHolder.VID_UNDEFINED == nativeVisualID) {
+            x11CapsChosen = new X11Capabilities(getXVisualInfo(screen, capsChosen));
+        } else {
+            x11CapsChosen = new X11Capabilities(getXVisualInfo(screen, nativeVisualID));
+        }
+        final AbstractGraphicsConfiguration res = new X11GraphicsConfiguration((X11GraphicsScreen)screen,  x11CapsChosen, capsRequested, x11CapsChosen.getXVisualInfo());
         if(DEBUG) {
-            System.err.println("X11GraphicsConfigurationFactory.chooseGraphicsConfigurationImpl("+screen+","+capsChosen+"): "+res);
+            System.err.println("X11GraphicsConfigurationFactory.chooseGraphicsConfigurationImpl(visualID 0x"+Integer.toHexString(nativeVisualID)+", "+screen+","+capsChosen+"): "+res);
         }
         return res;
     }
 
-    public static XVisualInfo getXVisualInfo(AbstractGraphicsScreen screen, long visualID)
+    public static XVisualInfo getXVisualInfo(AbstractGraphicsScreen screen, int visualID)
     {
         XVisualInfo xvi_temp = XVisualInfo.create();
         xvi_temp.setVisualid(visualID);
diff --git a/src/nativewindow/classes/jogamp/nativewindow/x11/awt/X11AWTGraphicsConfigurationFactory.java b/src/nativewindow/classes/jogamp/nativewindow/x11/awt/X11AWTGraphicsConfigurationFactory.java
index b6bf63d44..1de03e8be 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/x11/awt/X11AWTGraphicsConfigurationFactory.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/x11/awt/X11AWTGraphicsConfigurationFactory.java
@@ -61,14 +61,14 @@ import jogamp.nativewindow.x11.X11Util;
 public class X11AWTGraphicsConfigurationFactory extends GraphicsConfigurationFactory {
     
     public static void registerFactory() {
-        GraphicsConfigurationFactory.registerFactory(com.jogamp.nativewindow.awt.AWTGraphicsDevice.class, new X11AWTGraphicsConfigurationFactory());
+        GraphicsConfigurationFactory.registerFactory(com.jogamp.nativewindow.awt.AWTGraphicsDevice.class, CapabilitiesImmutable.class, new X11AWTGraphicsConfigurationFactory());
     }    
     private X11AWTGraphicsConfigurationFactory() {
     }
 
     protected AbstractGraphicsConfiguration chooseGraphicsConfigurationImpl(
             CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested,
-            CapabilitiesChooser chooser, AbstractGraphicsScreen absScreen) {    
+            CapabilitiesChooser chooser, AbstractGraphicsScreen absScreen, int nativeVisualID) {    
         if (absScreen != null &&
             !(absScreen instanceof AWTGraphicsScreen)) {
             throw new IllegalArgumentException("This GraphicsConfigurationFactory accepts only AWTGraphicsScreen objects");
@@ -77,18 +77,18 @@ public class X11AWTGraphicsConfigurationFactory extends GraphicsConfigurationFac
             absScreen = AWTGraphicsScreen.createDefault();
         }
 
-        return chooseGraphicsConfigurationStatic(capsChosen, capsRequested, chooser, (AWTGraphicsScreen)absScreen);
+        return chooseGraphicsConfigurationStatic(capsChosen, capsRequested, chooser, (AWTGraphicsScreen)absScreen, nativeVisualID);
     }
     
     public static AWTGraphicsConfiguration chooseGraphicsConfigurationStatic(
             CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested,
-            CapabilitiesChooser chooser, AWTGraphicsScreen awtScreen) {
+            CapabilitiesChooser chooser, AWTGraphicsScreen awtScreen, int nativeVisualID) {
         if(DEBUG) {
             System.err.println("X11AWTGraphicsConfigurationFactory: got "+awtScreen);
         }
         
         final GraphicsDevice device = ((AWTGraphicsDevice)awtScreen.getDevice()).getGraphicsDevice();
-
+        
         final long displayHandleAWT = X11SunJDKReflection.graphicsDeviceGetDisplay(device);
         final long displayHandle;
         boolean owner = false;
@@ -121,8 +121,8 @@ public class X11AWTGraphicsConfigurationFactory extends GraphicsConfigurationFac
             System.err.println("X11AWTGraphicsConfigurationFactory: made "+x11Screen);
         }
         
-        final GraphicsConfigurationFactory factory = GraphicsConfigurationFactory.getFactory(x11Device);
-        AbstractGraphicsConfiguration aConfig = factory.chooseGraphicsConfiguration(capsChosen, capsRequested, chooser, x11Screen);
+        final GraphicsConfigurationFactory factory = GraphicsConfigurationFactory.getFactory(x11Device, capsChosen);
+        AbstractGraphicsConfiguration aConfig = factory.chooseGraphicsConfiguration(capsChosen, capsRequested, chooser, x11Screen, nativeVisualID);
         if (aConfig == null) {
             throw new NativeWindowException("Unable to choose a GraphicsConfiguration (1): "+capsChosen+",\n\t"+chooser+"\n\t"+x11Screen);
         }
@@ -160,7 +160,7 @@ public class X11AWTGraphicsConfigurationFactory extends GraphicsConfigurationFac
         // try again using an AWT Colormodel compatible configuration
         GraphicsConfiguration gc = device.getDefaultConfiguration();
         capsChosen = AWTGraphicsConfiguration.setupCapabilitiesRGBABits(capsChosen, gc);
-        aConfig = factory.chooseGraphicsConfiguration(capsChosen, capsRequested, chooser, x11Screen);
+        aConfig = factory.chooseGraphicsConfiguration(capsChosen, capsRequested, chooser, x11Screen, nativeVisualID);
         if (aConfig == null) {
             throw new NativeWindowException("Unable to choose a GraphicsConfiguration (2): "+capsChosen+",\n\t"+chooser+"\n\t"+x11Screen);
         }
diff --git a/src/nativewindow/native/x11/Xmisc.c b/src/nativewindow/native/x11/Xmisc.c
index 21771c9aa..fcba8580c 100644
--- a/src/nativewindow/native/x11/Xmisc.c
+++ b/src/nativewindow/native/x11/Xmisc.c
@@ -362,14 +362,40 @@ Java_jogamp_nativewindow_x11_X11Lib_XGetVisualInfo1__JJLjava_nio_ByteBuffer_2Lja
   return jbyteCopy;
 }
 
-JNIEXPORT jlong JNICALL 
+JNIEXPORT jint JNICALL 
+Java_jogamp_nativewindow_x11_X11Lib_GetVisualIDFromWindow(JNIEnv *env, jclass _unused, jlong display, jlong window) {
+    Display * dpy = (Display *)(intptr_t)display;
+    Window      w = (Window) window;
+    XWindowAttributes xwa;
+    jlong r = 0; // undefinded
+
+    if(NULL==dpy) {
+        NativewindowCommon_throwNewRuntimeException(env, "invalid display connection..");
+        return;
+    }
+
+    NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 1, 0, 1);
+    memset(&xwa, 0, sizeof(XWindowAttributes));
+    XGetWindowAttributes(dpy, w, &xwa);
+    if(NULL != xwa.visual) {
+        r = (jint) XVisualIDFromVisual( xwa.visual );
+    } else {
+        r = 0;
+    }
+    NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 0, 0, 1);
+
+    return r;
+}
+
+
+JNIEXPORT jint JNICALL 
 Java_jogamp_nativewindow_x11_X11Lib_DefaultVisualID(JNIEnv *env, jclass _unused, jlong display, jint screen) {
   jlong r;
     if(0==display) {
         NativewindowCommon_FatalError(env, "invalid display connection..");
     }
   NativewindowCommon_x11ErrorHandlerEnable(env, (Display *) (intptr_t) display, 1, 0, 0);
-  r = (jlong) XVisualIDFromVisual( DefaultVisual( (Display*) (intptr_t) display, screen ) );
+  r = (jint) XVisualIDFromVisual( DefaultVisual( (Display*) (intptr_t) display, screen ) );
   NativewindowCommon_x11ErrorHandlerEnable(env, (Display *) (intptr_t) display, 0, 0, 0);
   return r;
 }