michael/lwjgl
michael
/
lwjgl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added java debug output to linux display.c

This commit is contained in:
Elias Naur 2004-12-11 20:09:04 +00:00
parent 5ee6565bb5
commit 7e4fc4c3b9
7 changed files with 62 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/native/common/common_tools.c
View File

@ -80,7 +80,7 @@ void printfDebugJava(JNIEnv *env, const char *format, ...) {
buffer[BUFFER_SIZE - 1] = '\0'; buffer[BUFFER_SIZE - 1] = '\0';
jstring str = (*env)->NewStringUTF(env, buffer); jstring str = (*env)->NewStringUTF(env, buffer);
jclass org_lwjgl_Sys_class = (*env)->FindClass(env, "org/lwjgl/Sys"); jclass org_lwjgl_Sys_class = (*env)->FindClass(env, "org/lwjgl/Sys");
jmethodID log_method = (*env)->GetMethodID(env, org_lwjgl_Sys_class, "log", "(Ljava/lang/String;)V"); jmethodID log_method = (*env)->GetStaticMethodID(env, org_lwjgl_Sys_class, "log", "(Ljava/lang/String;)V");
(*env)->CallStaticVoidMethod(env, org_lwjgl_Sys_class, log_method, str); (*env)->CallStaticVoidMethod(env, org_lwjgl_Sys_class, log_method, str);
} }
va_end(ap); va_end(ap);

3
src/native/linux/Window.h
View File

@ -53,8 +53,7 @@
/* /*
* release input (keyboard, mouse) * release input (keyboard, mouse)
*/ */
extern bool releaseInput(void); extern void handleMessages(JNIEnv *env);
extern void handleMessages(void);
extern bool checkXError(JNIEnv *env); extern bool checkXError(JNIEnv *env);
extern Atom getWarpAtom(void); extern Atom getWarpAtom(void);

82
src/native/linux/display.c
View File

