34package com.jogamp.nativewindow;
36import com.jogamp.common.ExceptionUtils;
37import com.jogamp.common.util.ReflectionUtil;
39import jogamp.nativewindow.Debug;
40import jogamp.nativewindow.DefaultGraphicsConfigurationFactoryImpl;
42import java.util.ArrayList;
43import java.util.Arrays;
44import java.util.Collections;
45import java.util.HashMap;
46import java.util.Iterator;
68 protected static final boolean DEBUG;
70 private static class DeviceCapsType {
71 public final Class<?> deviceType;
72 public final Class<?> capsType;
73 private final int hash32;
75 public DeviceCapsType(
final Class<?> deviceType,
final Class<?> capsType) {
76 this.deviceType = deviceType;
77 this.capsType = capsType;
80 int hash32 = 31 + deviceType.hashCode();
81 hash32 = ((hash32 << 5) - hash32) + capsType.hashCode();
86 public final int hashCode() {
91 public final boolean equals(
final Object obj) {
92 if(
this == obj) {
return true; }
93 if (obj instanceof DeviceCapsType) {
94 final DeviceCapsType dct = (DeviceCapsType)obj;
95 return deviceType == dct.deviceType && capsType == dct.capsType;
101 public final String toString() {
102 return "DeviceCapsType["+deviceType.getName()+
", "+capsType.getName()+
"]";
107 private static final Map<DeviceCapsType, GraphicsConfigurationFactory> registeredFactories;
108 private static final DeviceCapsType defaultDeviceCapsType;
109 static boolean initialized =
false;
112 DEBUG = Debug.debug(
"GraphicsConfiguration");
114 System.err.println(Thread.currentThread().getName()+
" - Info: GraphicsConfigurationFactory.<init>");
117 registeredFactories = Collections.synchronizedMap(
new HashMap<DeviceCapsType, GraphicsConfigurationFactory>());
118 defaultDeviceCapsType =
new DeviceCapsType(AbstractGraphicsDevice.class, CapabilitiesImmutable.class);
126 System.err.println(Thread.currentThread().getName()+
" - GraphicsConfigurationFactory.initSingleton()");
134 registerFactory(defaultDeviceCapsType.deviceType, defaultDeviceCapsType.capsType,
new DefaultGraphicsConfigurationFactoryImpl());
138 ReflectionUtil.callStaticMethod(
"jogamp.nativewindow.x11.X11GraphicsConfigurationFactory",
140 }
catch (
final Exception e) {
141 throw new RuntimeException(e);
145 ReflectionUtil.callStaticMethod(
"jogamp.nativewindow.x11.awt.X11AWTGraphicsConfigurationFactory",
147 }
catch (
final Exception e) { }
157 System.err.println(Thread.currentThread().getName()+
" - GraphicsConfigurationFactory.shutdown()");
159 registeredFactories.clear();
164 return Thread.currentThread().getName();
168 return "0x" + Integer.toHexString(val);
172 return "0x" + Long.toHexString(val);
187 if (device ==
null) {
188 throw new IllegalArgumentException(
"null device");
191 throw new IllegalArgumentException(
"null caps");
193 return getFactory(device.getClass(), caps.getClass());
224 if (!(defaultDeviceCapsType.deviceType.isAssignableFrom(deviceType))) {
225 throw new IllegalArgumentException(
"Given class must implement AbstractGraphicsDevice");
227 if (!(defaultDeviceCapsType.capsType.isAssignableFrom(capabilitiesType))) {
228 throw new IllegalArgumentException(
"Given capabilities class must implement CapabilitiesImmutable");
231 ExceptionUtils.dumpStack(System.err);
232 System.err.println(
"GraphicsConfigurationFactory.getFactory: "+deviceType.getName()+
", "+capabilitiesType.getName());
236 final List<Class<?>> deviceTypes = getAllAssignableClassesFrom(defaultDeviceCapsType.deviceType, deviceType,
false);
238 System.err.println(
"GraphicsConfigurationFactory.getFactory() deviceTypes: " + deviceTypes);
240 final List<Class<?>> capabilitiesTypes = getAllAssignableClassesFrom(defaultDeviceCapsType.capsType, capabilitiesType,
true);
242 System.err.println(
"GraphicsConfigurationFactory.getFactory() capabilitiesTypes: " + capabilitiesTypes);
244 for(
int j=0; j<deviceTypes.size(); j++) {
245 final Class<?> interfaceDevice = deviceTypes.get(j);
246 for(
int i=0; i<capabilitiesTypes.size(); i++) {
247 final Class<?> interfaceCaps = capabilitiesTypes.get(i);
248 final DeviceCapsType dct =
new DeviceCapsType(interfaceDevice, interfaceCaps);
250 if (factory !=
null) {
252 System.err.println(
"GraphicsConfigurationFactory.getFactory() found "+dct+
" -> "+factory);
261 System.err.println(
"GraphicsConfigurationFactory.getFactory() DEFAULT "+defaultDeviceCapsType+
" -> "+factory);
265 private static ArrayList<Class<?>> getAllAssignableClassesFrom(
final Class<?> superClassOrInterface,
final Class<?> fromClass,
final boolean interfacesOnly) {
267 final ArrayList<Class<?>> inspectClasses =
new ArrayList<Class<?>>();
268 final ArrayList<Class<?>> resolvedInterfaces =
new ArrayList<Class<?>>();
269 inspectClasses.add(fromClass);
270 for(
int j=0; j<inspectClasses.size(); j++) {
271 final Class<?> clazz = inspectClasses.get(j);
272 getAllAssignableClassesFrom(superClassOrInterface, clazz, interfacesOnly, resolvedInterfaces, inspectClasses);
274 return resolvedInterfaces;
276 private static void getAllAssignableClassesFrom(
final Class<?> superClassOrInterface,
final Class<?> fromClass,
final boolean interfacesOnly,
final List<Class<?>> resolvedInterfaces,
final List<Class<?>> inspectClasses) {
277 final ArrayList<Class<?>> types =
new ArrayList<Class<?>>();
278 if( superClassOrInterface.isAssignableFrom(fromClass) && !resolvedInterfaces.contains(fromClass)) {
279 if( !interfacesOnly || fromClass.isInterface() ) {
280 types.add(fromClass);
283 types.addAll(Arrays.asList(fromClass.getInterfaces()));
285 for(
int i=0; i<types.size(); i++) {
286 final Class<?> iface = types.get(i);
287 if( superClassOrInterface.isAssignableFrom(iface) && !resolvedInterfaces.contains(iface) ) {
288 resolvedInterfaces.add(iface);
289 if( !superClassOrInterface.equals(iface) && !inspectClasses.contains(iface) ) {
290 inspectClasses.add(iface);
294 final Class<?> parentClass = fromClass.getSuperclass();
295 if(
null != parentClass && superClassOrInterface.isAssignableFrom(parentClass) && !inspectClasses.contains(parentClass) ) {
296 inspectClasses.add(parentClass);
299 private static void dumpFactories() {
300 final Set<DeviceCapsType> dcts = registeredFactories.keySet();
302 for(
final Iterator<DeviceCapsType> iter = dcts.iterator(); iter.hasNext(); ) {
303 final DeviceCapsType dct = iter.next();
304 System.err.println(
"Factory #"+i+
": "+dct+
" -> "+registeredFactories.get(dct));
329 throws IllegalArgumentException
331 if (!(defaultDeviceCapsType.deviceType.isAssignableFrom(abstractGraphicsDeviceImplementor))) {
332 throw new IllegalArgumentException(
"Given device class must implement AbstractGraphicsDevice");
334 if (!(defaultDeviceCapsType.capsType.isAssignableFrom(capabilitiesType))) {
335 throw new IllegalArgumentException(
"Given capabilities class must implement CapabilitiesImmutable");
337 final DeviceCapsType dct =
new DeviceCapsType(abstractGraphicsDeviceImplementor, capabilitiesType);
339 if(
null == factory) {
340 prevFactory = registeredFactories.remove(dct);
342 System.err.println(
"GraphicsConfigurationFactory.registerFactory() remove "+dct+
343 ", deleting: "+prevFactory);
346 prevFactory = registeredFactories.put(dct, factory);
348 System.err.println(
"GraphicsConfigurationFactory.registerFactory() put "+dct+
" -> "+factory+
349 ", overridding: "+prevFactory);
409 if(
null==capsChosen) {
412 if(
null==capsRequested) {
Provides the mechanism by which the graphics configuration for a window can be chosen before the wind...
GraphicsConfigurationFactory()
Creates a new NativeWindowFactory instance.
final AbstractGraphicsConfiguration chooseGraphicsConfiguration(final CapabilitiesImmutable capsChosen, final CapabilitiesImmutable capsRequested, final CapabilitiesChooser chooser, final AbstractGraphicsScreen screen, final int nativeVisualID)
static synchronized void shutdown()
static String getThreadName()
static String toHexString(final int val)
abstract AbstractGraphicsConfiguration chooseGraphicsConfigurationImpl(CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested, CapabilitiesChooser chooser, AbstractGraphicsScreen screen, int nativeVisualID)
Called by chooseGraphicsConfiguration(CapabilitiesImmutable, CapabilitiesImmutable,...
static final boolean DEBUG
static GraphicsConfigurationFactory getFactory(final Class<?> deviceType, final Class<?> capabilitiesType)
Returns the graphics configuration factory for use with the given device and capability class.
static GraphicsConfigurationFactory registerFactory(final Class<?> abstractGraphicsDeviceImplementor, final Class<?> capabilitiesType, final GraphicsConfigurationFactory factory)
Registers a GraphicsConfigurationFactory handling the given graphics device and capability class.
static String toHexString(final long val)
static synchronized void initSingleton()
static GraphicsConfigurationFactory getFactory(final AbstractGraphicsDevice device, final CapabilitiesImmutable caps)
Returns the graphics configuration factory for use with the given device and capability.
A generic exception for OpenGL errors used throughout the binding as a substitute for RuntimeExceptio...
Provides a pluggable mechanism for arbitrary window toolkits to adapt their components to the NativeW...
static final String TYPE_X11
X11 type, as retrieved with getNativeWindowType(boolean).
static String getNativeWindowType(final boolean useCustom)
A marker interface describing a graphics configuration, visual, or pixel format in a toolkit-independ...
A interface describing a graphics device in a toolkit-independent manner.
void lock()
Optionally locking the device, utilizing eg com.jogamp.nativewindow.ToolkitLock#lock().
void unlock()
Optionally unlocking the device, utilizing eg com.jogamp.nativewindow.ToolkitLock#unlock().
A interface describing a graphics screen in a toolkit-independent manner.
Provides a mechanism by which applications can customize the window type selection for a given Capabi...
Specifies an immutable set of capabilities that a window's rendering context must support,...