Java example source code file (XlibWrapper.c)
The XlibWrapper.c Java example source code/*
* Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include "sun_awt_X11_XlibWrapper.h"
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Xatom.h>
#include <X11/extensions/Xdbe.h>
#include <X11/extensions/shape.h>
#include <string.h>
#include <stdlib.h>
#include <X11/Sunkeysym.h>
#include <jni.h>
#include <jni_util.h>
#include <jlong.h>
#include <sizecalc.h>
#include <awt.h>
#include <awt_util.h>
#include <jvm.h>
#include <Region.h>
#include "utility/rect.h"
#include <X11/XKBlib.h>
#if defined(DEBUG) || defined(INTERNAL_BUILD)
static jmethodID lockIsHeldMID = NULL;
static void
CheckHaveAWTLock(JNIEnv *env)
{
if (lockIsHeldMID == NULL) {
if (tkClass == NULL) return;
lockIsHeldMID =
(*env)->GetStaticMethodID(env, tkClass,
"isAWTLockHeldByCurrentThread", "()Z");
}
if (!(*env)->CallStaticBooleanMethod(env, tkClass, lockIsHeldMID)) {
JNU_ThrowInternalError(env, "Current thread does not hold AWT_LOCK!");
}
}
#define AWT_CHECK_HAVE_LOCK() CheckHaveAWTLock(env)
#else
#define AWT_CHECK_HAVE_LOCK()
#endif
/*
* Class: XlibWrapper
* Method: XOpenDisplay
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XOpenDisplay
(JNIEnv *env, jclass clazz, jlong display_name)
{
Display *dp;
AWT_CHECK_HAVE_LOCK();
dp = XOpenDisplay((char *) jlong_to_ptr(display_name));
return ptr_to_jlong(dp);
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XCloseDisplay(JNIEnv *env, jclass clazz,
jlong display) {
AWT_CHECK_HAVE_LOCK();
XCloseDisplay((Display*) jlong_to_ptr(display));
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XDisplayString(JNIEnv *env, jclass clazz,
jlong display) {
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XDisplayString((Display*) jlong_to_ptr(display)));
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XSetCloseDownMode(JNIEnv *env, jclass clazz,
jlong display, jint mode) {
AWT_CHECK_HAVE_LOCK();
XSetCloseDownMode((Display*) jlong_to_ptr(display), (int)mode);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: DefaultScreen
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DefaultScreen (JNIEnv *env, jclass clazz, jlong display) {
AWT_CHECK_HAVE_LOCK();
return (jlong) DefaultScreen((Display *) jlong_to_ptr(display));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: ScreenOfDisplay
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_ScreenOfDisplay(JNIEnv *env, jclass clazz, jlong display, jlong screen_number) {
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(ScreenOfDisplay((Display *) jlong_to_ptr(display),
screen_number));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: DoesBackingStore
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_DoesBackingStore(JNIEnv *env, jclass clazz, jlong screen) {
AWT_CHECK_HAVE_LOCK();
return (jint) DoesBackingStore((Screen*) jlong_to_ptr(screen));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: DisplayWidth
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayWidth
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
AWT_CHECK_HAVE_LOCK();
return (jlong) DisplayWidth((Display *) jlong_to_ptr(display),screen);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: DisplayWidthMM
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayWidthMM
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
AWT_CHECK_HAVE_LOCK();
return (jlong) DisplayWidthMM((Display *) jlong_to_ptr(display),screen);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: DisplayHeight
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayHeight
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
AWT_CHECK_HAVE_LOCK();
return (jlong) DisplayHeight((Display *) jlong_to_ptr(display),screen);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: DisplayHeightMM
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_DisplayHeightMM
(JNIEnv *env, jclass clazz, jlong display, jlong screen) {
AWT_CHECK_HAVE_LOCK();
return (jlong) DisplayHeightMM((Display *) jlong_to_ptr(display),screen);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: RootWindow
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_RootWindow
(JNIEnv *env , jclass clazz, jlong display, jlong screen_number) {
AWT_CHECK_HAVE_LOCK();
return (jlong) RootWindow((Display *) jlong_to_ptr(display), screen_number);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: ScreenCount
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_ScreenCount
(JNIEnv *env , jclass clazz, jlong display) {
AWT_CHECK_HAVE_LOCK();
return ScreenCount((Display *) jlong_to_ptr(display));
}
/*
* Class: XlibWrapper
* Method: XCreateWindow
* Signature: (JJIIIIIIJJJJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreateWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window,
jint x, jint y, jint w, jint h , jint border_width, jint depth,
jlong wclass, jlong visual, jlong valuemask, jlong attributes)
{
AWT_CHECK_HAVE_LOCK();
return XCreateWindow((Display *) jlong_to_ptr(display),(Window) window, x, y, w, h,
border_width, depth, wclass, (Visual *) jlong_to_ptr(visual),
valuemask, (XSetWindowAttributes *) jlong_to_ptr(attributes));
}
/*
* Class: XlibWrapper
* Method: XConvertCase
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XConvertCase
(JNIEnv *env, jclass clazz, jlong keysym,
jlong keysym_lowercase, jlong keysym_uppercase)
{
AWT_CHECK_HAVE_LOCK();
XConvertCase(keysym, (jlong_to_ptr(keysym_lowercase)),
(jlong_to_ptr(keysym_uppercase)));
}
/*
* Class: XlibWrapper
* Method: XMapWindow
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMapWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XMapWindow( (Display *)jlong_to_ptr(display),(Window) window);
}
/*
* Class: XlibWrapper
* Method: XMapRaised
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMapRaised
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XMapRaised( (Display *)jlong_to_ptr(display),(Window) window);
}
/*
* Class: XlibWrapper
* Method: XRaiseWindow
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRaiseWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XRaiseWindow( (Display *)jlong_to_ptr(display),(Window) window);
}
/*
* Class: XlibWrapper
* Method: XLowerWindow
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XLowerWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XLowerWindow( (Display *)jlong_to_ptr(display),(Window) window);
}
/*
* Class: XlibWrapper
* Method: XRestackWindows
* Signature: (JJI)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRestackWindows
(JNIEnv *env, jclass clazz, jlong display, jlong windows, jint length)
{
AWT_CHECK_HAVE_LOCK();
XRestackWindows( (Display *) jlong_to_ptr(display), (Window *) jlong_to_ptr(windows), length);
}
/*
* Class: XlibWrapper
* Method: XConfigureWindow
* Signature: (JJJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XConfigureWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong value_mask,
jlong values)
{
AWT_CHECK_HAVE_LOCK();
XConfigureWindow((Display*)jlong_to_ptr(display), (Window)window,
(unsigned int)value_mask, (XWindowChanges*)jlong_to_ptr(values));
}
/*
* Class: XlibWrapper
* Method: XSetInputFocus
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, CurrentTime);
}
/*
* Class: XlibWrapper
* Method: XSetInputFocus2
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetInputFocus2
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong time)
{
AWT_CHECK_HAVE_LOCK();
XSetInputFocus( (Display *)jlong_to_ptr(display),(Window) window, RevertToPointerRoot, time);
}
/*
* Class: XlibWrapper
* Method: XGetInputFocus
* Signature: (JJ)V
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetInputFocus
(JNIEnv *env, jclass clazz, jlong display)
{
Window focusOwner;
int revert_to;
AWT_CHECK_HAVE_LOCK();
XGetInputFocus( (Display *)jlong_to_ptr(display), &focusOwner, &revert_to);
return focusOwner;
}
/*
* Class: XlibWrapper
* Method: XDestroyWindow
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XDestroyWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XDestroyWindow( (Display *)jlong_to_ptr(display),(Window) window);
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGrabPointer
(JNIEnv *env, jclass clazz, jlong display, jlong window,
jint owner_events, jint event_mask, jint pointer_mode,
jint keyboard_mode, jlong confine_to, jlong cursor, jlong time)
{
AWT_CHECK_HAVE_LOCK();
return XGrabPointer( (Display *)jlong_to_ptr(display), (Window) window,
(Bool) owner_events, (unsigned int) event_mask, (int) pointer_mode,
(int) keyboard_mode, (Window) confine_to, (Cursor) cursor, (Time) time);
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUngrabPointer
(JNIEnv *env, jclass clazz, jlong display, jlong time)
{
AWT_CHECK_HAVE_LOCK();
XUngrabPointer( (Display *)jlong_to_ptr(display), (Time) time);
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGrabKeyboard
(JNIEnv *env, jclass clazz, jlong display, jlong window,
jint owner_events, jint pointer_mode,
jint keyboard_mode, jlong time)
{
AWT_CHECK_HAVE_LOCK();
return XGrabKeyboard( (Display *)jlong_to_ptr(display), (Window) window,
(Bool) owner_events, (int) pointer_mode,
(int) keyboard_mode, (Time) time);
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUngrabKeyboard
(JNIEnv *env, jclass clazz, jlong display, jlong time)
{
AWT_CHECK_HAVE_LOCK();
XUngrabKeyboard( (Display *)jlong_to_ptr(display), (Time) time);
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XGrabServer(JNIEnv *env, jclass clazz,
jlong display) {
AWT_CHECK_HAVE_LOCK();
XGrabServer((Display*)jlong_to_ptr(display));
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XUngrabServer(JNIEnv *env, jclass clazz,
jlong display) {
AWT_CHECK_HAVE_LOCK();
XUngrabServer((Display*)jlong_to_ptr(display));
/* Workaround for bug 5039226 */
XSync((Display*)jlong_to_ptr(display), False);
}
/*
* Class: XlibWrapper
* Method: XUnmapWindow
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XUnmapWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XUnmapWindow( (Display *)jlong_to_ptr(display),(Window) window);
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSelectInput
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong mask)
{
AWT_CHECK_HAVE_LOCK();
XSelectInput((Display *) jlong_to_ptr(display), (Window) window, mask);
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSelectEvents
(JNIEnv *env, jclass clazz, jlong display, jlong device, jlong bits_to_change, jlong values_for_bits)
{
AWT_CHECK_HAVE_LOCK();
XkbSelectEvents((Display *) jlong_to_ptr(display), (unsigned int)device,
(unsigned long)bits_to_change,
(unsigned long)values_for_bits);
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSelectEventDetails
(JNIEnv *env, jclass clazz, jlong display, jlong device, jlong event_type, jlong bits_to_change, jlong values_for_bits)
{
AWT_CHECK_HAVE_LOCK();
XkbSelectEventDetails((Display *) jlong_to_ptr(display), (unsigned int)device,
(unsigned int) event_type,
(unsigned long)bits_to_change,
(unsigned long)values_for_bits);
}
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbQueryExtension
(JNIEnv *env, jclass clazz, jlong display, jlong opcode_rtrn, jlong event_rtrn,
jlong error_rtrn, jlong major_in_out, jlong minor_in_out)
{
AWT_CHECK_HAVE_LOCK();
return XkbQueryExtension( (Display *) jlong_to_ptr(display),
(int *) jlong_to_ptr(opcode_rtrn),
(int *) jlong_to_ptr(event_rtrn),
(int *) jlong_to_ptr(error_rtrn),
(int *) jlong_to_ptr(major_in_out),
(int *) jlong_to_ptr(minor_in_out));
}
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbLibraryVersion
(JNIEnv *env, jclass clazz, jlong lib_major_in_out, jlong lib_minor_in_out)
{
AWT_CHECK_HAVE_LOCK();
*((int *)jlong_to_ptr(lib_major_in_out)) = XkbMajorVersion;
*((int *)jlong_to_ptr(lib_minor_in_out)) = XkbMinorVersion;
return XkbLibraryVersion((int *)jlong_to_ptr(lib_major_in_out), (int *)jlong_to_ptr(lib_minor_in_out));
}
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XkbGetMap
(JNIEnv *env, jclass clazz, jlong display, jlong which, jlong device_spec)
{
AWT_CHECK_HAVE_LOCK();
return (jlong) XkbGetMap( (Display *) jlong_to_ptr(display),
(unsigned int) which,
(unsigned int) device_spec);
}
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XkbGetUpdatedMap
(JNIEnv *env, jclass clazz, jlong display, jlong which, jlong xkb)
{
AWT_CHECK_HAVE_LOCK();
return (jlong) XkbGetUpdatedMap( (Display *) jlong_to_ptr(display),
(unsigned int) which,
(XkbDescPtr) jlong_to_ptr(xkb));
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbFreeKeyboard
(JNIEnv *env, jclass clazz, jlong xkb, jlong which, jboolean free_all)
{
AWT_CHECK_HAVE_LOCK();
XkbFreeKeyboard(jlong_to_ptr(xkb), (unsigned int)which, free_all);
}
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XkbTranslateKeyCode
(JNIEnv *env, jclass clazz, jlong xkb, jint keycode, jlong mods, jlong mods_rtrn, jlong keysym_rtrn)
{
Bool b;
b = XkbTranslateKeyCode((XkbDescPtr)xkb, (unsigned int)keycode, (unsigned int)mods,
(unsigned int *)jlong_to_ptr(mods_rtrn),
(KeySym *)jlong_to_ptr(keysym_rtrn));
//printf("native, input: keycode:0x%0X; mods:0x%0X\n", keycode, mods);
//printf("native, output: keysym:0x%0X; mods:0x%0X\n", *(unsigned int *)jlong_to_ptr(keysym_rtrn), *(unsigned int *)jlong_to_ptr(mods_rtrn));
return b;
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XkbSetDetectableAutoRepeat
(JNIEnv *env, jclass clazz, jlong display, jboolean detectable)
{
AWT_CHECK_HAVE_LOCK();
XkbSetDetectableAutoRepeat((Display *) jlong_to_ptr(display), detectable, NULL);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XNextEvent
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XNextEvent
(JNIEnv *env, jclass clazz, jlong display, jlong ptr)
{
AWT_CHECK_HAVE_LOCK();
XNextEvent( (Display *) jlong_to_ptr(display), jlong_to_ptr(ptr));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XMaskEvent
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMaskEvent
(JNIEnv *env, jclass clazz, jlong display, jlong event_mask, jlong event_return)
{
AWT_CHECK_HAVE_LOCK();
XMaskEvent( (Display *) jlong_to_ptr(display), event_mask, (XEvent *) jlong_to_ptr(event_return));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XWindowEvent
* Signature: (JJJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XWindowEvent
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong event_mask, jlong event_return)
{
AWT_CHECK_HAVE_LOCK();
XWindowEvent( (Display *) jlong_to_ptr(display), (Window)window, event_mask, (XEvent *) jlong_to_ptr(event_return));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFilterEvent
* Signature: (JJ)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XFilterEvent
(JNIEnv *env, jclass clazz, jlong ptr, jlong window)
{
AWT_CHECK_HAVE_LOCK();
return (jboolean) XFilterEvent((XEvent *) jlong_to_ptr(ptr), (Window) window);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSupportsLocale
* Signature: ()Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XSupportsLocale
(JNIEnv *env, jclass clazz)
{
AWT_CHECK_HAVE_LOCK();
return (jboolean)XSupportsLocale();
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetLocaleModifiers
* Signature: (Ljava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_XSetLocaleModifiers
(JNIEnv *env, jclass clazz, jstring jstr)
{
char * modifier_list = NULL;
char * ret = NULL;
if (!JNU_IsNull(env, jstr)) {
modifier_list = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
}
AWT_CHECK_HAVE_LOCK();
if (modifier_list) {
ret = XSetLocaleModifiers(modifier_list);
JNU_ReleaseStringPlatformChars(env, jstr, (const char *) modifier_list);
} else {
ret = XSetLocaleModifiers("");
}
return (ret != NULL ? JNU_NewStringPlatform(env, ret): NULL);
}
/*
* Class: sun_awt_X11_wrappers_XlibWrapper
* Method: XPeekEvent
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XPeekEvent
(JNIEnv *env, jclass clazz, jlong display, jlong ptr)
{
AWT_CHECK_HAVE_LOCK();
XPeekEvent((Display *) jlong_to_ptr(display),jlong_to_ptr(ptr));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XMoveResizeWindow
* Signature: (JJIIII)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMoveResizeWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint x , jint y , jint width, jint height) {
AWT_CHECK_HAVE_LOCK();
XMoveResizeWindow( (Display *) jlong_to_ptr(display), (Window) window, x, y, width, height);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XResizeWindow
* Signature: (JJII)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XResizeWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height)
{
AWT_CHECK_HAVE_LOCK();
XResizeWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XMoveWindow
* Signature: (JJII)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XMoveWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint width, jint height)
{
AWT_CHECK_HAVE_LOCK();
XMoveWindow( (Display *) jlong_to_ptr(display),(Window) window,width,height);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetWindowBackground
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWindowBackground
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong background_pixel) {
AWT_CHECK_HAVE_LOCK();
XSetWindowBackground((Display *) jlong_to_ptr(display),window,background_pixel);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFlush
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFlush
(JNIEnv *env, jclass clazz, jlong display) {
AWT_CHECK_HAVE_LOCK();
XFlush((Display *)jlong_to_ptr(display));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSync
* Signature: (JI)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSync
(JNIEnv *env, jclass clazz, jlong display, jint discard) {
AWT_CHECK_HAVE_LOCK();
XSync((Display *) jlong_to_ptr(display), discard);
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XTranslateCoordinates
(JNIEnv *env, jclass clazz, jlong display, jlong src_w, jlong dest_w,
jlong src_x, jlong src_y, jlong dest_x_return, jlong dest_y_return,
jlong child_return)
{
AWT_CHECK_HAVE_LOCK();
return XTranslateCoordinates( (Display *) jlong_to_ptr(display), src_w, dest_w,
src_x, src_y,
(int *) jlong_to_ptr(dest_x_return),
(int *) jlong_to_ptr(dest_y_return),
(Window *) jlong_to_ptr(child_return));
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XEventsQueued
(JNIEnv *env, jclass clazz, jlong display, jint mode) {
AWT_CHECK_HAVE_LOCK();
return XEventsQueued((Display *) jlong_to_ptr(display), mode);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: SetProperty
* Signature: (JJJLjava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_SetProperty
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom, jstring jstr) {
char *cname;
XTextProperty tp;
int32_t status;
/*
In case there are direct support of UTF-8 declared, use UTF-8 strings.
*/
if (!JNU_IsNull(env, jstr)) {
#ifdef X_HAVE_UTF8_STRING
cname = (char *) (*env)->GetStringUTFChars(env, jstr, JNI_FALSE);
#else
cname = (char *) JNU_GetStringPlatformChars(env, jstr, NULL);
#endif
} else {
cname = "";
}
AWT_CHECK_HAVE_LOCK();
#ifdef X_HAVE_UTF8_STRING
status = Xutf8TextListToTextProperty((Display *)jlong_to_ptr(display), &cname, 1,
XStdICCTextStyle, &tp);
#else
status = XmbTextListToTextProperty((Display *)jlong_to_ptr(display), &cname, 1,
XStdICCTextStyle, &tp);
#endif
if (status == Success || status > 0) {
XChangeProperty((Display *)jlong_to_ptr(display), window, atom, tp.encoding, tp.format, PropModeReplace, tp.value, tp.nitems);
if (tp.value != NULL) {
XFree(tp.value);
}
}
if (!JNU_IsNull(env, jstr)) {
#ifdef X_HAVE_UTF8_STRING
(*env)->ReleaseStringUTFChars(env, jstr, (const char *) cname);
#else
JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
#endif
}
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XChangeProperty
* Signature: (JJJJJJJJJJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangePropertyImpl(
JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property,
jlong type, jint format, jint mode, jlong data, jint nelements)
{
AWT_CHECK_HAVE_LOCK();
XChangeProperty((Display*) jlong_to_ptr(display), (Window) window, (Atom) property,
(Atom) type, format, mode, (unsigned char*) jlong_to_ptr(data),
nelements);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XChangePropertyS
* Signature: (JJJJJJJJJLjava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangePropertyS(
JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property,
jlong type, jint format, jint mode, jstring value)
{
jboolean iscopy;
const char * chars = JNU_GetStringPlatformChars(env, value, &iscopy);
AWT_CHECK_HAVE_LOCK();
XChangeProperty((Display*)jlong_to_ptr(display), window, (Atom)property,
(Atom)type, format, mode, (unsigned char*)chars, strlen(chars));
if (iscopy) {
JNU_ReleaseStringPlatformChars(env, value, chars);
}
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetWindowProperty
* Signature: (JJJJJJJJJJJ)J;
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWindowProperty
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong property, jlong long_offset,
jlong long_length, jlong delete, jlong req_type, jlong actual_type,
jlong actual_format, jlong nitems_ptr, jlong bytes_after, jlong data_ptr)
{
AWT_CHECK_HAVE_LOCK();
return XGetWindowProperty((Display*) jlong_to_ptr(display), window, property, long_offset, long_length,
delete, (Atom) req_type, (Atom*) jlong_to_ptr(actual_type),
(int *) jlong_to_ptr(actual_format), (unsigned long *) jlong_to_ptr(nitems_ptr),
(unsigned long*) jlong_to_ptr(bytes_after), (unsigned char**) jlong_to_ptr(data_ptr));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: GetProperty
* Signature: (JJJ)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_GetProperty
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom)
{
/* Request status */
int status;
/* Returns of XGetWindowProperty */
Atom actual_type;
int actual_format;
unsigned long nitems;
unsigned long bytes_after;
unsigned char * string;
jstring res;
AWT_CHECK_HAVE_LOCK();
status = XGetWindowProperty((Display*)jlong_to_ptr(display), window,
atom, 0, 0xFFFF, False, XA_STRING,
&actual_type, &actual_format, &nitems, &bytes_after,
&string);
if (status != Success || string == NULL) {
return NULL;
}
if (actual_type != XA_STRING || actual_format != 8) {
XFree(string);
return NULL;
}
// Memory leak???
return JNU_NewStringPlatform(env,(char*) string);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: InternAtom
* Signature: (JLjava/lang/String;I)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_InternAtom
(JNIEnv *env, jclass clazz, jlong display, jstring jstr, jint ife) {
char *cname;
unsigned long atom;
if (!JNU_IsNull(env, jstr)) {
cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
} else {
cname = "";
}
AWT_CHECK_HAVE_LOCK();
atom = XInternAtom((Display *) jlong_to_ptr(display), cname, ife);
if (!JNU_IsNull(env, jstr)) {
JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
}
return (jlong) atom;
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XCreateFontCursor
(JNIEnv *env, jclass clazz, jlong display, jint shape) {
AWT_CHECK_HAVE_LOCK();
return XCreateFontCursor((Display *) jlong_to_ptr(display), (int) shape);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XCreatePixmapCursor
* Signature: (JJJJJII)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreatePixmapCursor
(JNIEnv *env , jclass clazz, jlong display, jlong source, jlong mask, jlong fore, jlong back, jint x , jint y) {
AWT_CHECK_HAVE_LOCK();
return (jlong) XCreatePixmapCursor((Display *) jlong_to_ptr(display), (Pixmap) source, (Pixmap) mask,
(XColor *) jlong_to_ptr(fore), (XColor *) jlong_to_ptr(back), x, y);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XQueryBestCursor
* Signature: (JJIIJJ)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryBestCursor
(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jint width, jint height, jlong width_return, jlong height_return) {
Status status;
AWT_CHECK_HAVE_LOCK();
status = XQueryBestCursor((Display *) jlong_to_ptr(display), (Drawable) drawable, width,height,
(unsigned int *) jlong_to_ptr(width_return), (unsigned int *) jlong_to_ptr(height_return));
if (status == 0) return JNI_FALSE;
else return JNI_TRUE;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFreeCursor
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFreeCursor
(JNIEnv *env, jclass clazz, jlong display, jlong cursor) {
AWT_CHECK_HAVE_LOCK();
XFreeCursor( (Display *) jlong_to_ptr(display), (Cursor) cursor);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XQueryPointer
* Signature: (JJJJJJJJJ)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryPointer
(JNIEnv *env, jclass clazz, jlong display, jlong w, jlong root_return, jlong child_return, jlong root_x_return , jlong root_y_return, jlong win_x_return, jlong win_y_return, jlong mask_return) {
Bool b;
AWT_CHECK_HAVE_LOCK();
b = XQueryPointer((Display *) jlong_to_ptr(display),
(Window) w, (Window *) jlong_to_ptr(root_return), (Window *) jlong_to_ptr(child_return),
(int *) jlong_to_ptr(root_x_return), (int *) jlong_to_ptr(root_y_return),
(int *) jlong_to_ptr(win_x_return), (int *) jlong_to_ptr(win_y_return),
(unsigned int *) jlong_to_ptr(mask_return));
if (b == True) return JNI_TRUE;
else return JNI_FALSE;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XChangeWindowAttributes
* Signature: (JJJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XChangeWindowAttributes
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong valuemask, jlong attributes) {
AWT_CHECK_HAVE_LOCK();
XChangeWindowAttributes((Display *) jlong_to_ptr(display), (Window) window, (unsigned long) valuemask,
(XSetWindowAttributes *) jlong_to_ptr(attributes));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetTransientFor
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetTransientFor
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong transient_for_window)
{
AWT_CHECK_HAVE_LOCK();
XSetTransientForHint((Display *) jlong_to_ptr(display), window, transient_for_window);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetWMHints
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWMHints
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints)
{
AWT_CHECK_HAVE_LOCK();
XSetWMHints((Display *) jlong_to_ptr(display), window, (XWMHints *) jlong_to_ptr(hints));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetWMHints
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XGetWMHints
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints)
{
XWMHints * get_hints;
AWT_CHECK_HAVE_LOCK();
get_hints = XGetWMHints((Display*)jlong_to_ptr(display), window);
if (get_hints != NULL) {
memcpy(jlong_to_ptr(hints), get_hints, sizeof(XWMHints));
XFree(get_hints);
} else {
memset(jlong_to_ptr(hints), 0, sizeof(XWMHints));
}
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetPointerMapping
* Signature: (JJI)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetPointerMapping
(JNIEnv *env, jclass clazz, jlong display, jlong map, jint buttonNumber)
{
AWT_CHECK_HAVE_LOCK();
return XGetPointerMapping((Display*)jlong_to_ptr(display), (unsigned char*) jlong_to_ptr(map), buttonNumber);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetDefault
* Signature: (JJI)I
*/
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_XGetDefault
(JNIEnv *env, jclass clazz, jlong display, jstring program, jstring option)
{
char * c_program = NULL;
char * c_option = NULL;
char * c_res = NULL;
if (!JNU_IsNull(env, program)) {
c_program = (char *)JNU_GetStringPlatformChars(env, program, NULL);
}
if (!JNU_IsNull(env, option)) {
c_option = (char *)JNU_GetStringPlatformChars(env, option, NULL);
}
if (c_program == NULL || c_option == NULL) {
if (!JNU_IsNull(env, program)) {
JNU_ReleaseStringPlatformChars(env, program, (const char *) c_program);
}
if (!JNU_IsNull(env, option)) {
JNU_ReleaseStringPlatformChars(env, option, (const char *) c_option);
}
return NULL;
}
AWT_CHECK_HAVE_LOCK();
c_res = XGetDefault((Display*)jlong_to_ptr(display), c_program, c_option);
if (!JNU_IsNull(env, program)) {
JNU_ReleaseStringPlatformChars(env, program, (const char *) c_program);
}
if (!JNU_IsNull(env, option)) {
JNU_ReleaseStringPlatformChars(env, option, (const char *) c_option);
}
if (c_res != NULL) {
// Memory leak???
return JNU_NewStringPlatform(env, c_res);
} else {
return NULL;
}
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: getScreenOfWindow
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_getScreenOfWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
XWindowAttributes attrs;
memset(&attrs, 0, sizeof(attrs));
AWT_CHECK_HAVE_LOCK();
XGetWindowAttributes((Display *) jlong_to_ptr(display), window, &attrs);
return ptr_to_jlong(attrs.screen);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XScreenNumberOfScreen
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XScreenNumberOfScreen
(JNIEnv *env, jclass clazz, jlong screen)
{
AWT_CHECK_HAVE_LOCK();
if(jlong_to_ptr(screen) == NULL) {
return -1;
}
return XScreenNumberOfScreen((Screen*) jlong_to_ptr(screen));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XIconifyWindow
* Signature: (JJJ)V
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XIconifyWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong screenNumber)
{
AWT_CHECK_HAVE_LOCK();
return XIconifyWindow((Display*) jlong_to_ptr(display), window, screenNumber);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFree
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFree
(JNIEnv *env, jclass clazz, jlong ptr)
{
AWT_CHECK_HAVE_LOCK();
XFree(jlong_to_ptr(ptr));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFree
* Signature: (J)V
*/
JNIEXPORT jbyteArray JNICALL Java_sun_awt_X11_XlibWrapper_getStringBytes
(JNIEnv *env, jclass clazz, jlong str_ptr)
{
unsigned char * str = (unsigned char*) jlong_to_ptr(str_ptr);
long length = strlen((char*)str);
jbyteArray res = (*env)->NewByteArray(env, length);
void * storage = malloc(length+1);
memcpy(storage, str, length+1);
(*env)->SetByteArrayRegion(env, res, 0, length,
(const signed char*) storage);
return res;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: ServerVendor
* Signature: (J)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_ServerVendor
(JNIEnv *env, jclass clazz, jlong display)
{
AWT_CHECK_HAVE_LOCK();
return JNU_NewStringPlatform(env, ServerVendor((Display*)jlong_to_ptr(display)));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: VendorRelease
* Signature: (J)I;
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_VendorRelease
(JNIEnv *env, jclass clazz, jlong display)
{
AWT_CHECK_HAVE_LOCK();
return VendorRelease((Display*)jlong_to_ptr(display));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: IsXsunKPBehavior
* Signature: (J)Z;
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsXsunKPBehavior
(JNIEnv *env, jclass clazz, jlong display)
{
// Xsun without XKB uses keysymarray[2] keysym to determine if it is KP event.
// Otherwise, it is [1] or sometimes [0].
// This sniffer first tries to determine what is a keycode for XK_KP_7
// using XKeysymToKeycode;
// second, in which place in the keysymarray is XK_KP_7
// using XKeycodeToKeysym.
int kc7;
AWT_CHECK_HAVE_LOCK();
kc7 = XKeysymToKeycode((Display*)jlong_to_ptr(display), XK_KP_7);
if( !kc7 ) {
// keycode is not defined. Why, it's a reduced keyboard perhaps:
// report arbitrarily false.
return JNI_FALSE;
} else {
long ks2 = XKeycodeToKeysym((Display*)jlong_to_ptr(display), kc7, 2);
if( ks2 == XK_KP_7 ) {
//XXX If some Xorg server would put XK_KP_7 in keysymarray[2] as well,
//XXX for yet unknown to me reason, the sniffer would lie.
return JNI_TRUE;
}else{
return JNI_FALSE;
}
}
}
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsSunKeyboard
(JNIEnv *env, jclass clazz, jlong display)
{
int xx;
AWT_CHECK_HAVE_LOCK();
xx = XKeysymToKeycode((Display*)jlong_to_ptr(display), SunXK_F37);
return (!xx) ? JNI_FALSE : JNI_TRUE;
}
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsKanaKeyboard
(JNIEnv *env, jclass clazz, jlong display)
{
int xx;
static jboolean result = JNI_FALSE;
int32_t minKeyCode, maxKeyCode, keySymsPerKeyCode;
KeySym *keySyms, *keySymsStart, keySym;
int32_t i;
int32_t kanaCount = 0;
AWT_CHECK_HAVE_LOCK();
// There's no direct way to determine whether the keyboard has
// a kana lock key. From available keyboard mapping tables, it looks
// like only keyboards with the kana lock key can produce keysyms
// for kana characters. So, as an indirect test, we check for those.
XDisplayKeycodes((Display*)jlong_to_ptr(display), &minKeyCode, &maxKeyCode);
keySyms = XGetKeyboardMapping((Display*)jlong_to_ptr(display), minKeyCode, maxKeyCode - minKeyCode + 1, &keySymsPerKeyCode);
keySymsStart = keySyms;
for (i = 0; i < (maxKeyCode - minKeyCode + 1) * keySymsPerKeyCode; i++) {
keySym = *keySyms++;
if ((keySym & 0xff00) == 0x0400) {
kanaCount++;
}
}
XFree(keySymsStart);
// use a (somewhat arbitrary) minimum so we don't get confused by a stray function key
result = kanaCount > 10;
return result ? JNI_TRUE : JNI_FALSE;
}
JavaVM* jvm = NULL;
static int ToolkitErrorHandler(Display * dpy, XErrorEvent * event) {
JNIEnv * env;
// First call the native synthetic error handler declared in "awt_util.h" file.
if (current_native_xerror_handler != NULL) {
current_native_xerror_handler(dpy, event);
}
if (jvm != NULL) {
env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
if (env) {
return JNU_CallStaticMethodByName(env, NULL, "sun/awt/X11/XErrorHandlerUtil",
"globalErrorHandler", "(JJ)I", ptr_to_jlong(dpy), ptr_to_jlong(event)).i;
}
}
return 0;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: SetToolkitErrorHandler
* Signature: ()J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_SetToolkitErrorHandler
(JNIEnv *env, jclass clazz)
{
(*env)->GetJavaVM(env, &jvm);
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XSetErrorHandler(ToolkitErrorHandler));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetErrorHandler
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetErrorHandler
(JNIEnv *env, jclass clazz, jlong handler)
{
AWT_CHECK_HAVE_LOCK();
XSetErrorHandler((XErrorHandler) jlong_to_ptr(handler));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: CallErrorHandler
* Signature: (JJJ)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_CallErrorHandler
(JNIEnv *env, jclass clazz, jlong handler, jlong display, jlong event_ptr)
{
return (*(XErrorHandler)jlong_to_ptr(handler))((Display*) jlong_to_ptr(display), (XErrorEvent*) jlong_to_ptr(event_ptr));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: PrintXErrorEvent
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_PrintXErrorEvent
(JNIEnv *env, jclass clazz, jlong display, jlong event_ptr)
{
char msg[128];
char buf[128];
XErrorEvent* err = (XErrorEvent *)jlong_to_ptr(event_ptr);
XGetErrorText((Display *)jlong_to_ptr(display), err->error_code, msg, sizeof(msg));
jio_fprintf(stderr, "Xerror %s, XID %x, ser# %d\n", msg, err->resourceid, err->serial);
jio_snprintf(buf, sizeof(buf), "%d", err->request_code);
XGetErrorDatabaseText((Display *)jlong_to_ptr(display), "XRequest", buf, "Unknown", msg, sizeof(msg));
jio_fprintf(stderr, "Major opcode %d (%s)\n", err->request_code, msg);
if (err->request_code > 128) {
jio_fprintf(stderr, "Minor opcode %d\n", err->minor_code);
}
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XInternAtoms
* Signature: (J[Ljava/lang/String;ZJ)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XInternAtoms
(JNIEnv *env, jclass clazz, jlong display, jobjectArray names_arr, jboolean only_if_exists, jlong atoms)
{
int length = (*env)->GetArrayLength(env, names_arr);
char ** names = (char**)malloc(length*sizeof(char*));
jboolean copy;
int index, name_index = 0;
int status;
AWT_CHECK_HAVE_LOCK();
for (index = 0; index < length; index++) {
jstring str = (*env)->GetObjectArrayElement(env, names_arr, index);
if (!JNU_IsNull(env, str)) {
const char * str_char = JNU_GetStringPlatformChars(env, str, NULL);
names[name_index++] = strdup(str_char);
JNU_ReleaseStringPlatformChars(env, str, str_char);
(*env)->DeleteLocalRef(env, str);
}
}
status = XInternAtoms((Display*)jlong_to_ptr(display), names, name_index, only_if_exists, (Atom*) jlong_to_ptr(atoms));
for (index = 0; index < length; index++) {
free(names[index]);
}
free(names);
return status;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetWindowAttributes
* Signature: (JJJ)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWindowAttributes
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong attr_ptr)
{
jint status;
AWT_CHECK_HAVE_LOCK();
memset((XWindowAttributes*) jlong_to_ptr(attr_ptr), 0, sizeof(XWindowAttributes));
status = XGetWindowAttributes((Display*)jlong_to_ptr(display), window, (XWindowAttributes*) jlong_to_ptr(attr_ptr));
return status;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetGeometry
* Signature: (JJJJJJJJJ)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetGeometry
(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong root_return,
jlong x_return, jlong y_return, jlong width_return, jlong height_return,
jlong border_width_return, jlong depth_return)
{
jint status;
AWT_CHECK_HAVE_LOCK();
status = XGetGeometry((Display *)jlong_to_ptr(display),
(Drawable)drawable, (Window *)jlong_to_ptr(root_return),
(int *)jlong_to_ptr(x_return), (int *)jlong_to_ptr(y_return),
(unsigned int *)jlong_to_ptr(width_return), (unsigned int *)jlong_to_ptr(height_return),
(unsigned int *)jlong_to_ptr(border_width_return),
(unsigned int *)jlong_to_ptr(depth_return));
return status;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetWMNormalHints
* Signature: (JJJJ)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XGetWMNormalHints
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints, jlong supplied_return)
{
AWT_CHECK_HAVE_LOCK();
return XGetWMNormalHints((Display*) jlong_to_ptr(display),
window,
(XSizeHints*) jlong_to_ptr(hints),
(long*) jlong_to_ptr(supplied_return));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetWMNormalHints
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetWMNormalHints
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong hints)
{
AWT_CHECK_HAVE_LOCK();
XSetWMNormalHints((Display*) jlong_to_ptr(display), window, (XSizeHints*) jlong_to_ptr(hints));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XDeleteProperty
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XDeleteProperty
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom)
{
AWT_CHECK_HAVE_LOCK();
XDeleteProperty((Display*) jlong_to_ptr(display), window, (Atom)atom);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSendEvent
* Signature: (JJZJJ)V
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XSendEvent
(JNIEnv *env, jclass clazz, jlong display, jlong window, jboolean propagate, jlong event_mask, jlong event)
{
AWT_CHECK_HAVE_LOCK();
return XSendEvent((Display*) jlong_to_ptr(display),
window,
propagate==JNI_TRUE?True:False,
(long) event_mask,
(XEvent*) jlong_to_ptr(event));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XQueryTree
* Signature: (JJJJJJ)I
*/
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XQueryTree
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong root_return, jlong parent_return, jlong children_return, jlong nchildren_return)
{
AWT_CHECK_HAVE_LOCK();
return XQueryTree((Display*) jlong_to_ptr(display),
window,
(Window *) jlong_to_ptr(root_return),
(Window*) jlong_to_ptr(parent_return),
(Window**) jlong_to_ptr(children_return),
(unsigned int*) jlong_to_ptr(nchildren_return));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: memcpy
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_memcpy
(JNIEnv *env, jclass clazz, jlong dest_ptr, jlong src_ptr, jlong length)
{
memcpy(jlong_to_ptr(dest_ptr), jlong_to_ptr(src_ptr), length);
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XSetMinMaxHints
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint x, jint y, jint width, jint height, jlong flags) {
XSizeHints * hints;
AWT_CHECK_HAVE_LOCK();
hints = XAllocSizeHints();
hints->flags = flags;
hints->width = width;
hints->min_width = width;
hints->max_width = width;
hints->height = height;
hints->min_height = height;
hints->max_height = height;
hints->x = x;
hints->y = y;
XSetWMNormalHints((Display*) jlong_to_ptr(display), window, hints);
XFree(hints);
}
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XGetVisualInfo
(JNIEnv *env, jclass clazz, jlong display, jlong vinfo_mask, jlong vinfo_template,
jlong nitems_return)
{
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XGetVisualInfo((Display*) jlong_to_ptr(display),
(long) vinfo_mask,
(XVisualInfo*) jlong_to_ptr(vinfo_template),
(int*) jlong_to_ptr(nitems_return)));
}
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XAllocSizeHints
(JNIEnv *env, jclass clazz)
{
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XAllocSizeHints());
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XIconifyWindow
* Signature: (JJJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XBell
(JNIEnv *env, jclass clazz, jlong display, jint percent)
{
AWT_CHECK_HAVE_LOCK();
XBell((Display*)jlong_to_ptr(display), percent);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XAllocColor
* Signature: (JJJ)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XAllocColor
(JNIEnv *env, jclass clazz, jlong display , jlong colormap, jlong xcolor) {
Status status;
AWT_CHECK_HAVE_LOCK();
status = XAllocColor((Display *) jlong_to_ptr(display), (Colormap) colormap, (XColor *) jlong_to_ptr(xcolor));
if (status == 0) return JNI_FALSE;
else return JNI_TRUE;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XCreateBitmapFromData
* Signature: (JJJII)J
*/
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XCreateBitmapFromData
(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong data, jint width, jint height) {
AWT_CHECK_HAVE_LOCK();
return (jlong) XCreateBitmapFromData((Display *) jlong_to_ptr(display), (Drawable) drawable,
(char *) jlong_to_ptr(data), width, height);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XFreePixmap
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XFreePixmap
(JNIEnv *env, jclass clazz, jlong display, jlong pixmap) {
AWT_CHECK_HAVE_LOCK();
XFreePixmap((Display *)jlong_to_ptr(display), (Pixmap) pixmap);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XReparentWindow
* Signature: (JJJII)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XReparentWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong parent, jint x, jint y) {
AWT_CHECK_HAVE_LOCK();
XReparentWindow((Display*)jlong_to_ptr(display), window, parent, x, y);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XConvertSelection
* Signature: (JJJJJJ)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XConvertSelection(JNIEnv *env, jclass clazz,
jlong display, jlong selection,
jlong target, jlong property,
jlong requestor, jlong time) {
AWT_CHECK_HAVE_LOCK();
XConvertSelection((Display*)jlong_to_ptr(display), selection, target, property, requestor,
time);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetSelectionOwner
* Signature: (JJJJ)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XSetSelectionOwner(JNIEnv *env, jclass clazz,
jlong display, jlong selection,
jlong owner, jlong time) {
AWT_CHECK_HAVE_LOCK();
XSetSelectionOwner((Display*)jlong_to_ptr(display), selection, owner, time);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetSelectionOwner
* Signature: (JJ)J
*/
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XGetSelectionOwner(JNIEnv *env, jclass clazz,
jlong display, jlong selection) {
AWT_CHECK_HAVE_LOCK();
return (jlong)XGetSelectionOwner((Display*)jlong_to_ptr(display), selection);
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XGetAtomName
* Signature: (JJ)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_sun_awt_X11_XlibWrapper_XGetAtomName(JNIEnv *env, jclass clazz,
jlong display, jlong atom)
{
jstring string = NULL;
char* name;
AWT_CHECK_HAVE_LOCK();
name = (char*) XGetAtomName((Display*)jlong_to_ptr(display), atom);
if (name == NULL) {
fprintf(stderr, "Atom was %d\n", (int)atom);
JNU_ThrowNullPointerException(env, "Failed to retrieve atom name.");
return NULL;
}
string = (*env)->NewStringUTF(env, (const char *)name);
XFree(name);
return string;
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XMaxRequestSize
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XMaxRequestSize(JNIEnv *env, jclass clazz,
jlong display) {
AWT_CHECK_HAVE_LOCK();
return XMaxRequestSize((Display*) jlong_to_ptr(display));
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XAllocWMHints(JNIEnv *env, jclass clazz)
{
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XAllocWMHints());
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XCreatePixmap(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jint width, jint height, jint depth)
{
AWT_CHECK_HAVE_LOCK();
return XCreatePixmap((Display*)jlong_to_ptr(display), (Drawable)drawable, width, height, depth);
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XCreateImage
(JNIEnv *env, jclass clazz, jlong display, jlong visual_ptr,
jint depth, jint format, jint offset, jlong data, jint width,
jint height, jint bitmap_pad, jint bytes_per_line)
{
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XCreateImage((Display*) jlong_to_ptr(display), (Visual*) jlong_to_ptr(visual_ptr),
depth, format, offset, (char*) jlong_to_ptr(data),
width, height, bitmap_pad, bytes_per_line));
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XCreateGC
(JNIEnv *env, jclass clazz, jlong display, jlong drawable,
jlong valuemask, jlong values)
{
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XCreateGC((Display*) jlong_to_ptr(display), (Drawable)drawable, valuemask, (XGCValues*) jlong_to_ptr(values)));
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XDestroyImage(JNIEnv *env, jclass clazz, jlong image)
{
XImage *img = (XImage*) jlong_to_ptr(image);
AWT_CHECK_HAVE_LOCK();
// Fix for bug 4903671 :
// We should be careful to not double free the memory pointed to data
// Since we use unsafe to allocate it, we should use unsafe to free it.
// So we should NULL the data pointer before calling XDestroyImage so
// that X does not free the pointer for us.
img->data = NULL;
XDestroyImage(img);
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XPutImage(JNIEnv *env, jclass clazz, jlong display, jlong drawable, jlong gc, jlong image, jint src_x, jint src_y, jint dest_x, jint dest_y, jint width, jint height)
{
AWT_CHECK_HAVE_LOCK();
XPutImage((Display*)jlong_to_ptr(display), (Drawable)drawable, (GC) jlong_to_ptr(gc), (XImage*) jlong_to_ptr(image), src_x, src_y,
dest_x, dest_y, width, height);
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XFreeGC(JNIEnv *env, jclass clazz, jlong display, jlong gc)
{
AWT_CHECK_HAVE_LOCK();
XFreeGC((Display*) jlong_to_ptr(display), (GC) jlong_to_ptr(gc));
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XSetWindowBackgroundPixmap(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong pixmap)
{
AWT_CHECK_HAVE_LOCK();
XSetWindowBackgroundPixmap((Display*) jlong_to_ptr(display), (Window)window, (Pixmap)pixmap);
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XClearWindow(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XClearWindow((Display*) jlong_to_ptr(display), (Window)window);
}
JNIEXPORT jint JNICALL
Java_sun_awt_X11_XlibWrapper_XGetIconSizes(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong ret_sizes, jlong ret_count)
{
XIconSize** psize = (XIconSize**) jlong_to_ptr(ret_sizes);
int * pcount = (int *) jlong_to_ptr(ret_count);
Status res;
AWT_CHECK_HAVE_LOCK();
res = XGetIconSizes((Display*) jlong_to_ptr(display), (Window)window, psize, pcount);
return res;
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeQueryExtension
(JNIEnv *env, jclass clazz, jlong display, jlong major_version_return,
jlong minor_version_return)
{
AWT_CHECK_HAVE_LOCK();
return XdbeQueryExtension((Display*) jlong_to_ptr(display), (int *) jlong_to_ptr(major_version_return),
(int *) jlong_to_ptr(minor_version_return));
}
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_XQueryExtension
(JNIEnv *env, jclass clazz, jlong display, jstring jstr, jlong mop_return,
jlong feve_return, jlong err_return)
{
char *cname;
Boolean bu;
if (!JNU_IsNull(env, jstr)) {
cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
} else {
cname = "";
}
AWT_CHECK_HAVE_LOCK();
bu = XQueryExtension((Display*) jlong_to_ptr(display), cname, (int *) jlong_to_ptr(mop_return),
(int *) jlong_to_ptr(feve_return), (int *) jlong_to_ptr(err_return));
if (!JNU_IsNull(env, jstr)) {
JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
}
return bu ? JNI_TRUE : JNI_FALSE;
}
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XlibWrapper_IsKeypadKey
(JNIEnv *env, jclass clazz, jlong keysym)
{
AWT_CHECK_HAVE_LOCK();
if(IsKeypadKey(keysym)) {
return JNI_TRUE;
}
return JNI_FALSE;
}
JNIEXPORT jlong JNICALL Java_sun_awt_X11_XlibWrapper_XdbeAllocateBackBufferName
(JNIEnv *env, jclass clazz, jlong display, jlong window, jint swap_action)
{
AWT_CHECK_HAVE_LOCK();
return XdbeAllocateBackBufferName((Display*) jlong_to_ptr(display), (Window) window,
(XdbeSwapAction) swap_action);
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeDeallocateBackBufferName
(JNIEnv *env, jclass clazz, jlong display, jlong buffer)
{
AWT_CHECK_HAVE_LOCK();
return XdbeDeallocateBackBufferName((Display*) jlong_to_ptr(display), (XdbeBackBuffer) buffer);
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeBeginIdiom
(JNIEnv *env, jclass clazz, jlong display)
{
AWT_CHECK_HAVE_LOCK();
return XdbeBeginIdiom((Display*) jlong_to_ptr(display));
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeEndIdiom
(JNIEnv *env, jclass clazz, jlong display)
{
AWT_CHECK_HAVE_LOCK();
return XdbeEndIdiom((Display*) jlong_to_ptr(display));
}
JNIEXPORT jint JNICALL Java_sun_awt_X11_XlibWrapper_XdbeSwapBuffers
(JNIEnv *env, jclass clazz, jlong display, jlong swap_info, jint num_windows)
{
AWT_CHECK_HAVE_LOCK();
return XdbeSwapBuffers((Display*) jlong_to_ptr(display), (XdbeSwapInfo *) jlong_to_ptr(swap_info), num_windows);
}
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XQueryKeymap
(JNIEnv *env, jclass clazz, jlong display, jlong vector)
{
AWT_CHECK_HAVE_LOCK();
XQueryKeymap( (Display *) jlong_to_ptr(display), (char *) jlong_to_ptr(vector));
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XKeycodeToKeysym(JNIEnv *env, jclass clazz,
jlong display, jint keycode,
jint index) {
AWT_CHECK_HAVE_LOCK();
return XKeycodeToKeysym((Display*) jlong_to_ptr(display), (unsigned int)keycode, (int)index);
}
JNIEXPORT jint JNICALL
Java_sun_awt_X11_XlibWrapper_XkbGetEffectiveGroup(JNIEnv *env, jclass clazz,
jlong display) {
XkbStateRec sr;
AWT_CHECK_HAVE_LOCK();
memset(&sr, 0, sizeof(XkbStateRec));
XkbGetState((Display*) jlong_to_ptr(display), XkbUseCoreKbd, &sr);
// printf("-------------------------------------VVVV\n");
// printf(" group:0x%0X\n",sr.group);
// printf(" base_group:0x%0X\n",sr.base_group);
// printf(" latched_group:0x%0X\n",sr.latched_group);
// printf(" locked_group:0x%0X\n",sr.locked_group);
// printf(" mods:0x%0X\n",sr.mods);
// printf(" base_mods:0x%0X\n",sr.base_mods);
// printf(" latched_mods:0x%0X\n",sr.latched_mods);
// printf(" locked_mods:0x%0X\n",sr.locked_mods);
// printf(" compat_state:0x%0X\n",sr.compat_state);
// printf(" grab_mods:0x%0X\n",sr.grab_mods);
// printf(" compat_grab_mods:0x%0X\n",sr.compat_grab_mods);
// printf(" lookup_mods:0x%0X\n",sr.lookup_mods);
// printf(" compat_lookup_mods:0x%0X\n",sr.compat_lookup_mods);
// printf(" ptr_buttons:0x%0X\n",sr.ptr_buttons);
// printf("-------------------------------------^^^^\n");
return (jint)(sr.group);
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XkbKeycodeToKeysym(JNIEnv *env, jclass clazz,
jlong display, jint keycode,
jint group, jint level) {
AWT_CHECK_HAVE_LOCK();
return XkbKeycodeToKeysym((Display*) jlong_to_ptr(display), (unsigned int)keycode, (unsigned int)group, (unsigned int)level);
}
JNIEXPORT jint JNICALL
Java_sun_awt_X11_XlibWrapper_XKeysymToKeycode(JNIEnv *env, jclass clazz,
jlong display, jlong keysym) {
AWT_CHECK_HAVE_LOCK();
return XKeysymToKeycode((Display*) jlong_to_ptr(display), (KeySym)keysym);
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_XGetModifierMapping(JNIEnv *env, jclass clazz,
jlong display) {
AWT_CHECK_HAVE_LOCK();
return ptr_to_jlong(XGetModifierMapping((Display*) jlong_to_ptr(display)));
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XFreeModifiermap(JNIEnv *env, jclass clazz,
jlong keymap) {
AWT_CHECK_HAVE_LOCK();
XFreeModifiermap((XModifierKeymap*) jlong_to_ptr(keymap));
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XRefreshKeyboardMapping
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XRefreshKeyboardMapping
(JNIEnv *env, jclass clazz, jlong event_ptr)
{
AWT_CHECK_HAVE_LOCK();
XRefreshKeyboardMapping((XMappingEvent*) jlong_to_ptr(event_ptr));
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XChangeActivePointerGrab(JNIEnv *env, jclass clazz,
jlong display, jint mask,
jlong cursor, jlong time) {
AWT_CHECK_HAVE_LOCK();
XChangeActivePointerGrab((Display*)jlong_to_ptr(display), (unsigned int)mask,
(Cursor)cursor, (Time)time);
}
/******************* Secondary loop support ************************************/
#define AWT_SECONDARY_LOOP_TIMEOUT 250
static Bool exitSecondaryLoop = True;
/*
* This predicate procedure allows the Toolkit thread to process specific events
* while it is blocked waiting for the event dispatch thread to process
* a SunDropTargetEvent. We need this to prevent deadlock when the client code
* processing SunDropTargetEvent sets or gets the contents of the system
* clipboard/selection. In this case the event dispatch thread waits for the
* Toolkit thread to process PropertyNotify or SelectionNotify events.
*/
static Bool
secondary_loop_event(Display* dpy, XEvent* event, char* arg) {
return (event->type == SelectionNotify ||
event->type == SelectionClear ||
event->type == PropertyNotify) ? True : False;
}
JNIEXPORT jboolean JNICALL
Java_sun_awt_X11_XlibWrapper_XNextSecondaryLoopEvent(JNIEnv *env, jclass clazz,
jlong display, jlong ptr) {
uint32_t timeout = 1;
AWT_CHECK_HAVE_LOCK();
exitSecondaryLoop = False;
while (!exitSecondaryLoop) {
if (XCheckIfEvent((Display*) jlong_to_ptr(display), (XEvent*) jlong_to_ptr(ptr), secondary_loop_event, NULL)) {
return JNI_TRUE;
}
timeout = (timeout < AWT_SECONDARY_LOOP_TIMEOUT) ? (timeout << 1) : AWT_SECONDARY_LOOP_TIMEOUT;
AWT_WAIT(timeout);
}
return JNI_FALSE;
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_ExitSecondaryLoop(JNIEnv *env, jclass clazz) {
DASSERT(!exitSecondaryLoop);
AWT_CHECK_HAVE_LOCK();
exitSecondaryLoop = True;
AWT_NOTIFY_ALL();
}
/*******************************************************************************/
JNIEXPORT jobjectArray JNICALL
Java_sun_awt_X11_XlibWrapper_XTextPropertyToStringList(JNIEnv *env,
jclass clazz,
jbyteArray bytes,
jlong encodingAtom) {
XTextProperty tp;
jbyte *value;
char** strings = (char **)NULL;
int32_t nstrings = 0;
jobjectArray ret = NULL;
int32_t i;
jsize len;
jboolean isCopy = JNI_FALSE;
static jclass stringClass = NULL;
jclass stringClassLocal = NULL;
AWT_CHECK_HAVE_LOCK();
if (JNU_IsNull(env, stringClass)) {
stringClassLocal = (*env)->FindClass(env, "java/lang/String");
if ((*env)->ExceptionCheck(env)) {
(*env)->ExceptionDescribe(env);
(*env)->ExceptionClear(env);
DASSERT(False);
}
if (JNU_IsNull(env, stringClassLocal)) {
return NULL;
}
stringClass = (*env)->NewGlobalRef(env, stringClassLocal); /* never freed! */
(*env)->DeleteLocalRef(env, stringClassLocal);
if (JNU_IsNull(env, stringClass)) {
JNU_ThrowOutOfMemoryError(env, "");
return NULL;
}
}
/*
* If the length of the byte array is 0 just return a null
*/
len = (*env)->GetArrayLength(env, bytes);
if (len == 0) {
return (*env)->NewObjectArray(env, 0, stringClass, NULL);
}
value = (*env)->GetByteArrayElements(env, bytes, &isCopy);
if (JNU_IsNull(env, value)) {
return NULL;
}
tp.encoding = encodingAtom;
tp.value = (unsigned char *)value;
tp.nitems = len;
tp.format = 8;
/*
* Convert the byte stream into a list of X11 strings
*/
if (XTextPropertyToStringList(&tp, &strings, &nstrings) == 0) {
(*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT);
return NULL;
}
(*env)->ReleaseByteArrayElements(env, bytes, value, JNI_ABORT);
if (nstrings == 0) {
return (*env)->NewObjectArray(env, 0, stringClass, NULL);
}
ret = (*env)->NewObjectArray(env, nstrings, stringClass, NULL);
if ((*env)->ExceptionCheck(env)) {
(*env)->ExceptionDescribe(env);
(*env)->ExceptionClear(env);
goto wayout;
}
if (JNU_IsNull(env, ret)) {
goto wayout;
}
for (i = 0; i < nstrings; i++) {
jstring string = (*env)->NewStringUTF(env,
(const char *)strings[i]);
if ((*env)->ExceptionCheck(env)) {
(*env)->ExceptionDescribe(env);
(*env)->ExceptionClear(env);
goto wayout;
}
if (JNU_IsNull(env, string)) {
goto wayout;
}
(*env)->SetObjectArrayElement(env, ret, i, string);
if ((*env)->ExceptionCheck(env)) {
(*env)->ExceptionDescribe(env);
(*env)->ExceptionClear(env);
goto wayout;
}
(*env)->DeleteLocalRef(env, string);
}
wayout:
/*
* Clean up and return
*/
XFreeStringList(strings);
return ret;
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_XPutBackEvent(JNIEnv *env,
jclass clazz,
jlong display,
jlong event) {
XPutBackEvent((Display*)jlong_to_ptr(display), (XEvent*) jlong_to_ptr(event));
}
JNIEXPORT jlong JNICALL
Java_sun_awt_X11_XlibWrapper_getAddress(JNIEnv *env,
jclass clazz,
jobject o) {
return ptr_to_jlong(o);
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_copyIntArray(JNIEnv *env,
jclass clazz,
jlong dest, jobject array, jint size) {
jboolean isCopy = JNI_FALSE;
jint * ints = (*env)->GetIntArrayElements(env, array, &isCopy);
memcpy(jlong_to_ptr(dest), ints, size);
if (isCopy) {
(*env)->ReleaseIntArrayElements(env, array, ints, JNI_ABORT);
}
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_copyLongArray(JNIEnv *env,
jclass clazz,
jlong dest, jobject array, jint size) {
jboolean isCopy = JNI_FALSE;
jlong * longs = (*env)->GetLongArrayElements(env, array, &isCopy);
memcpy(jlong_to_ptr(dest), longs, size);
if (isCopy) {
(*env)->ReleaseLongArrayElements(env, array, longs, JNI_ABORT);
}
}
JNIEXPORT jint JNICALL
Java_sun_awt_X11_XlibWrapper_XSynchronize(JNIEnv *env, jclass clazz, jlong display, jboolean onoff)
{
return (jint) XSynchronize((Display*)jlong_to_ptr(display), (onoff == JNI_TRUE ? True : False));
}
JNIEXPORT jboolean JNICALL
Java_sun_awt_X11_XlibWrapper_XShapeQueryExtension
(JNIEnv *env, jclass clazz, jlong display, jlong event_base_return, jlong error_base_return)
{
jboolean status;
AWT_CHECK_HAVE_LOCK();
status = XShapeQueryExtension((Display *)jlong_to_ptr(display),
(int *)jlong_to_ptr(event_base_return), (int *)jlong_to_ptr(error_base_return));
return status;
}
/*
* Class: XlibWrapper
* Method: SetRectangularShape
*/
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_SetRectangularShape
(JNIEnv *env, jclass clazz, jlong display, jlong window,
jint x1, jint y1, jint x2, jint y2,
jobject region)
{
AWT_CHECK_HAVE_LOCK();
// If all the params are zeros, the shape must be simply reset.
// Otherwise, the shape may be not rectangular.
if (region || x1 || x2 || y1 || y2) {
XRectangle rects[256];
XRectangle *pRect = rects;
int numrects = RegionToYXBandedRectangles(env, x1, y1, x2, y2, region,
&pRect, 256);
XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded);
XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded);
if (pRect != rects) {
free(pRect);
}
} else {
// Reset the shape to a rectangular form.
XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
ShapeClip, 0, 0, None, ShapeSet);
XShapeCombineMask((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
ShapeBounding, 0, 0, None, ShapeSet);
}
}
/*
* Class: XlibWrapper
* Method: SetZOrder
*/
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_SetZOrder
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong above)
{
unsigned int value_mask = CWStackMode;
XWindowChanges wc;
wc.sibling = (Window)jlong_to_ptr(above);
AWT_CHECK_HAVE_LOCK();
if (above == 0) {
wc.stack_mode = Above;
} else {
wc.stack_mode = Below;
value_mask |= CWSibling;
}
XConfigureWindow((Display *)jlong_to_ptr(display),
(Window)jlong_to_ptr(window),
value_mask, &wc );
}
/*
* Class: XlibWrapper
* Method: SetBitmapShape
*/
JNIEXPORT void JNICALL
Java_sun_awt_X11_XlibWrapper_SetBitmapShape
(JNIEnv *env, jclass clazz, jlong display, jlong window,
jint width, jint height, jintArray bitmap)
{
jsize len;
jint *values;
jboolean isCopy = JNI_FALSE;
size_t worstBufferSize = (size_t)((width / 2 + 1) * height);
RECT_T * pRect;
int numrects;
if (!IS_SAFE_SIZE_MUL(width / 2 + 1, height)) {
return;
}
AWT_CHECK_HAVE_LOCK();
len = (*env)->GetArrayLength(env, bitmap);
if (len == 0 || len < width * height) {
return;
}
values = (*env)->GetIntArrayElements(env, bitmap, &isCopy);
if (JNU_IsNull(env, values)) {
return;
}
pRect = (RECT_T *)SAFE_SIZE_ARRAY_ALLOC(malloc, worstBufferSize, sizeof(RECT_T));
if (!pRect) {
return;
}
/* Note: the values[0] and values[1] are supposed to contain the width
* and height (see XIconInfo.getIntData() for details). So, we do +2.
*/
numrects = BitmapToYXBandedRectangles(32, (int)width, (int)height,
(unsigned char *)(values + 2), pRect);
XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
ShapeClip, 0, 0, pRect, numrects, ShapeSet, YXBanded);
XShapeCombineRectangles((Display *)jlong_to_ptr(display), (Window)jlong_to_ptr(window),
ShapeBounding, 0, 0, pRect, numrects, ShapeSet, YXBanded);
free(pRect);
(*env)->ReleaseIntArrayElements(env, bitmap, values, JNI_ABORT);
}
Other Java examples (source code examples)Here is a short list of links related to this Java XlibWrapper.c source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