@ -87,54 +87,54 @@ extension getCurrentDisplayModeExtension(void) {
return current_extension; return current_extension;
} }
static bool getXF86VidModeVersion(Display *disp, int *major, int *minor) { static bool getXF86VidModeVersion(JNIEnv *env, Display *disp, int *major, int *minor) {
int event_base, error_base; int event_base, error_base;
if (!XF86VidModeQueryExtension(disp, &event_base, &error_base)) { if (!XF86VidModeQueryExtension(disp, &event_base, &error_base)) {
printfDebug("XF86VidMode extension not available\n"); printfDebugJava(env, "XF86VidMode extension not available");
return false; return false;
} }
if (!XF86VidModeQueryVersion(disp, major, minor)) { if (!XF86VidModeQueryVersion(disp, major, minor)) {
printfDebug("Could not query XF86VidMode version\n"); printfDebugJava(env, "Could not query XF86VidMode version");
return false; return false;
} }
printfDebug("XF86VidMode extension version %i.%i\n", *major, *minor); printfDebugJava(env, "XF86VidMode extension version %i.%i", *major, *minor);
return true; return true;
} }
static bool getXrandrVersion(Display *disp, int *major, int *minor) { static bool getXrandrVersion(JNIEnv *env, Display *disp, int *major, int *minor) {
int event_base, error_base; int event_base, error_base;
if (!XRRQueryExtension(disp, &event_base, &error_base)) { if (!XRRQueryExtension(disp, &event_base, &error_base)) {
printfDebug("Xrandr extension not available\n"); printfDebugJava(env, "Xrandr extension not available");
return false; return false;
} }
if (!XRRQueryVersion(disp, major, minor)) { if (!XRRQueryVersion(disp, major, minor)) {
printfDebug("Could not query Xrandr version\n"); printfDebugJava(env, "Could not query Xrandr version");
return false; return false;
} }
printfDebug("Xrandr extension version %i.%i\n", *major, *minor); printfDebugJava(env, "Xrandr extension version %i.%i", *major, *minor);
return true; return true;
} }
static bool isXrandrSupported(Display *disp) { static bool isXrandrSupported(JNIEnv *env, Display *disp) {
int major, minor; int major, minor;
if (!getXrandrVersion(disp, &major, &minor)) if (!getXrandrVersion(env, disp, &major, &minor))
return false; return false;
return major >= 1; return major >= 1;
} }
static bool isXF86VidModeSupported(Display *disp) { static bool isXF86VidModeSupported(JNIEnv *env, Display *disp) {
int minor_ver, major_ver; int minor_ver, major_ver;
if (!getXF86VidModeVersion(disp, &major_ver, &minor_ver)) if (!getXF86VidModeVersion(env, disp, &major_ver, &minor_ver))
return false; return false;
return major_ver >= 2; return major_ver >= 2;
} }
static extension getBestDisplayModeExtension(Display *disp) { static extension getBestDisplayModeExtension(JNIEnv *env, Display *disp) {
if (isXrandrSupported(disp)) if (isXrandrSupported(env, disp))
return XRANDR; return XRANDR;
else if (isXF86VidModeSupported(disp)) else if (isXF86VidModeSupported(env, disp))
return XF86VIDMODE; return XF86VIDMODE;
else else
return NONE; return NONE;
@ -225,29 +225,29 @@ static bool setXrandrMode(Display *disp, int screen, mode_info *mode) {
return true; return true;
} }
static bool setMode(Display *disp, int screen, int width, int height, int freq, bool temporary) { static bool setMode(JNIEnv *env, Display *disp, int screen, int width, int height, int freq, bool temporary) {
if (current_extension == NONE) if (current_extension == NONE)
return false; return false;
int num_modes, i; int num_modes, i;
mode_info *avail_modes = getDisplayModes(disp, screen, &num_modes); mode_info *avail_modes = getDisplayModes(disp, screen, &num_modes);
if (avail_modes == NULL) { if (avail_modes == NULL) {
printfDebug("Could not get display modes\n"); printfDebugJava(env, "Could not get display modes");
return false; return false;
} }
bool result = false; bool result = false;
for ( i = 0; i < num_modes; ++i ) { for ( i = 0; i < num_modes; ++i ) {
printfDebug("Mode %d: %dx%d @%d\n", i, avail_modes[i].width, avail_modes[i].height, avail_modes[i].freq); printfDebugJava(env, "Mode %d: %dx%d @%d", i, avail_modes[i].width, avail_modes[i].height, avail_modes[i].freq);
if (avail_modes[i].width == width && avail_modes[i].height == height && avail_modes[i].freq == freq) { if (avail_modes[i].width == width && avail_modes[i].height == height && avail_modes[i].freq == freq) {
switch (current_extension) { switch (current_extension) {
case XF86VIDMODE: case XF86VIDMODE:
if (!setXF86VidModeMode(disp, screen, &avail_modes[i])) { if (!setXF86VidModeMode(disp, screen, &avail_modes[i])) {
printfDebug("Could not switch mode\n"); printfDebugJava(env, "Could not switch mode");
continue; continue;
} }
break; break;
case XRANDR: case XRANDR:
if (!setXrandrMode(disp, screen, &avail_modes[i])) { if (!setXrandrMode(disp, screen, &avail_modes[i])) {
printfDebug("Could not switch mode\n"); printfDebugJava(env, "Could not switch mode");
continue; continue;
} }
break; break;
@ -279,26 +279,26 @@ static void freeSavedGammaRamps() {
saved_gamma_ramp_length = 0; saved_gamma_ramp_length = 0;
} }
static int getGammaRampLengthOfDisplay(Display *disp, int screen) { static int getGammaRampLengthOfDisplay(JNIEnv *env, Display *disp, int screen) {
int ramp_size; int ramp_size;
if (!isXF86VidModeSupported(disp)) { if (!isXF86VidModeSupported(env, disp)) {
printfDebug("XF86VidMode extension version >= 2 not found\n"); printfDebugJava(env, "XF86VidMode extension version >= 2 not found");
return 0; return 0;
} }
if (XF86VidModeGetGammaRampSize(disp, screen, &ramp_size) == False) { if (XF86VidModeGetGammaRampSize(disp, screen, &ramp_size) == False) {
printfDebug("XF86VidModeGetGammaRampSize call failed\n"); printfDebugJava(env, "XF86VidModeGetGammaRampSize call failed");
return 0; return 0;
} }
return ramp_size; return ramp_size;
} }
int getGammaRampLength(int screen) { int getGammaRampLength(JNIEnv *env, int screen) {
Display *disp = XOpenDisplay(NULL); Display *disp = XOpenDisplay(NULL);
if (disp == NULL) { if (disp == NULL) {
printfDebug("Could not open display"); printfDebugJava(env, "Could not open display");
return 0; return 0;
} }
int length = getGammaRampLengthOfDisplay(disp, screen); int length = getGammaRampLengthOfDisplay(env, disp, screen);
XCloseDisplay(disp); XCloseDisplay(disp);
return length; return length;
} }
@ -312,7 +312,7 @@ jobject initDisplay(JNIEnv *env, int screen) {
return NULL; return NULL;
} }
current_extension = getBestDisplayModeExtension(disp); current_extension = getBestDisplayModeExtension(env, disp);
if (current_extension == NONE) { if (current_extension == NONE) {
throwException(env, "No display mode extension is available"); throwException(env, "No display mode extension is available");
XCloseDisplay(disp); XCloseDisplay(disp);
@ -328,7 +328,7 @@ jobject initDisplay(JNIEnv *env, int screen) {
saved_height = current_height = avail_modes[0].height; saved_height = current_height = avail_modes[0].height;
saved_freq = current_freq = avail_modes[0].freq; saved_freq = current_freq = avail_modes[0].freq;
int bpp = XDefaultDepth(disp, screen); int bpp = XDefaultDepth(disp, screen);
printfDebug("Original display dimensions: width %d, height %d freq %d\n", saved_width, saved_height, saved_freq); printfDebugJava(env, "Original display dimensions: width %d, height %d freq %d", saved_width, saved_height, saved_freq);
jclass jclass_DisplayMode = (*env)->FindClass(env, "org/lwjgl/opengl/DisplayMode"); jclass jclass_DisplayMode = (*env)->FindClass(env, "org/lwjgl/opengl/DisplayMode");
jmethodID ctor = (*env)->GetMethodID(env, jclass_DisplayMode, "<init>", "(IIII)V"); jmethodID ctor = (*env)->GetMethodID(env, jclass_DisplayMode, "<init>", "(IIII)V");
jobject newMode = (*env)->NewObject(env, jclass_DisplayMode, ctor, saved_width, saved_height, bpp, saved_freq); jobject newMode = (*env)->NewObject(env, jclass_DisplayMode, ctor, saved_width, saved_height, bpp, saved_freq);
@ -336,7 +336,7 @@ jobject initDisplay(JNIEnv *env, int screen) {
free(avail_modes); free(avail_modes);
/* Fetch the current gamma ramp */ /* Fetch the current gamma ramp */
saved_gamma_ramp_length = getGammaRampLengthOfDisplay(disp, screen); saved_gamma_ramp_length = getGammaRampLengthOfDisplay(env, disp, screen);
if (saved_gamma_ramp_length > 0) { if (saved_gamma_ramp_length > 0) {
r_ramp = (unsigned short *)malloc(sizeof(unsigned short)*saved_gamma_ramp_length); r_ramp = (unsigned short *)malloc(sizeof(unsigned short)*saved_gamma_ramp_length);
g_ramp = (unsigned short *)malloc(sizeof(unsigned short)*saved_gamma_ramp_length); g_ramp = (unsigned short *)malloc(sizeof(unsigned short)*saved_gamma_ramp_length);
@ -363,18 +363,18 @@ static void setCurrentGamma(Display *disp, int screen, JNIEnv *env) {
if (env != NULL) if (env != NULL)
throwException(env, "Could not set gamma ramp."); throwException(env, "Could not set gamma ramp.");
else else
printfDebug("Could not set gamma ramp\n"); printfDebugJava(env, "Could not set gamma ramp");
} }
} }
void temporaryRestoreMode(int screen) { void temporaryRestoreMode(JNIEnv *env, int screen) {
Display *disp = XOpenDisplay(NULL); Display *disp = XOpenDisplay(NULL);
if (disp == NULL) { if (disp == NULL) {
printfDebug("Could not open display"); printfDebugJava(env, "Could not open display");
return; return;
} }
if (!setMode(disp, screen, current_width, current_height, current_freq, false)) if (!setMode(env, disp, screen, current_width, current_height, current_freq, false))
printfDebug("Could not restore mode\n"); printfDebugJava(env, "Could not restore mode");
setCurrentGamma(disp, screen, NULL); setCurrentGamma(disp, screen, NULL);
XCloseDisplay(disp); XCloseDisplay(disp);
// Don't propagate error to caller // Don't propagate error to caller
@ -397,17 +397,17 @@ void switchDisplayMode(JNIEnv * env, jobject mode, int screen) {
throwException(env, "Could not open display"); throwException(env, "Could not open display");
return; return;
} }
if (!setMode(disp, screen, width, height, freq, false)) if (!setMode(env, disp, screen, width, height, freq, false))
throwException(env, "Could not switch mode."); throwException(env, "Could not switch mode.");
XCloseDisplay(disp); XCloseDisplay(disp);
} }
void resetDisplayMode(int screen, bool temporary) { void resetDisplayMode(JNIEnv *env, int screen, bool temporary) {
Display *disp = XOpenDisplay(NULL); Display *disp = XOpenDisplay(NULL);
if (disp == NULL) if (disp == NULL)
return; return;
if (!setMode(disp, screen, saved_width, saved_height, saved_freq, temporary)) { if (!setMode(env, disp, screen, saved_width, saved_height, saved_freq, temporary)) {
printfDebug("Failed to reset mode"); printfDebugJava(env, "Failed to reset mode");
} }
if (saved_gamma_ramp_length > 0) { if (saved_gamma_ramp_length > 0) {
XF86VidModeSetGammaRamp(disp, screen, saved_gamma_ramp_length, r_ramp, g_ramp, b_ramp); XF86VidModeSetGammaRamp(disp, screen, saved_gamma_ramp_length, r_ramp, g_ramp, b_ramp);
@ -428,7 +428,7 @@ jobjectArray getAvailableDisplayModes(JNIEnv * env, int screen) {
int bpp = XDefaultDepth(disp, screen); int bpp = XDefaultDepth(disp, screen);
avail_modes = getDisplayModes(disp, screen, &num_modes); avail_modes = getDisplayModes(disp, screen, &num_modes);
if (avail_modes == NULL) { if (avail_modes == NULL) {
printfDebug("Could not get display modes\n"); printfDebugJava(env, "Could not get display modes");
XCloseDisplay(disp); XCloseDisplay(disp);
return NULL; return NULL;
} }
@ -453,7 +453,7 @@ void setGammaRamp(JNIEnv *env, jobject gamma_ramp_buffer, int screen) {
return; return;
} }
freeCurrentGamma(); freeCurrentGamma();
current_gamma_ramp_length = getGammaRampLengthOfDisplay(disp, screen); current_gamma_ramp_length = getGammaRampLengthOfDisplay(env, disp, screen);
if (current_gamma_ramp_length == 0) { if (current_gamma_ramp_length == 0) {
throwException(env, "Gamma ramp not supported"); throwException(env, "Gamma ramp not supported");
return; return;

6
src/native/linux/display.h
View File

@ -51,11 +51,11 @@ extern int getScreenModeWidth(void);
extern int getScreenModeHeight(void); extern int getScreenModeHeight(void);
extern jobject initDisplay(JNIEnv *env, int screen); extern jobject initDisplay(JNIEnv *env, int screen);
extern void switchDisplayMode(JNIEnv * env, jobject mode, int screen); extern void switchDisplayMode(JNIEnv * env, jobject mode, int screen);
extern void resetDisplayMode(int screen, bool temporary); extern void resetDisplayMode(JNIEnv *env, int screen, bool temporary);
extern jobjectArray getAvailableDisplayModes(JNIEnv * env, int screen); extern jobjectArray getAvailableDisplayModes(JNIEnv * env, int screen);
extern int getGammaRampLength(int screen); extern int getGammaRampLength(JNIEnv *env, int screen);
extern void setGammaRamp(JNIEnv *env, jobject gamma_ramp_buffer, int screen); extern void setGammaRamp(JNIEnv *env, jobject gamma_ramp_buffer, int screen);
extern extension getCurrentDisplayModeExtension(); extern extension getCurrentDisplayModeExtension();
extern void temporaryRestoreMode(int screen); extern void temporaryRestoreMode(JNIEnv *env, int screen);
#endif #endif

4
src/native/linux/org_lwjgl_input_Keyboard.c
View File

@ -285,12 +285,12 @@ void handleKeyEvent(XKeyEvent *event) {
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_pollKeyboard(JNIEnv * env, jobject this, jobject buffer) { JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_pollKeyboard(JNIEnv * env, jobject this, jobject buffer) {
unsigned char *new_keyboard_buffer = (unsigned char *)(*env)->GetDirectBufferAddress(env, buffer); unsigned char *new_keyboard_buffer = (unsigned char *)(*env)->GetDirectBufferAddress(env, buffer);
handleMessages(); handleMessages(env);
memcpy(new_keyboard_buffer, key_buf, KEYBOARD_SIZE*sizeof(unsigned char)); memcpy(new_keyboard_buffer, key_buf, KEYBOARD_SIZE*sizeof(unsigned char));
} }
JNIEXPORT int JNICALL Java_org_lwjgl_opengl_LinuxDisplay_readKeyboard(JNIEnv * env, jobject this, jobject buffer, jint buffer_position) { JNIEXPORT int JNICALL Java_org_lwjgl_opengl_LinuxDisplay_readKeyboard(JNIEnv * env, jobject this, jobject buffer, jint buffer_position) {
handleMessages(); handleMessages(env);
jint* buffer_ptr = (jint *)(*env)->GetDirectBufferAddress(env, buffer); jint* buffer_ptr = (jint *)(*env)->GetDirectBufferAddress(env, buffer);
int buffer_size = ((*env)->GetDirectBufferCapacity(env, buffer))/sizeof(jint) - buffer_position; int buffer_size = ((*env)->GetDirectBufferCapacity(env, buffer))/sizeof(jint) - buffer_position;
return copyEvents(&event_queue, buffer_ptr + buffer_position, buffer_size); return copyEvents(&event_queue, buffer_ptr + buffer_position, buffer_size);

4
src/native/linux/org_lwjgl_input_Mouse.c
View File

@ -365,7 +365,7 @@ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_pollMouse(JNIEnv * env
int coords_length = (*env)->GetDirectBufferCapacity(env, coord_buffer_obj); int coords_length = (*env)->GetDirectBufferCapacity(env, coord_buffer_obj);
unsigned char *buttons_buffer = (unsigned char *)(*env)->GetDirectBufferAddress(env, button_buffer_obj); unsigned char *buttons_buffer = (unsigned char *)(*env)->GetDirectBufferAddress(env, button_buffer_obj);
int buttons_length = (*env)->GetDirectBufferCapacity(env, button_buffer_obj); int buttons_length = (*env)->GetDirectBufferCapacity(env, button_buffer_obj);
handleMessages(); handleMessages(env);
if (coords_length < 3) { if (coords_length < 3) {
printfDebug("ERROR: Not enough space in coords array: %d < 3\n", coords_length); printfDebug("ERROR: Not enough space in coords array: %d < 3\n", coords_length);
return; return;
@ -394,7 +394,7 @@ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_enableMouseBuffer(JNIE
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_LinuxDisplay_readMouse(JNIEnv *env, jobject this, jobject buffer, jint buffer_position) { JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_LinuxDisplay_readMouse(JNIEnv *env, jobject this, jobject buffer, jint buffer_position) {
jint* buffer_ptr = (jint *)(*env)->GetDirectBufferAddress(env, buffer); jint* buffer_ptr = (jint *)(*env)->GetDirectBufferAddress(env, buffer);
int buffer_size = ((*env)->GetDirectBufferCapacity(env, buffer))/sizeof(jint) - buffer_position; int buffer_size = ((*env)->GetDirectBufferCapacity(env, buffer))/sizeof(jint) - buffer_position;
handleMessages(); handleMessages(env);
return copyEvents(&event_queue, buffer_ptr + buffer_position, buffer_size); return copyEvents(&event_queue, buffer_ptr + buffer_position, buffer_size);
} }

24
src/native/linux/org_lwjgl_opengl_Display.c
View File

@ -199,7 +199,7 @@ static void setDecorations(int dec) {
XChangeProperty (getDisplay(), getCurrentWindow(), motif_hints_atom, motif_hints_atom, 32, PropModeReplace, (unsigned char *)&motif_hints, sizeof(MotifWmHints)/sizeof(long)); XChangeProperty (getDisplay(), getCurrentWindow(), motif_hints_atom, motif_hints_atom, 32, PropModeReplace, (unsigned char *)&motif_hints, sizeof(MotifWmHints)/sizeof(long));
} }
bool releaseInput(void) { static bool releaseInput(JNIEnv *env) {
if (isLegacyFullscreen() || input_released) if (isLegacyFullscreen() || input_released)
return false; return false;
input_released = true; input_released = true;
@ -207,19 +207,19 @@ bool releaseInput(void) {
updateInputGrab(); updateInputGrab();
if (current_window_mode == FULLSCREEN_NETWM) { if (current_window_mode == FULLSCREEN_NETWM) {
XIconifyWindow(getDisplay(), getCurrentWindow(), getCurrentScreen()); XIconifyWindow(getDisplay(), getCurrentWindow(), getCurrentScreen());
resetDisplayMode(getCurrentScreen(), true); resetDisplayMode(env, getCurrentScreen(), true);
} }
return true; return true;
} }
static void acquireInput(void) { static void acquireInput(JNIEnv *env) {
if (isLegacyFullscreen() || !input_released) if (isLegacyFullscreen() || !input_released)
return; return;
input_released = false; input_released = false;
setRepeatMode(AutoRepeatModeOff); setRepeatMode(AutoRepeatModeOff);
updateInputGrab(); updateInputGrab();
if (current_window_mode == FULLSCREEN_NETWM) { if (current_window_mode == FULLSCREEN_NETWM) {
temporaryRestoreMode(getCurrentScreen()); temporaryRestoreMode(env, getCurrentScreen());
} }
} }
@ -246,20 +246,20 @@ void setGrab(bool new_grab) {
} }
} }
static void checkInput(void) { static void checkInput(JNIEnv *env) {
Window win; Window win;
int revert_mode; int revert_mode;
XGetInputFocus(getDisplay(), &win, &revert_mode); XGetInputFocus(getDisplay(), &win, &revert_mode);
if (win == current_win) { if (win == current_win) {
acquireInput(); acquireInput(env);
focused = true; focused = true;
} else { } else {
releaseInput(); releaseInput(env);
focused = false; focused = false;
} }
} }
void handleMessages(void) { void handleMessages(JNIEnv *env) {
XEvent event; XEvent event;
/* Window win; /* Window win;
int revert_mode;*/ int revert_mode;*/
@ -310,7 +310,7 @@ void handleMessages(void) {
break; break;
} }
} }
checkInput(); checkInput(env);
} }
static void setWindowTitle(const char *title) { static void setWindowTitle(const char *title) {
@ -439,7 +439,7 @@ int getWindowHeight(void) {
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_update JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_update
(JNIEnv *env, jobject this) (JNIEnv *env, jobject this)
{ {
handleMessages(); handleMessages(env);
} }
static bool makeCurrent(void) { static bool makeCurrent(void) {
@ -676,11 +676,11 @@ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_switchDisplayMode(JNIE
} }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_resetDisplayMode(JNIEnv *env, jobject this) { JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_resetDisplayMode(JNIEnv *env, jobject this) {
resetDisplayMode(getCurrentScreen(), false); resetDisplayMode(env, getCurrentScreen(), false);
} }
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_LinuxDisplay_getGammaRampLength(JNIEnv *env, jobject this) { JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_LinuxDisplay_getGammaRampLength(JNIEnv *env, jobject this) {
return (jint)getGammaRampLength(getCurrentScreen()); return (jint)getGammaRampLength(env, getCurrentScreen());
} }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_setGammaRamp(JNIEnv *env, jobject this, jobject gamma_buffer) { JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_setGammaRamp(JNIEnv *env, jobject this, jobject gamma_buffer) {