static X11GLXGraphicsConfiguration fetchGraphicsConfigurationFBConfig(
X11GraphicsScreen x11Screen, int fbID, GLProfile glp) {
final AbstractGraphicsDevice absDevice = x11Screen.getDevice();
final long display = absDevice.getHandle();
final int screen = x11Screen.getIndex();
final long fbcfg = X11GLXGraphicsConfiguration.glXFBConfigID2FBConfig(display, screen, fbID);
if (0 == fbcfg || !X11GLXGraphicsConfiguration.GLXFBConfigValid(display, fbcfg)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed - GLX FBConfig invalid: ("
+ x11Screen
+ ","
+ toHexString(fbID)
+ "): fbcfg: "
+ toHexString(fbcfg));
}
return null;
}
final X11GLXDrawableFactory factory =
(X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
final X11GLCapabilities caps =
X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
glp, display, fbcfg, true, true, true, factory.isGLXMultisampleAvailable(absDevice));
return new X11GLXGraphicsConfiguration(
x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
}
protected void createNativeImpl() {
if (0 != getParentWindowHandle()) {
throw new NativeWindowException("GDL Window does not support window parenting");
}
AbstractGraphicsScreen aScreen = getScreen().getGraphicsScreen();
AbstractGraphicsDevice aDevice = getScreen().getDisplay().getGraphicsDevice();
config =
GraphicsConfigurationFactory.getFactory(aDevice)
.chooseGraphicsConfiguration(
capsRequested, capsRequested, capabilitiesChooser, aScreen);
if (config == null) {
throw new NativeWindowException(
"Error choosing GraphicsConfiguration creating window: " + this);
}
synchronized (Window.class) {
setWindowHandle(nextWindowHandle++); // just a marker
surfaceHandle =
CreateSurface(
aDevice.getHandle(),
getScreen().getWidth(),
getScreen().getHeight(),
x,
y,
width,
height);
if (surfaceHandle == 0) {
throw new NativeWindowException("Error creating window");
}
}
}
static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesXVisual(
X11GraphicsScreen x11Screen, GLProfile glProfile, boolean isMultisampleAvailable) {
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
int[] count = new int[1];
XVisualInfo template = XVisualInfo.create();
template.setScreen(screen);
XVisualInfo[] infos =
X11Lib.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
if (infos == null || infos.length < 1) {
throw new GLException("Error while enumerating available XVisualInfos");
}
ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
for (int i = 0; i < infos.length; i++) {
if (!X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(
availableCaps,
glProfile,
display,
infos[i],
GLGraphicsConfigurationUtil.ALL_BITS,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesXVisual: XVisual invalid: ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(infos[i].getVisualid()));
}
}
}
return availableCaps;
}
protected void closeNativeImpl() {
if (0 != windowHandleClose && null != getScreen()) {
DisplayDriver display = (DisplayDriver) getScreen().getDisplay();
final AbstractGraphicsDevice edtDevice = display.getGraphicsDevice();
edtDevice.lock();
try {
CloseWindow0(
edtDevice.getHandle(),
windowHandleClose,
display.getJavaObjectAtom(),
display.getWindowDeleteAtom());
} catch (Throwable t) {
if (DEBUG_IMPLEMENTATION) {
Exception e =
new Exception(
"Warning: closeNativeImpl failed - " + Thread.currentThread().getName(), t);
e.printStackTrace();
}
} finally {
edtDevice.unlock();
windowHandleClose = 0;
}
}
if (null != renderDevice) {
renderDevice.close(); // closes X11 display
renderDevice = null;
}
}
@Override
protected ProxySurface createMutableSurfaceImpl(
AbstractGraphicsDevice deviceReq,
boolean createNewDevice,
GLCapabilitiesImmutable capsChosen,
GLCapabilitiesImmutable capsRequested,
GLCapabilitiesChooser chooser,
UpstreamSurfaceHook upstreamHook) {
final boolean ownDevice;
final EGLGraphicsDevice device;
if (createNewDevice || !(deviceReq instanceof EGLGraphicsDevice)) {
final long nativeDisplayID =
(deviceReq instanceof EGLGraphicsDevice)
? ((EGLGraphicsDevice) deviceReq).getNativeDisplayID()
: deviceReq.getHandle();
device =
EGLDisplayUtil.eglCreateEGLGraphicsDevice(
nativeDisplayID, deviceReq.getConnection(), deviceReq.getUnitID());
ownDevice = true;
} else {
device = (EGLGraphicsDevice) deviceReq;
ownDevice = false;
}
final DefaultGraphicsScreen screen = new DefaultGraphicsScreen(device, 0);
final EGLGraphicsConfiguration config =
EGLGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(
capsChosen, capsRequested, chooser, screen, VisualIDHolder.VID_UNDEFINED, false);
if (null == config) {
throw new GLException(
"Choosing GraphicsConfiguration failed w/ " + capsChosen + " on " + screen);
}
return new WrappedSurface(config, 0, upstreamHook, ownDevice);
}
/**
* @param capsRequested
* @param absScreen
* @param eglConfigID {@link EGL#EGL_CONFIG_ID} for which the config is being created for.
* @return
* @throws GLException if invalid EGL display.
*/
public static EGLGraphicsConfiguration create(
GLCapabilitiesImmutable capsRequested, AbstractGraphicsScreen absScreen, int eglConfigID) {
final AbstractGraphicsDevice absDevice = absScreen.getDevice();
if (null == absDevice || !(absDevice instanceof EGLGraphicsDevice)) {
throw new GLException("GraphicsDevice must be a valid EGLGraphicsDevice");
}
final long dpy = absDevice.getHandle();
if (dpy == EGL.EGL_NO_DISPLAY) {
throw new GLException("Invalid EGL display: " + absDevice);
}
final long cfg = EGLConfigId2EGLConfig(dpy, eglConfigID);
if (0 < cfg) {
final GLRendererQuirks defaultQuirks =
GLRendererQuirks.getStickyDeviceQuirks(
GLDrawableFactory.getEGLFactory().getDefaultDevice());
final int winattrmask =
GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsRequested);
final EGLGLCapabilities caps =
EGLConfig2Capabilities(
defaultQuirks,
(EGLGraphicsDevice) absDevice,
capsRequested.getGLProfile(),
cfg,
winattrmask,
false);
return new EGLGraphicsConfiguration(
absScreen, caps, capsRequested, new DefaultGLCapabilitiesChooser());
}
return null;
}
static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesFBConfig(
X11GraphicsScreen x11Screen, GLProfile glProfile, boolean isMultisampleAvailable) {
PointerBuffer fbcfgsL = null;
// Utilizing FBConfig
//
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
int[] count = {-1};
ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
if (fbcfgsL == null || fbcfgsL.limit() <= 0) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: Failed glXChooseFBConfig ("
+ x11Screen
+ "): "
+ fbcfgsL
+ ", "
+ count[0]);
}
return null;
}
for (int i = 0; i < fbcfgsL.limit(); i++) {
if (!X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
availableCaps,
glProfile,
display,
fbcfgsL.get(i),
GLGraphicsConfigurationUtil.ALL_BITS,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: FBConfig invalid (2): ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(fbcfgsL.get(i)));
}
}
}
return availableCaps;
}
private static X11GLXGraphicsConfiguration chooseGraphicsConfigurationXVisual(
GLCapabilitiesImmutable capsChosen,
GLCapabilitiesImmutable capsReq,
GLCapabilitiesChooser chooser,
X11GraphicsScreen x11Screen) {
if (chooser == null) {
chooser = new DefaultGLCapabilitiesChooser();
}
GLProfile glProfile = capsChosen.getGLProfile();
final int winattrmask =
GLGraphicsConfigurationUtil.getWinAttributeBits(
capsChosen.isOnscreen(), false /* pbuffer */);
ArrayList availableCaps = new ArrayList();
int recommendedIndex = -1;
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
final X11GLXDrawableFactory factory =
(X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(absDevice);
int[] attribs =
X11GLXGraphicsConfiguration.GLCapabilities2AttribList(
capsChosen, false, isMultisampleAvailable, display, screen);
// 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as
// preferred choice
XVisualInfo recommendedVis = GLX.glXChooseVisual(display, screen, attribs, 0);
if (DEBUG) {
System.err.print("glXChooseVisual recommended ");
if (recommendedVis == null) {
System.err.println("null visual");
} else {
System.err.println("visual id " + toHexString(recommendedVis.getVisualid()));
}
}
// 2nd choice: get all GLCapabilities available, preferred recommendedIndex might be available
// if 1st choice was successful
int[] count = new int[1];
XVisualInfo template = XVisualInfo.create();
template.setScreen(screen);
XVisualInfo[] infos =
X11Lib.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
if (infos == null || infos.length < 1) {
throw new GLException("Error while enumerating available XVisualInfos");
}
for (int i = 0; i < infos.length; i++) {
if (!X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(
availableCaps, glProfile, display, infos[i], winattrmask, isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationXVisual: XVisual invalid: ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(infos[i].getVisualid()));
}
} else {
// Attempt to find the visual chosenIndex by glXChooseVisual, if not translucent
if (capsChosen.isBackgroundOpaque()
&& recommendedVis != null
&& recommendedVis.getVisualid() == infos[i].getVisualid()) {
recommendedIndex = availableCaps.size() - 1;
}
}
}
int chosenIndex = chooseCapabilities(chooser, capsChosen, availableCaps, recommendedIndex);
if (0 > chosenIndex) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationXVisual: failed, return null");
Thread.dumpStack();
}
return null;
}
X11GLCapabilities chosenCaps = (X11GLCapabilities) availableCaps.get(chosenIndex);
return new X11GLXGraphicsConfiguration(x11Screen, chosenCaps, capsReq, chooser);
}
private static X11GLXGraphicsConfiguration chooseGraphicsConfigurationFBConfig(
GLCapabilitiesImmutable capsChosen,
GLCapabilitiesImmutable capsReq,
GLCapabilitiesChooser chooser,
X11GraphicsScreen x11Screen) {
int recommendedIndex = -1;
PointerBuffer fbcfgsL = null;
GLProfile glProfile = capsChosen.getGLProfile();
boolean onscreen = capsChosen.isOnscreen();
boolean usePBuffer = capsChosen.isPBuffer();
// Utilizing FBConfig
//
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
final X11GLXDrawableFactory factory =
(X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(absDevice);
int[] attribs =
X11GLXGraphicsConfiguration.GLCapabilities2AttribList(
capsChosen, true, isMultisampleAvailable, display, screen);
int[] count = {-1};
ArrayList /*<X11GLCapabilities>*/ availableCaps = new ArrayList();
final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer);
// 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as
// preferred choice
fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, 0, count, 0);
if (fbcfgsL != null && fbcfgsL.limit() > 0) {
for (int i = 0; i < fbcfgsL.limit(); i++) {
if (!X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
availableCaps,
glProfile,
display,
fbcfgsL.get(i),
winattrmask,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (1): ("
+ x11Screen
+ ","
+ capsChosen
+ "): fbcfg: "
+ toHexString(fbcfgsL.get(i)));
}
}
}
if (availableCaps.size() > 0) {
recommendedIndex =
capsChosen.isBackgroundOpaque() ? 0 : -1; // only use recommended idx if not translucent
if (DEBUG) {
System.err.println(
"glXChooseFBConfig recommended fbcfg "
+ toHexString(fbcfgsL.get(0))
+ ", idx "
+ recommendedIndex);
System.err.println("user caps " + capsChosen);
System.err.println("fbcfg caps " + availableCaps.get(0));
}
} else if (DEBUG) {
System.err.println(
"glXChooseFBConfig no caps for recommended fbcfg " + toHexString(fbcfgsL.get(0)));
System.err.println("user caps " + capsChosen);
}
}
// 2nd choice: get all GLCapabilities available, no preferred recommendedIndex available
if (0 == availableCaps.size()) {
// reset ..
recommendedIndex = -1;
fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
if (fbcfgsL == null || fbcfgsL.limit() <= 0) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXChooseFBConfig ("
+ x11Screen
+ ","
+ capsChosen
+ "): "
+ fbcfgsL
+ ", "
+ count[0]);
}
return null;
}
for (int i = 0; i < fbcfgsL.limit(); i++) {
if (!X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
availableCaps,
glProfile,
display,
fbcfgsL.get(i),
winattrmask,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (2): ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(fbcfgsL.get(i)));
}
}
}
}
int chosenIndex = chooseCapabilities(chooser, capsChosen, availableCaps, recommendedIndex);
if (0 > chosenIndex) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: failed, return null");
Thread.dumpStack();
}
return null;
}
X11GLCapabilities chosenCaps = (X11GLCapabilities) availableCaps.get(chosenIndex);
return new X11GLXGraphicsConfiguration(x11Screen, chosenCaps, capsReq, chooser);
}
protected static X11GLXGraphicsConfiguration chooseGraphicsConfigurationXVisual(
GLCapabilities capabilities, GLCapabilitiesChooser chooser, X11GraphicsScreen x11Screen) {
if (chooser == null) {
chooser = new DefaultGLCapabilitiesChooser();
}
// Until we have a rock-solid visual selection algorithm written
// in pure Java, we're going to provide the underlying window
// system's selection to the chooser as a hint
GLProfile glProfile = capabilities.getGLProfile();
boolean onscreen = capabilities.isOnscreen();
GLCapabilities[] caps = null;
int recommendedIndex = -1;
XVisualInfo retXVisualInfo = null;
int chosen = -1;
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
try {
NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
X11Lib.XLockDisplay(display);
int screen = x11Screen.getIndex();
boolean isMultisampleAvailable = GLXUtil.isMultisampleAvailable(display);
int[] attribs =
X11GLXGraphicsConfiguration.GLCapabilities2AttribList(
capabilities, false, isMultisampleAvailable, display, screen);
XVisualInfo[] infos = null;
XVisualInfo recommendedVis = GLX.glXChooseVisualCopied(display, screen, attribs, 0);
if (DEBUG) {
System.err.print("!!! glXChooseVisual recommended ");
if (recommendedVis == null) {
System.err.println("null visual");
} else {
System.err.println("visual id 0x" + Long.toHexString(recommendedVis.getVisualid()));
}
}
int[] count = new int[1];
XVisualInfo template = XVisualInfo.create();
template.setScreen(screen);
infos = X11Lib.XGetVisualInfoCopied(display, X11Lib.VisualScreenMask, template, count, 0);
if (infos == null || infos.length < 1) {
throw new GLException("Error while enumerating available XVisualInfos");
}
caps = new GLCapabilities[infos.length];
for (int i = 0; i < infos.length; i++) {
caps[i] =
X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(
glProfile, display, infos[i], onscreen, false, isMultisampleAvailable);
// Attempt to find the visual chosen by glXChooseVisual
if (recommendedVis != null && recommendedVis.getVisualid() == infos[i].getVisualid()) {
recommendedIndex = i;
}
}
try {
chosen = chooser.chooseCapabilities(capabilities, caps, recommendedIndex);
} catch (NativeWindowException e) {
if (DEBUG) {
e.printStackTrace();
}
chosen = -1;
}
if (chosen < 0) {
// keep on going ..
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationXVisual Failed .. unable to choose config, using first");
}
chosen = 0; // default ..
} else if (chosen >= caps.length) {
throw new GLException(
"GLCapabilitiesChooser specified invalid index (expected 0.."
+ (caps.length - 1)
+ ")");
}
if (infos[chosen] == null) {
throw new GLException("GLCapabilitiesChooser chose an invalid visual");
}
retXVisualInfo = XVisualInfo.create(infos[chosen]);
} finally {
X11Lib.XUnlockDisplay(display);
NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
}
return new X11GLXGraphicsConfiguration(
x11Screen, caps[chosen], capabilities, chooser, retXVisualInfo, 0, -1);
}
protected static X11GLXGraphicsConfiguration chooseGraphicsConfigurationFBConfig(
GLCapabilities capabilities, GLCapabilitiesChooser chooser, X11GraphicsScreen x11Screen) {
int recommendedIndex = -1;
GLCapabilities[] caps = null;
PointerBuffer fbcfgsL = null;
int chosen = -1;
int retFBID = -1;
XVisualInfo retXVisualInfo = null;
GLProfile glProfile = capabilities.getGLProfile();
boolean onscreen = capabilities.isOnscreen();
boolean usePBuffer = capabilities.isPBuffer();
// Utilizing FBConfig
//
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
try {
NativeWindowFactory.getDefaultFactory().getToolkitLock().lock();
X11Lib.XLockDisplay(display);
int screen = x11Screen.getIndex();
boolean isMultisampleAvailable = GLXUtil.isMultisampleAvailable(display);
int[] attribs =
X11GLXGraphicsConfiguration.GLCapabilities2AttribList(
capabilities, true, isMultisampleAvailable, display, screen);
int[] count = {-1};
fbcfgsL = GLX.glXChooseFBConfigCopied(display, screen, attribs, 0, count, 0);
if (fbcfgsL == null || fbcfgsL.limit() < 1) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXChooseFBConfig ("
+ x11Screen
+ ","
+ capabilities
+ "): "
+ fbcfgsL
+ ", "
+ count[0]);
}
return null;
}
if (!X11GLXGraphicsConfiguration.GLXFBConfigValid(display, fbcfgsL.get(0))) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed - GLX FBConfig invalid: ("
+ x11Screen
+ ","
+ capabilities
+ "): "
+ fbcfgsL
+ ", fbcfg: 0x"
+ Long.toHexString(fbcfgsL.get(0)));
}
return null;
}
recommendedIndex = 0; // 1st match is always recommended ..
caps = new GLCapabilities[fbcfgsL.limit()];
for (int i = 0; i < fbcfgsL.limit(); i++) {
caps[i] =
X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
glProfile,
display,
fbcfgsL.get(i),
false,
onscreen,
usePBuffer,
isMultisampleAvailable);
}
if (null == chooser) {
chosen = recommendedIndex;
} else {
try {
chosen = chooser.chooseCapabilities(capabilities, caps, recommendedIndex);
} catch (NativeWindowException e) {
if (DEBUG) {
e.printStackTrace();
}
chosen = -1;
}
}
if (chosen < 0) {
// keep on going ..
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig Failed .. unable to choose config, using first");
}
chosen = 0; // default ..
} else if (chosen >= caps.length) {
throw new GLException(
"GLCapabilitiesChooser specified invalid index (expected 0.."
+ (caps.length - 1)
+ ")");
}
retFBID = X11GLXGraphicsConfiguration.glXFBConfig2FBConfigID(display, fbcfgsL.get(chosen));
retXVisualInfo = GLX.glXGetVisualFromFBConfigCopied(display, fbcfgsL.get(chosen));
if (retXVisualInfo == null) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXGetVisualFromFBConfig ("
+ x11Screen
+ ", "
+ fbcfgsL.get(chosen)
+ " (Continue: "
+ (false == caps[chosen].isOnscreen())
+ "):\n\t"
+ caps[chosen]);
}
if (caps[chosen].isOnscreen()) {
// Onscreen drawables shall have a XVisual ..
return null;
}
}
} finally {
X11Lib.XUnlockDisplay(display);
NativeWindowFactory.getDefaultFactory().getToolkitLock().unlock();
}
return new X11GLXGraphicsConfiguration(
x11Screen,
caps[chosen],
capabilities,
chooser,
retXVisualInfo,
fbcfgsL.get(chosen),
retFBID);
}
protected void createNativeImpl() {
final ScreenDriver screen = (ScreenDriver) getScreen();
final DisplayDriver display = (DisplayDriver) screen.getDisplay();
final AbstractGraphicsDevice edtDevice = display.getGraphicsDevice();
// Decoupled X11 Device/Screen allowing X11 display lock-free off-thread rendering
final long renderDeviceHandle = X11Util.openDisplay(edtDevice.getConnection());
if (0 == renderDeviceHandle) {
throw new RuntimeException("Error creating display(EDT): " + edtDevice.getConnection());
}
renderDevice =
new X11GraphicsDevice(
renderDeviceHandle, AbstractGraphicsDevice.DEFAULT_UNIT, true /* owner */);
final AbstractGraphicsScreen renderScreen =
new X11GraphicsScreen(renderDevice, screen.getIndex());
final GraphicsConfigurationFactory factory =
GraphicsConfigurationFactory.getFactory(display.getGraphicsDevice(), capsRequested);
final AbstractGraphicsConfiguration cfg =
factory.chooseGraphicsConfiguration(
capsRequested,
capsRequested,
capabilitiesChooser,
renderScreen,
VisualIDHolder.VID_UNDEFINED);
if (DEBUG_IMPLEMENTATION) {
System.err.println(
"X11Window.createNativeImpl() factory: " + factory + ", chosen config: " + cfg);
}
if (null == cfg) {
throw new NativeWindowException(
"Error choosing GraphicsConfiguration creating window: " + this);
}
final int visualID = cfg.getVisualID(VIDType.NATIVE);
if (VisualIDHolder.VID_UNDEFINED == visualID) {
throw new NativeWindowException("Chosen Configuration w/o native visual ID: " + cfg);
}
setGraphicsConfiguration(cfg);
final int flags = getReconfigureFlags(0, true) & (FLAG_IS_ALWAYSONTOP | FLAG_IS_UNDECORATED);
edtDevice.lock();
try {
setWindowHandle(
CreateWindow0(
getParentWindowHandle(),
edtDevice.getHandle(),
screen.getIndex(),
visualID,
display.getJavaObjectAtom(),
display.getWindowDeleteAtom(),
getX(),
getY(),
getWidth(),
getHeight(),
autoPosition(),
flags));
} finally {
edtDevice.unlock();
}
windowHandleClose = getWindowHandle();
if (0 == windowHandleClose) {
throw new NativeWindowException("Error creating window");
}
}
