/*
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* - Redistribution of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
* ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
* DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use
* in the design, construction, operation or maintenance of any nuclear
* facility.
*
* Sun gratefully acknowledges that this software was originally authored
* and developed by Kenneth Bradley Russell and Christopher John Kline.
*/
package com.sun.opengl.impl.x11;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.nio.*;
import java.security.*;
import java.util.*;
import javax.media.opengl.*;
import com.sun.gluegen.runtime.*;
import com.sun.opengl.impl.*;
public class X11GLDrawableFactory extends GLDrawableFactoryImpl {
private static final boolean DEBUG = Debug.debug("X11GLDrawableFactory");
// ATI's proprietary drivers apparently send GLX tokens even for
// direct contexts, so we need to disable the context optimizations
// in this case
private static boolean isVendorATI;
// See whether we're running in headless mode
private static boolean isHeadless;
// Map for rediscovering the GLCapabilities associated with a
// particular screen and visualID after the fact
private static Map visualToGLCapsMap = Collections.synchronizedMap(new HashMap());
static class ScreenAndVisualIDKey {
private int screen;
private long visualID;
ScreenAndVisualIDKey(int screen,
long visualID) {
this.screen = screen;
this.visualID = visualID;
}
public int hashCode() {
return (int) (screen + 13 * visualID);
}
public boolean equals(Object obj) {
if ((obj == null) || (!(obj instanceof ScreenAndVisualIDKey))) {
return false;
}
ScreenAndVisualIDKey key = (ScreenAndVisualIDKey) obj;
return (screen == key.screen &&
visualID == key.visualID);
}
int screen() { return screen; }
long visualID() { return visualID; }
}
static {
// See DRIHack.java for an explanation of why this is necessary
DRIHack.begin();
com.sun.opengl.impl.NativeLibLoader.loadCore();
DRIHack.end();
isHeadless = GraphicsEnvironment.isHeadless();
}
public X11GLDrawableFactory() {
// Must initialize GLX support eagerly in case a pbuffer is the
// first thing instantiated
ProcAddressHelper.resetProcAddressTable(GLX.getGLXProcAddressTable(), this);
}
private static final int MAX_ATTRIBS = 128;
public AbstractGraphicsConfiguration chooseGraphicsConfiguration(GLCapabilities capabilities,
GLCapabilitiesChooser chooser,
AbstractGraphicsDevice absDevice) {
if (capabilities == null) {
capabilities = new GLCapabilities();
}
if (chooser == null) {
chooser = new DefaultGLCapabilitiesChooser();
}
GraphicsDevice device = null;
if (absDevice != null &&
!(absDevice instanceof AWTGraphicsDevice)) {
throw new IllegalArgumentException("This GLDrawableFactory accepts only AWTGraphicsDevice objects");
}
if ((absDevice == null) ||
(((AWTGraphicsDevice) absDevice).getGraphicsDevice() == null)) {
device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
} else {
device = ((AWTGraphicsDevice) absDevice).getGraphicsDevice();
}
int screen;
if (isXineramaEnabled()) {
screen = 0;
} else {
screen = X11SunJDKReflection.graphicsDeviceGetScreen(device);
}
// 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
int[] attribs = glCapabilities2AttribList(capabilities, isMultisampleAvailable(), false, 0, 0);
XVisualInfo[] infos = null;
GLCapabilities[] caps = null;
int recommendedIndex = -1;
lockToolkit();
try {
long display = getDisplayConnection();
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 0x" + Long.toHexString(recommendedVis.visualid()));
}
}
int[] count = new int[1];
XVisualInfo template = XVisualInfo.create();
template.screen(screen);
infos = GLX.XGetVisualInfo(display, GLX.VisualScreenMask, template, count, 0);
if (infos == null) {
throw new GLException("Error while enumerating available XVisualInfos");
}
caps = new GLCapabilities[infos.length];
for (int i = 0; i < infos.length; i++) {
caps[i] = xvi2GLCapabilities(display, infos[i]);
// Attempt to find the visual chosen by glXChooseVisual
if (recommendedVis != null && recommendedVis.visualid() == infos[i].visualid()) {
recommendedIndex = i;
}
}
} finally {
unlockToolkit();
}
// Store these away for later
for (int i = 0; i < infos.length; i++) {
if (caps[i] != null) {
visualToGLCapsMap.put(new ScreenAndVisualIDKey(screen, infos[i].visualid()),
caps[i].clone());
}
}
int chosen = chooser.chooseCapabilities(capabilities, caps, recommendedIndex);
if (chosen < 0 || chosen >= caps.length) {
throw new GLException("GLCapabilitiesChooser specified invalid index (expected 0.." + (caps.length - 1) + ")");
}
XVisualInfo vis = infos[chosen];
if (vis == null) {
throw new GLException("GLCapabilitiesChooser chose an invalid visual");
}
// FIXME: need to look at glue code and see type of this field
long visualID = vis.visualid();
// FIXME: the storage for the infos array, as well as that for the
// recommended visual, is leaked; should free them here with XFree()
// Now figure out which GraphicsConfiguration corresponds to this
// visual by matching the visual ID
GraphicsConfiguration[] configs = device.getConfigurations();
for (int i = 0; i < configs.length; i++) {
GraphicsConfiguration config = configs[i];
if (config != null) {
if (X11SunJDKReflection.graphicsConfigurationGetVisualID(config) == visualID) {
return new AWTGraphicsConfiguration(config);
}
}
}
// Either we weren't able to reflectively introspect on the
// X11GraphicsConfig or something went wrong in the steps above;
// we're going to return null without signaling an error condition
// in this case (although we should distinguish between the two
// and possibly report more of an error in the latter case)
return null;
}
public GLDrawable getGLDrawable(Object target,
GLCapabilities capabilities,
GLCapabilitiesChooser chooser) {
if (target == null) {
throw new IllegalArgumentException("Null target");
}
if (!(target instanceof Component)) {
throw new IllegalArgumentException("GLDrawables not supported for objects of type " +
target.getClass().getName() + " (only Components are supported in this implementation)");
}
Component comp = (Component) target;
X11OnscreenGLDrawable drawable = new X11OnscreenGLDrawable(comp);
// Figure out the GLCapabilities of this component
GraphicsConfiguration config = comp.getGraphicsConfiguration();
if (config == null) {
throw new IllegalArgumentException("GLDrawableFactory.chooseGraphicsConfiguration() was not used when creating this Component");
}
int visualID = X11SunJDKReflection.graphicsConfigurationGetVisualID(config);
int screen;
if (isXineramaEnabled()) {
screen = 0;
} else {
screen = X11SunJDKReflection.graphicsDeviceGetScreen(config.getDevice());
}
drawable.setChosenGLCapabilities((GLCapabilities) visualToGLCapsMap.get(new ScreenAndVisualIDKey(screen, visualID)));
return drawable;
}
public GLDrawableImpl createOffscreenDrawable(GLCapabilities capabilities,
GLCapabilitiesChooser chooser) {
return new X11OffscreenGLDrawable(capabilities, chooser);
}
private boolean pbufferSupportInitialized = false;
private boolean canCreateGLPbuffer = false;
public boolean canCreateGLPbuffer() {
if (!pbufferSupportInitialized) {
Runnable r = new Runnable() {
public void run() {
long display = getDisplayConnection();
lockToolkit();
try {
int[] major = new int[1];
int[] minor = new int[1];
int screen = 0; // FIXME: provide way to specify this?
if (!GLX.glXQueryVersion(display, major, 0, minor, 0)) {
throw new GLException("glXQueryVersion failed");
}
if (DEBUG) {
System.err.println("!!! GLX version: major " + major[0] +
", minor " + minor[0]);
}
// Work around bugs in ATI's Linux drivers where they report they
// only implement GLX version 1.2 on the server side
if (major[0] == 1 && minor[0] == 2) {
String str = GLX.glXGetClientString(display, GLX.GLX_VERSION);
if (str != null && str.startsWith("1.") &&
(str.charAt(2) >= '3')) {
canCreateGLPbuffer = true;
}
} else {
canCreateGLPbuffer = ((major[0] > 1) || (minor[0] > 2));
}
pbufferSupportInitialized = true;
} finally {
unlockToolkit();
}
}
};
maybeDoSingleThreadedWorkaround(r);
}
return canCreateGLPbuffer;
}
public GLPbuffer createGLPbuffer(final GLCapabilities capabilities,
final GLCapabilitiesChooser chooser,
final int initialWidth,
final int initialHeight,
final GLContext shareWith) {
if (!canCreateGLPbuffer()) {
throw new GLException("Pbuffer support not available with current graphics card");
}
final List returnList = new ArrayList();
Runnable r = new Runnable() {
public void run() {
X11PbufferGLDrawable pbufferDrawable = new X11PbufferGLDrawable(capabilities,
initialWidth,
initialHeight);
GLPbufferImpl pbuffer = new GLPbufferImpl(pbufferDrawable, shareWith);
returnList.add(pbuffer);
}
};
maybeDoSingleThreadedWorkaround(r);
return (GLPbuffer) returnList.get(0);
}
public GLContext createExternalGLContext() {
return new X11ExternalGLContext();
}
public boolean canCreateExternalGLDrawable() {
return canCreateGLPbuffer();
}
public GLDrawable createExternalGLDrawable() {
return new X11ExternalGLDrawable();
}
public void loadGLULibrary() {
GLX.dlopen("/usr/lib/libGLU.so");
}
public long dynamicLookupFunction(String glFuncName) {
long res = 0;
res = GLX.glXGetProcAddressARB(glFuncName);
if (res == 0) {
// GLU routines aren't known to the OpenGL function lookup
res = GLX.dlsym(glFuncName);
}
return res;
}
public static GLCapabilities xvi2GLCapabilities(long display, XVisualInfo info) {
int[] tmp = new int[1];
int val = glXGetConfig(display, info, GLX.GLX_USE_GL, tmp, 0);
if (val == 0) {
// Visual does not support OpenGL
return null;
}
val = glXGetConfig(display, info, GLX.GLX_RGBA, tmp, 0);
if (val == 0) {
// Visual does not support RGBA
return null;
}
GLCapabilities res = new GLCapabilities();
res.setDoubleBuffered(glXGetConfig(display, info, GLX.GLX_DOUBLEBUFFER, tmp, 0) != 0);
res.setStereo (glXGetConfig(display, info, GLX.GLX_STEREO, tmp, 0) != 0);
// Note: use of hardware acceleration is determined by
// glXCreateContext, not by the XVisualInfo. Optimistically claim
// that all GLCapabilities have the capability to be hardware
// accelerated.
res.setHardwareAccelerated(true);
res.setDepthBits (glXGetConfig(display, info, GLX.GLX_DEPTH_SIZE, tmp, 0));
res.setStencilBits (glXGetConfig(display, info, GLX.GLX_STENCIL_SIZE, tmp, 0));
res.setRedBits (glXGetConfig(display, info, GLX.GLX_RED_SIZE, tmp, 0));
res.setGreenBits (glXGetConfig(display, info, GLX.GLX_GREEN_SIZE, tmp, 0));
res.setBlueBits (glXGetConfig(display, info, GLX.GLX_BLUE_SIZE, tmp, 0));
res.setAlphaBits (glXGetConfig(display, info, GLX.GLX_ALPHA_SIZE, tmp, 0));
res.setAccumRedBits (glXGetConfig(display, info, GLX.GLX_ACCUM_RED_SIZE, tmp, 0));
res.setAccumGreenBits(glXGetConfig(display, info, GLX.GLX_ACCUM_GREEN_SIZE, tmp, 0));
res.setAccumBlueBits (glXGetConfig(display, info, GLX.GLX_ACCUM_BLUE_SIZE, tmp, 0));
res.setAccumAlphaBits(glXGetConfig(display, info, GLX.GLX_ACCUM_ALPHA_SIZE, tmp, 0));
if (isMultisampleAvailable()) {
res.setSampleBuffers(glXGetConfig(display, info, GLX.GLX_SAMPLE_BUFFERS_ARB, tmp, 0) != 0);
res.setNumSamples (glXGetConfig(display, info, GLX.GLX_SAMPLES_ARB, tmp, 0));
}
return res;
}
public static int[] glCapabilities2AttribList(GLCapabilities caps,
boolean isMultisampleAvailable,
boolean pbuffer,
long display,
int screen) {
int colorDepth = (caps.getRedBits() +
caps.getGreenBits() +
caps.getBlueBits());
if (colorDepth < 15) {
throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
}
int[] res = new int[MAX_ATTRIBS];
int idx = 0;
if (pbuffer) {
res[idx++] = GLXExt.GLX_DRAWABLE_TYPE;
res[idx++] = GLXExt.GLX_PBUFFER_BIT;
res[idx++] = GLXExt.GLX_RENDER_TYPE;
res[idx++] = GLXExt.GLX_RGBA_BIT;
} else {
res[idx++] = GLX.GLX_RGBA;
}
if (caps.getDoubleBuffered()) {
res[idx++] = GLX.GLX_DOUBLEBUFFER;
if (pbuffer) {
res[idx++] = GL.GL_TRUE;
}
} else {
if (pbuffer) {
res[idx++] = GLX.GLX_DOUBLEBUFFER;
res[idx++] = GL.GL_FALSE;
}
}
if (caps.getStereo()) {
res[idx++] = GLX.GLX_STEREO;
if (pbuffer) {
res[idx++] = GL.GL_TRUE;
}
}
// NOTE: don't set (GLX_STEREO, GL_FALSE) in "else" branch for
// pbuffer case to work around Mesa bug
res[idx++] = GLX.GLX_RED_SIZE;
res[idx++] = caps.getRedBits();
res[idx++] = GLX.GLX_GREEN_SIZE;
res[idx++] = caps.getGreenBits();
res[idx++] = GLX.GLX_BLUE_SIZE;
res[idx++] = caps.getBlueBits();
res[idx++] = GLX.GLX_ALPHA_SIZE;
res[idx++] = caps.getAlphaBits();
res[idx++] = GLX.GLX_DEPTH_SIZE;
res[idx++] = caps.getDepthBits();
if (caps.getStencilBits() > 0) {
res[idx++] = GLX.GLX_STENCIL_SIZE;
res[idx++] = caps.getStencilBits();
}
if (caps.getAccumRedBits() > 0 ||
caps.getAccumGreenBits() > 0 ||
caps.getAccumBlueBits() > 0 ||
caps.getAccumAlphaBits() > 0) {
res[idx++] = GLX.GLX_ACCUM_RED_SIZE;
res[idx++] = caps.getAccumRedBits();
res[idx++] = GLX.GLX_ACCUM_GREEN_SIZE;
res[idx++] = caps.getAccumGreenBits();
res[idx++] = GLX.GLX_ACCUM_BLUE_SIZE;
res[idx++] = caps.getAccumBlueBits();
res[idx++] = GLX.GLX_ACCUM_ALPHA_SIZE;
res[idx++] = caps.getAccumAlphaBits();
}
if (isMultisampleAvailable && caps.getSampleBuffers()) {
res[idx++] = GLXExt.GLX_SAMPLE_BUFFERS_ARB;
res[idx++] = GL.GL_TRUE;
res[idx++] = GLXExt.GLX_SAMPLES_ARB;
res[idx++] = caps.getNumSamples();
}
if (pbuffer) {
if (caps.getPbufferFloatingPointBuffers()) {
String glXExtensions = GLX.glXQueryExtensionsString(display, screen);
if (glXExtensions == null ||
glXExtensions.indexOf("GLX_NV_float_buffer") < 0) {
throw new GLException("Floating-point pbuffers on X11 currently require NVidia hardware");
}
res[idx++] = GLX.GLX_FLOAT_COMPONENTS_NV;
res[idx++] = GL.GL_TRUE;
}
}
res[idx++] = 0;
return res;
}
public static GLCapabilities attribList2GLCapabilities(int[] iattribs,
int niattribs,
int[] ivalues,
boolean pbuffer) {
GLCapabilities caps = new GLCapabilities();
for (int i = 0; i < niattribs; i++) {
int attr = iattribs[i];
switch (attr) {
case GLX.GLX_DOUBLEBUFFER:
caps.setDoubleBuffered(ivalues[i] != GL.GL_FALSE);
break;
case GLX.GLX_STEREO:
caps.setStereo(ivalues[i] != GL.GL_FALSE);
break;
case GLX.GLX_RED_SIZE:
caps.setRedBits(ivalues[i]);
break;
case GLX.GLX_GREEN_SIZE:
caps.setGreenBits(ivalues[i]);
break;
case GLX.GLX_BLUE_SIZE:
caps.setBlueBits(ivalues[i]);
break;
case GLX.GLX_ALPHA_SIZE:
caps.setAlphaBits(ivalues[i]);
break;
case GLX.GLX_DEPTH_SIZE:
caps.setDepthBits(ivalues[i]);
break;
case GLX.GLX_STENCIL_SIZE:
caps.setStencilBits(ivalues[i]);
break;
case GLX.GLX_ACCUM_RED_SIZE:
caps.setAccumRedBits(ivalues[i]);
break;
case GLX.GLX_ACCUM_GREEN_SIZE:
caps.setAccumGreenBits(ivalues[i]);
break;
case GLX.GLX_ACCUM_BLUE_SIZE:
caps.setAccumBlueBits(ivalues[i]);
break;
case GLX.GLX_ACCUM_ALPHA_SIZE:
caps.setAccumAlphaBits(ivalues[i]);
break;
case GLXExt.GLX_SAMPLE_BUFFERS_ARB:
caps.setSampleBuffers(ivalues[i] != GL.GL_FALSE);
break;
case GLXExt.GLX_SAMPLES_ARB:
caps.setNumSamples(ivalues[i]);
break;
case GLX.GLX_FLOAT_COMPONENTS_NV:
caps.setPbufferFloatingPointBuffers(ivalues[i] != GL.GL_FALSE);
break;
default:
break;
}
}
return caps;
}
public void lockToolkit() {
if (isHeadless) {
// Workaround for running (to some degree) in headless
// environments but still supporting rendering via pbuffers
// For full correctness, would need to implement a Lock class
return;
}
if (!Java2D.isOGLPipelineActive() || !Java2D.isQueueFlusherThread()) {
JAWT.getJAWT().Lock();
}
}
public void unlockToolkit() {
if (isHeadless) {
// Workaround for running (to some degree) in headless
// environments but still supporting rendering via pbuffers
// For full correctness, would need to implement a Lock class
return;
}
if (!Java2D.isOGLPipelineActive() || !Java2D.isQueueFlusherThread()) {
JAWT.getJAWT().Unlock();
}
}
public void lockAWTForJava2D() {
lockToolkit();
}
public void unlockAWTForJava2D() {
unlockToolkit();
}
// Display connection for use by visual selection algorithm and by all offscreen surfaces
private static long staticDisplay;
public static long getDisplayConnection() {
if (staticDisplay == 0) {
getX11Factory().lockToolkit();
try {
staticDisplay = GLX.XOpenDisplay(null);
if (DEBUG && (staticDisplay != 0)) {
long display = staticDisplay;
int screen = 0; // FIXME
System.err.println("!!! GLX server vendor : " +
GLX.glXQueryServerString(display, screen, GLX.GLX_VENDOR));
System.err.println("!!! GLX server version: " +
GLX.glXQueryServerString(display, screen, GLX.GLX_VERSION));
System.err.println("!!! GLX client vendor : " +
GLX.glXGetClientString(display, GLX.GLX_VENDOR));
System.err.println("!!! GLX client version: " +
GLX.glXGetClientString(display, GLX.GLX_VERSION));
}
if (staticDisplay != 0) {
String vendor = GLX.glXGetClientString(staticDisplay, GLX.GLX_VENDOR);
if (vendor != null && vendor.startsWith("ATI")) {
isVendorATI = true;
}
}
} finally {
getX11Factory().unlockToolkit();
}
if (staticDisplay == 0) {
throw new GLException("Unable to open default display, needed for visual selection and offscreen surface handling");
}
}
return staticDisplay;
}
private static boolean checkedMultisample;
private static boolean multisampleAvailable;
public static boolean isMultisampleAvailable() {
if (!checkedMultisample) {
long display = getDisplayConnection();
String exts = GLX.glXGetClientString(display, GLX.GLX_EXTENSIONS);
if (exts != null) {
multisampleAvailable = (exts.indexOf("GLX_ARB_multisample") >= 0);
}
checkedMultisample = true;
}
return multisampleAvailable;
}
private static String glXGetConfigErrorCode(int err) {
switch (err) {
case GLX.GLX_NO_EXTENSION: return "GLX_NO_EXTENSION";
case GLX.GLX_BAD_SCREEN: return "GLX_BAD_SCREEN";
case GLX.GLX_BAD_ATTRIBUTE: return "GLX_BAD_ATTRIBUTE";
case GLX.GLX_BAD_VISUAL: return "GLX_BAD_VISUAL";
default: return "Unknown error code " + err;
}
}
public static int glXGetConfig(long display, XVisualInfo info, int attrib, int[] tmp, int tmp_offset) {
if (display == 0) {
throw new GLException("No display connection");
}
int res = GLX.glXGetConfig(display, info, attrib, tmp, tmp_offset);
if (res != 0) {
throw new GLException("glXGetConfig failed: error code " + glXGetConfigErrorCode(res));
}
return tmp[tmp_offset];
}
public static X11GLDrawableFactory getX11Factory() {
return (X11GLDrawableFactory) getFactory();
}
/** Workaround for apparent issue with ATI's proprietary drivers
where direct contexts still send GLX tokens for GL calls */
public static boolean isVendorATI() {
return isVendorATI;
}
private void maybeDoSingleThreadedWorkaround(Runnable action) {
if (Threading.isSingleThreaded() &&
!Threading.isOpenGLThread()) {
Threading.invokeOnOpenGLThread(action);
} else {
action.run();
}
}
public boolean canCreateContextOnJava2DSurface() {
return false;
}
public GLContext createContextOnJava2DSurface(Graphics g, GLContext shareWith)
throws GLException {
throw new GLException("Unimplemented on this platform");
}
//---------------------------------------------------------------------------
// Xinerama-related functionality
//
private boolean checkedXinerama;
private boolean xineramaEnabled;
protected synchronized boolean isXineramaEnabled() {
if (!checkedXinerama) {
checkedXinerama = true;
lockToolkit();
long display = getDisplayConnection();
xineramaEnabled = GLX.XineramaEnabled(display);
unlockToolkit();
}
return xineramaEnabled;
}
//----------------------------------------------------------------------
// Gamma-related functionality
//
private boolean gotGammaRampLength;
private int gammaRampLength;
protected synchronized int getGammaRampLength() {
if (gotGammaRampLength) {
return gammaRampLength;
}
int[] size = new int[1];
lockToolkit();
long display = getDisplayConnection();
boolean res = GLX.XF86VidModeGetGammaRampSize(display,
GLX.DefaultScreen(display),
size, 0);
unlockToolkit();
if (!res)
return 0;
gotGammaRampLength = true;
gammaRampLength = size[0];
return gammaRampLength;
}
protected boolean setGammaRamp(float[] ramp) {
int len = ramp.length;
short[] rampData = new short[len];
for (int i = 0; i < len; i++) {
rampData[i] = (short) (ramp[i] * 65535);
}
lockToolkit();
long display = getDisplayConnection();
boolean res = GLX.XF86VidModeSetGammaRamp(display,
GLX.DefaultScreen(display),
rampData.length,
rampData, 0,
rampData, 0,
rampData, 0);
unlockToolkit();
return res;
}
protected Buffer getGammaRamp() {
int size = getGammaRampLength();
ShortBuffer rampData = ShortBuffer.allocate(3 * size);
rampData.position(0);
rampData.limit(size);
ShortBuffer redRampData = rampData.slice();
rampData.position(size);
rampData.limit(2 * size);
ShortBuffer greenRampData = rampData.slice();
rampData.position(2 * size);
rampData.limit(3 * size);
ShortBuffer blueRampData = rampData.slice();
lockToolkit();
long display = getDisplayConnection();
boolean res = GLX.XF86VidModeGetGammaRamp(display,
GLX.DefaultScreen(display),
size,
redRampData,
greenRampData,
blueRampData);
unlockToolkit();
if (!res)
return null;
return rampData;
}
protected void resetGammaRamp(Buffer originalGammaRamp) {
if (originalGammaRamp == null)
return; // getGammaRamp failed originally
ShortBuffer rampData = (ShortBuffer) originalGammaRamp;
int capacity = rampData.capacity();
if ((capacity % 3) != 0) {
throw new IllegalArgumentException("Must not be the original gamma ramp");
}
int size = capacity / 3;
rampData.position(0);
rampData.limit(size);
ShortBuffer redRampData = rampData.slice();
rampData.position(size);
rampData.limit(2 * size);
ShortBuffer greenRampData = rampData.slice();
rampData.position(2 * size);
rampData.limit(3 * size);
ShortBuffer blueRampData = rampData.slice();
lockToolkit();
long display = getDisplayConnection();
GLX.XF86VidModeSetGammaRamp(display,
GLX.DefaultScreen(display),
size,
redRampData,
greenRampData,
blueRampData);
unlockToolkit();
}
}