JNIEXPORT jobject JNICALL
awt_GetComponent(JNIEnv* env, void* platformInfo)
{
Window window = (Window)platformInfo;
jobject peer = NULL;
jobject target = NULL;
AWT_LOCK();
if (window != None) {
peer = JNU_CallStaticMethodByName(env, NULL, "sun/awt/X11/XToolkit",
"windowToXWindow", "(J)Lsun/awt/X11/XBaseWindow;", (jlong)window).l;
}
if ((peer != NULL) &&
(JNU_IsInstanceOfByName(env, peer, "sun/awt/X11/XWindow") == 1)) {
target = (*env)->GetObjectField(env, peer, targetID);
}
if (target == NULL) {
JNU_ThrowNullPointerException(env, "NullPointerException");
AWT_UNLOCK();
return (jobject)NULL;
}
AWT_UNLOCK();
return target;
}
JNIEXPORT int32_t JNICALL
awt_GetColor(JAWT_DrawingSurface* ds, int32_t r, int32_t g, int32_t b)
{
JNIEnv* env;
jobject target, peer;
jclass componentClass;
AwtGraphicsConfigDataPtr adata;
int32_t result;
jobject gc_object;
if (ds == NULL) {
#ifdef DEBUG
fprintf(stderr, "Drawing Surface is NULL\n");
#endif
return (int32_t) 0;
}
env = ds->env;
target = ds->target;
/* Make sure the target is a java.awt.Component */
componentClass = (*env)->FindClass(env, "java/awt/Component");
if (!(*env)->IsInstanceOf(env, target, componentClass)) {
#ifdef DEBUG
fprintf(stderr, "DrawingSurface target must be a component\n");
#endif
return (int32_t) 0;
}
if (!awtLockInited) {
return (int32_t) 0;
}
AWT_LOCK();
/* Get the peer of the target component */
peer = (*env)->GetObjectField(env, target, componentIDs.peer);
if (JNU_IsNull(env, peer)) {
#ifdef DEBUG
fprintf(stderr, "Component peer is NULL\n");
#endif
AWT_UNLOCK();
return (int32_t) 0;
}
/* GraphicsConfiguration object of MComponentPeer */
gc_object = (*env)->GetObjectField(env, peer, graphicsConfigID);
if (gc_object != NULL) {
adata = (AwtGraphicsConfigDataPtr)
JNU_GetLongFieldAsPtr(env, gc_object,
x11GraphicsConfigIDs.aData);
} else {
adata = getDefaultConfig(DefaultScreen(awt_display));
}
result = adata->AwtColorMatch(r, g, b, adata);
AWT_UNLOCK();
return result;
}
JNIEXPORT void JNICALL
Java_java_awt_AWTEvent_nativeSetSource(JNIEnv *env, jobject self,
jobject newSource)
{
jbyteArray bdata;
AWT_LOCK();
bdata = (jbyteArray)(*env)->GetObjectField(env, self, awtEventIDs.bdata);
if (bdata != NULL) {
XEvent *xev;
Window w;
jboolean dummy;
/* get the widget out of the peer newSource */
struct ComponentData *cdata = (struct ComponentData *)
JNU_GetLongFieldAsPtr(env, newSource, mComponentPeerIDs.pData);
if (JNU_IsNull(env, cdata) || (cdata == NULL) ||
((cdata->widget != NULL) && (XtIsObject(cdata->widget)) &&
(cdata->widget->core.being_destroyed))) {
JNU_ThrowNullPointerException(env, "null widget");
AWT_UNLOCK();
return;
}
/* get the Window out of the widget */
w = XtWindow(cdata->widget);
if (w == None) {
JNU_ThrowNullPointerException(env, "null window");
AWT_UNLOCK();
return;
}
/* reset the filed in the event */
xev = (XEvent *)(*env)->GetPrimitiveArrayCritical(env, bdata, &dummy);
if (xev == NULL) {
JNU_ThrowNullPointerException(env, "null data");
AWT_UNLOCK();
return;
}
xev->xany.window = w;
(*env)->ReleasePrimitiveArrayCritical(env, bdata, (void *)xev, 0);
}
AWT_UNLOCK();
}
/*
* Class: sun_awt_DefaultMouseInfoPeer
* Method: isWindowUnderMouse
* Signature: (Ljava/awt/Window)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_DefaultMouseInfoPeer_isWindowUnderMouse
(JNIEnv * env, jclass cls, jobject window)
{
Window rootWindow, childWindow;
int i;
int32_t xr, yr, xw, yw;
uint32_t keys;
BOOL pointerFound;
struct FrameData *wdata;
jobject winPeer;
if ((*env)->EnsureLocalCapacity(env, 1) < 0) {
return JNI_FALSE;
}
winPeer = (*env)->GetObjectField(env, window, componentIDs.peer);
if (JNU_IsNull(env, winPeer)) {
return JNI_FALSE;
}
wdata = (struct FrameData *)
JNU_GetLongFieldAsPtr(env, winPeer, mComponentPeerIDs.pData);
(*env)->DeleteLocalRef(env, winPeer);
if (wdata == NULL) {
return JNI_FALSE;
}
AWT_LOCK();
pointerFound = XQueryPointer(awt_display, XtWindow(wdata->winData.shell),
&rootWindow, &childWindow,
&xr, &yr, &xw, &yw, &keys);
AWT_UNLOCK();
return pointerFound ? JNI_TRUE : JNI_FALSE;
}
/**
* This function invokes the native threadsafe flushing and unlocking
* mechanism (e.g. the AWT_FLUSH_UNLOCK() macro in the GLX case) to ensure
* the preceding OpenGL commands are completed before the surface is unlocked
* in a synchronized manner. See OGLSurfaceData.h for more information
* on the recognized constant values for the flushFlag parameter.
*/
void
OGLSD_UnlockImpl(JNIEnv *env, jint flushFlag)
{
J2dTraceLn1(J2D_TRACE_INFO, "in OGLSD_UnlockImpl (flush=%d)", flushFlag);
switch (flushFlag) {
case OGLSD_FLUSH_ON_JED:
// if we're on the JED thread, we can use the native Toolkit thread
// flushing mechanism, which will post an asynchronous event that will
// eventually flush the context that is current to this thread
needGLFlush = JNI_TRUE;
AWT_FLUSH_UNLOCK();
break;
case OGLSD_FLUSH_NOW:
// otherwise, we have no choice but to flush immediately (or else
// any rendering not invoked from the JED thread could be left
// unflushed)
j2d_glFlush();
// FALLTHROUGH
case OGLSD_NO_FLUSH:
default:
AWT_UNLOCK();
break;
}
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XRobotPeer_mouseWheelImpl (JNIEnv *env,
jclass cls,
jint wheelAmt) {
/* Mouse wheel is implemented as a button press of button 4 and 5, so it */
/* probably could have been hacked into robot_mouseButtonEvent, but it's */
/* cleaner to give it its own command type, in case the implementation */
/* needs to be changed later. -bchristi, 6/20/01 */
int32_t repeat = abs(wheelAmt);
int32_t button = wheelAmt < 0 ? 4 : 5; /* wheel up: button 4 */
/* wheel down: button 5 */
int32_t loopIdx;
AWT_LOCK();
DTRACE_PRINTLN1("RobotPeer: mouseWheelImpl(%i)", wheelAmt);
for (loopIdx = 0; loopIdx < repeat; loopIdx++) { /* do nothing for */
/* wheelAmt == 0 */
XTestFakeButtonEvent(awt_display, button, True, CurrentTime);
XTestFakeButtonEvent(awt_display, button, False, CurrentTime);
}
XSync(awt_display, False);
AWT_UNLOCK();
}
/*
* If the application doesn't receive events with timestamp for a long time
* XtLastTimestampProcessed() will return out-of-date value. This may cause
* selection handling routines to fail (see BugTraq ID 4085183).
* This routine is to resolve this problem. It queries the current X server
* time by appending a zero-length data to a property as prescribed by
* X11 Reference Manual.
* Note that this is a round-trip request, so it can be slow. If you know
* that the Xt timestamp is up-to-date use XtLastTimestampProcessed().
*/
Time
awt_util_getCurrentServerTime() {
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
static Atom _XA_JAVA_TIME_PROPERTY_ATOM = 0;
Time server_time = 0;
AWT_LOCK();
if (_XA_JAVA_TIME_PROPERTY_ATOM == 0) {
XtAddEventHandler(awt_root_shell, PropertyChangeMask, False,
propertyChangeEventHandler, NULL);
_XA_JAVA_TIME_PROPERTY_ATOM = XInternAtom(awt_display, "_SUNW_JAVA_AWT_TIME", False);
}
timeStampUpdated = False;
XChangeProperty(awt_display, XtWindow(awt_root_shell),
_XA_JAVA_TIME_PROPERTY_ATOM, XA_ATOM, 32, PropModeAppend,
(unsigned char *)"", 0);
XFlush(awt_display);
if (awt_currentThreadIsPrivileged(env)) {
XEvent event;
XMaskEvent(awt_display, PropertyChangeMask, &event);
XtDispatchEvent(&event);
} else {
awt_MToolkit_modalWait(isTimeStampUpdated, NULL);
}
server_time = XtLastTimestampProcessed(awt_display);
AWT_UNLOCK();
return server_time;
}
JNIEXPORT void JNICALL Java_sun_font_FontManager_setNativeFontPath
(JNIEnv *env, jclass obj, jstring theString) {
#ifdef HEADLESS
return;
#else
fDirRecord fDir;
const char *theChars;
if (awt_display == NULL) {
return;
}
AWT_LOCK();
if (shouldSetXFontPath(env)) {
theChars = (*env)->GetStringUTFChars (env, theString, 0);
fDir.num = 1;
fDir.name[0] = theChars;
/* printf ("Registering the font path here %s \n", theChars ); */
AddFontsToX11FontPath ( &fDir );
if (theChars) {
(*env)->ReleaseStringUTFChars (env,
theString, (const char*)theChars);
}
}
AWT_UNLOCK();
#endif
}
// this should be called from XRobotPeer constructor
JNIEXPORT void JNICALL
Java_sun_awt_X11_XRobotPeer_setup (JNIEnv * env, jclass cls, jint numberOfButtons, jintArray buttonDownMasks)
{
int32_t xtestAvailable;
jint *tmp;
int i;
DTRACE_PRINTLN("RobotPeer: setup()");
num_buttons = numberOfButtons;
tmp = (*env)->GetIntArrayElements(env, buttonDownMasks, JNI_FALSE);
masks = (jint *)malloc(sizeof(jint) * num_buttons);
if (masks == (jint *) NULL) {
JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), NULL);
(*env)->ReleaseIntArrayElements(env, buttonDownMasks, tmp, 0);
return;
}
for (i = 0; i < num_buttons; i++) {
masks[i] = tmp[i];
}
(*env)->ReleaseIntArrayElements(env, buttonDownMasks, tmp, 0);
AWT_LOCK();
xtestAvailable = isXTestAvailable();
DTRACE_PRINTLN1("RobotPeer: XTest available = %d", xtestAvailable);
if (!xtestAvailable) {
JNU_ThrowByName(env, "java/awt/AWTException", "java.awt.Robot requires your X server support the XTEST extension version 2.2");
}
AWT_UNLOCK();
}
/*
* Class: sun_awt_DefaultMouseInfoPeer
* Method: isWindowUnderMouse
* Signature: (Ljava/awt/Window)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_DefaultMouseInfoPeer_isWindowUnderMouse
(JNIEnv * env, jclass cls, jobject window)
{
Window rootWindow = None, parentWindow = None, siblingWindow = None;
Window * children = NULL;
int i = 0;
int is_the_same_screen = 0;
int32_t xr = 0, yr = 0, xw = 0, yw = 0;
uint32_t keys = 0;
uint32_t nchildren = 0;
Bool pointerFound = 0;
struct FrameData *wdata = NULL;
jobject winPeer = NULL;
if ((*env)->EnsureLocalCapacity(env, 1) < 0) {
return JNI_FALSE;
}
winPeer = (*env)->GetObjectField(env, window, componentIDs.peer);
if (JNU_IsNull(env, winPeer)) {
return JNI_FALSE;
}
wdata = (struct FrameData *)
JNU_GetLongFieldAsPtr(env, winPeer, mComponentPeerIDs.pData);
(*env)->DeleteLocalRef(env, winPeer);
if (wdata == NULL) {
return JNI_FALSE;
}
AWT_LOCK();
XQueryTree(awt_display, XtWindow(wdata->winData.comp.widget),
&rootWindow, &parentWindow, &children, &nchildren);
is_the_same_screen = XQueryPointer(awt_display, parentWindow,
&rootWindow, &siblingWindow, &xr, &yr, &xw, &yw, &keys);
if (siblingWindow == XtWindow(wdata->winData.comp.widget) && is_the_same_screen) {
AWT_UNLOCK();
return JNI_TRUE;
}
AWT_UNLOCK();
return JNI_FALSE ;
}
/*
* The goal of this function is to find all "system" fonts which
* are needed by the JRE to display text in supported locales etc, and
* to support APIs which allow users to enumerate all system fonts and use
* them from their Java applications.
* The preferred mechanism is now using the new "fontconfig" library
* This exists on newer versions of Linux and Solaris (S10 and above)
* The library is dynamically located. The results are merged with
* a set of "known" locations and with the X11 font path, if running in
* a local X11 environment.
* The hardwired paths are built into the JDK binary so as new font locations
* are created on a host plaform for them to be located by the JRE they will
* need to be added ito the host's font configuration database, typically
* /etc/fonts/local.conf, and to ensure that directory contains a fonts.dir
* NB: Fontconfig also depends heavily for performance on the host O/S
* maintaining up to date caches.
* This is consistent with the requirements of the desktop environments
* on these OSes.
* This also frees us from X11 APIs as JRE is required to function in
* a "headless" mode where there is no Xserver.
*/
static char *getPlatformFontPathChars(JNIEnv *env, jboolean noType1, jboolean isX11) {
char **fcdirs = NULL, **x11dirs = NULL, **knowndirs = NULL, *path = NULL;
/* As of 1.5 we try to use fontconfig on both Solaris and Linux.
* If its not available NULL is returned.
*/
fcdirs = getFontConfigLocations();
#if defined(__linux__)
knowndirs = fullLinuxFontPath;
#elif defined(__solaris__)
knowndirs = fullSolarisFontPath;
#elif defined(_AIX)
knowndirs = fullAixFontPath;
#endif
/* REMIND: this code requires to be executed when the GraphicsEnvironment
* is already initialised. That is always true, but if it were not so,
* this code could throw an exception and the fontpath would fail to
* be initialised.
*/
#ifndef HEADLESS
if (isX11) { // The following only works in an x11 environment.
#if defined(__linux__)
/* There's no headless build on linux ... */
if (!AWTIsHeadless()) { /* .. so need to call a function to check */
#endif
/* Using the X11 font path to locate font files is now a fallback
* useful only if fontconfig failed, or is incomplete. So we could
* remove this code completely and the consequences should be rare
* and non-fatal. If this happens, then the calling Java code can
* be modified to no longer require that the AWT lock (the X11GE)
* be initialised prior to calling this code.
*/
AWT_LOCK();
if (isDisplayLocal(env)) {
x11dirs = getX11FontPath();
}
AWT_UNLOCK();
#if defined(__linux__)
}
#endif
}
#endif /* !HEADLESS */
path = mergePaths(fcdirs, x11dirs, knowndirs, noType1);
if (fcdirs != NULL) {
char **p = fcdirs;
while (*p != NULL) free(*p++);
free(fcdirs);
}
if (x11dirs != NULL) {
char **p = x11dirs;
while (*p != NULL) free(*p++);
free(x11dirs);
}
return path;
}
/*
* Registered with the 2D disposer to be called after the Font is GC'd.
*/
static void pDataDisposeMethod(JNIEnv *env, jlong pData)
{
struct FontData *fdata = NULL;
int32_t i = 0;
Display *display = XDISPLAY;
AWT_LOCK();
fdata = (struct FontData *)pData;
if (fdata == NULL) {
AWT_UNLOCK();
return;
}
if (fdata->xfs != NULL) {
XFreeFontSet(display, fdata->xfs);
}
/* AWT fonts are always "multifonts" and probably have been in
* all post 1.0 releases, so this test for multi fonts is
* probably not needed, and the singleton xfont is probably never used.
*/
if (fdata->charset_num > 0) {
for (i = 0; i < fdata->charset_num; i++) {
free((void *)fdata->flist[i].xlfd);
JNU_ReleaseStringPlatformChars(env, NULL,
fdata->flist[i].charset_name);
if (fdata->flist[i].load) {
XFreeFont(display, fdata->flist[i].xfont);
}
}
free((void *)fdata->flist);
/* Don't free fdata->xfont because it is equal to fdata->flist[i].xfont
for some 'i' */
} else {
if (fdata->xfont != NULL) {
XFreeFont(display, fdata->xfont);
}
}
free((void *)fdata);
AWT_UNLOCK();
}
/*
* Class: sun_awt_DefaultMouseInfoPeer
* Method: fillPointWithCoords
* Signature: (Ljava/awt/Point)I
*/
JNIEXPORT jint JNICALL
Java_sun_awt_DefaultMouseInfoPeer_fillPointWithCoords(JNIEnv *env, jclass cls,
jobject point)
{
static jclass pointClass = NULL;
jclass pointClassLocal;
static jfieldID xID, yID;
Window rootWindow, childWindow;
int i;
int32_t xr, yr, xw, yw;
uint32_t keys;
BOOL pointerFound;
AWT_LOCK();
if (pointClass == NULL) {
pointClassLocal = (*env)->FindClass(env, "java/awt/Point");
DASSERT(pointClassLocal != NULL);
if (pointClassLocal == NULL) {
AWT_UNLOCK();
return (jint)0;
}
pointClass = (jclass)(*env)->NewGlobalRef(env, pointClassLocal);
(*env)->DeleteLocalRef(env, pointClassLocal);
xID = (*env)->GetFieldID(env, pointClass, "x", "I");
yID = (*env)->GetFieldID(env, pointClass, "y", "I");
}
for (i = 0; i < awt_numScreens; i++) {
pointerFound = XQueryPointer(awt_display, x11Screens[i].root,
&rootWindow, &childWindow,
&xr, &yr, &xw, &yw, &keys);
if (pointerFound) {
(*env)->SetIntField(env, point, xID, xr);
(*env)->SetIntField(env, point, yID, yr);
AWT_UNLOCK();
return (jint)i;
}
}
/* This should never happen */
DASSERT(FALSE);
AWT_UNLOCK();
return (jint)0;
}
/*
* Class: java_awt_KeyboardFocusManager
* Method: getNativeFocusedWindow
* Signature: ()Ljava/awt/Window;
*/
JNIEXPORT jobject JNICALL
Java_java_awt_KeyboardFocusManager_getNativeFocusedWindow
(JNIEnv *env, jclass cls)
{
jobject l_peer;
AWT_LOCK();
l_peer = awt_canvas_getFocusedWindowPeer();
AWT_UNLOCK();
return (l_peer != NULL)
? (*env)->GetObjectField(env, l_peer, mComponentPeerIDs.target)
: NULL;
}
JNIEXPORT jobject JNICALL
awt_GetComponent(JNIEnv* env, void* platformInfo)
{
Window window = (Window)platformInfo;
Widget widget = NULL;
jobject peer = NULL;
jobject target = NULL;
AWT_LOCK();
target = (*env)->GetObjectField(env, peer, targetID);
if (target == NULL) {
JNU_ThrowNullPointerException(env, "NullPointerException");
AWT_UNLOCK();
return (jobject)NULL;
}
AWT_UNLOCK();
return target;
}
JNIEXPORT jobject JNICALL
awt_GetComponent(JNIEnv* env, void* platformInfo)
{
Window window = (Window)platformInfo;
Widget widget = NULL;
jobject peer = NULL;
jobject target = NULL;
AWT_LOCK();
#ifndef XAWT
if (window != None) {
widget = XtWindowToWidget(awt_display, window);
}
if (widget != NULL) {
XtVaGetValues (widget, XmNuserData, &peer, NULL);
}
if (peer != NULL) {
target = (*env)->GetObjectField(env, peer, mComponentPeerIDs.target);
}
#else
target = (*env)->GetObjectField(env, peer, targetID);
#endif
if (target == NULL) {
JNU_ThrowNullPointerException(env, "NullPointerException");
AWT_UNLOCK();
return (jobject)NULL;
}
AWT_UNLOCK();
return target;
}
/*
* The goal of this function is to find all "system" fonts which
* are needed by the JRE to display text in supported locales etc, and
* to support APIs which allow users to enumerate all system fonts and use
* them from their Java applications.
* The preferred mechanism is now using the new "fontconfig" library
* This exists on newer versions of Linux and Solaris (S10 and above)
* The library is dynamically located. The results are merged with
* a set of "known" locations and with the X11 font path, if running in
* a local X11 environment.
* The hardwired paths are built into the JDK binary so as new font locations
* are created on a host plaform for them to be located by the JRE they will
* need to be added ito the host's font configuration database, typically
* /etc/fonts/local.conf, and to ensure that directory contains a fonts.dir
* NB: Fontconfig also depends heavily for performance on the host O/S
* maintaining up to date caches.
* This is consistent with the requirements of the desktop environments
* on these OSes.
* This also frees us from X11 APIs as JRE is required to function in
* a "headless" mode where there is no Xserver.
*/
static char *getPlatformFontPathChars(JNIEnv *env, jboolean noType1) {
char **fcdirs = NULL, **x11dirs = NULL, **knowndirs = NULL, *path = NULL;
/* As of 1.5 we try to use fontconfig on both Solaris and Linux.
* If its not available NULL is returned.
*/
fcdirs = getFontConfigLocations();
#ifdef __linux__
knowndirs = fullLinuxFontPath;
#else /* IF SOLARIS */
knowndirs = fullSolarisFontPath;
#endif
/* REMIND: this code requires to be executed when the GraphicsEnvironment
* is already initialised. That is always true, but if it were not so,
* this code could throw an exception and the fontpath would fail to
* be initialised.
*/
#ifndef HEADLESS
#ifdef __linux__ /* There's no headless build on linux ... */
if (!AWTIsHeadless()) { /* .. so need to call a function to check */
#endif
AWT_LOCK();
if (isDisplayLocal(env)) {
x11dirs = getX11FontPath();
}
AWT_UNLOCK();
#ifdef __linux__
}
#endif
#endif /* !HEADLESS */
path = mergePaths(fcdirs, x11dirs, knowndirs, noType1);
if (fcdirs != NULL) {
char **p = fcdirs;
while (*p != NULL) free(*p++);
free(fcdirs);
}
if (x11dirs != NULL) {
char **p = x11dirs;
while (*p != NULL) free(*p++);
free(x11dirs);
}
return path;
}
/*
* Class: sun_awt_motif_MCustomCursor
* Method: queryBestCursor
* Signature: (Ljava/awt/Dimension;)V
*/
JNIEXPORT void JNICALL Java_sun_awt_motif_MCustomCursor_queryBestCursor
(JNIEnv *env, jclass cls, jobject dimension)
{
Window root;
uint32_t width, height;
AWT_LOCK();
root = RootWindow(awt_display, DefaultScreen(awt_display));
XQueryBestCursor(awt_display, root,
(*env)->GetIntField(env, dimension, widthID),
(*env)->GetIntField(env, dimension, heightID),
&width, &height);
(*env)->SetIntField(env, dimension, widthID, (int32_t) width);
(*env)->SetIntField(env, dimension, heightID, (int32_t) height);
AWT_UNLOCK();
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XRobotPeer_keyReleaseImpl (JNIEnv *env,
jclass cls,
jint keycode) {
AWT_LOCK();
DTRACE_PRINTLN1("RobotPeer: keyReleaseImpl(%i)", keycode);
XTestFakeKeyEvent(awt_display,
XKeysymToKeycode(awt_display, awt_getX11KeySym(keycode)),
False,
CurrentTime);
XSync(awt_display, False);
AWT_UNLOCK();
}
/*
* Class: java_awt_KeyboardFocusManager
* Method: clearGlobalFocusOwner
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_java_awt_KeyboardFocusManager__1clearGlobalFocusOwner
(JNIEnv *env, jobject self)
{
/* Redirect focus to the focus proxy of the active Window. The effect
we want is for the active Window to remain active, but for none of
its children to be the focus owner. AWT maintains state to know
that any key events delivered after this call (but before focus is
re-established elsewhere) get ignored. */
jobject activeWindow;
Widget proxy;
if ((*env)->EnsureLocalCapacity(env, 1) < 0) {
return;
}
AWT_LOCK();
activeWindow = (*env)->CallStaticObjectMethod
(env, keyboardFocusManagerIDs.keyboardFocusManagerCls,
keyboardFocusManagerIDs.markClearGlobalFocusOwnerMID);
if (activeWindow != NULL) {
// Setting focus owner to proxy will be equivalent haveing
// null focus owner in Java layer while we will still be
// able to receive key events.
proxy = findWindowsProxy(activeWindow, env);
if (proxy != NULL) {
Widget curFocusWidget = XmGetFocusWidget(proxy);
if (curFocusWidget != NULL) {
callFocusHandler(curFocusWidget, FocusOut);
}
// Disable all but proxy widgets
processTree(curFocusWidget, proxy, False);
XmProcessTraversal(proxy, XmTRAVERSE_CURRENT);
}
}
AWT_UNLOCK();
}
/*
* Function joining the code of mousePressImpl and mouseReleaseImpl
*/
void mouseAction(JNIEnv *env,
jclass cls,
jint buttonMask,
Bool isMousePress)
{
AWT_LOCK();
DTRACE_PRINTLN1("RobotPeer: mouseAction(%i)", buttonMask);
DTRACE_PRINTLN1("RobotPeer: mouseAction, press = %d", isMousePress);
if (buttonMask & java_awt_event_InputEvent_BUTTON1_MASK ||
buttonMask & java_awt_event_InputEvent_BUTTON1_DOWN_MASK )
{
XTestFakeButtonEvent(awt_display, 1, isMousePress, CurrentTime);
}
if ((buttonMask & java_awt_event_InputEvent_BUTTON2_MASK ||
buttonMask & java_awt_event_InputEvent_BUTTON2_DOWN_MASK) &&
(num_buttons >= 2)) {
XTestFakeButtonEvent(awt_display, 2, isMousePress, CurrentTime);
}
if ((buttonMask & java_awt_event_InputEvent_BUTTON3_MASK ||
buttonMask & java_awt_event_InputEvent_BUTTON3_DOWN_MASK) &&
(num_buttons >= 3)) {
XTestFakeButtonEvent(awt_display, 3, isMousePress, CurrentTime);
}
if (num_buttons > 3){
int32_t i;
int32_t button = 0;
for (i = 3; i<num_buttons; i++){
if ((buttonMask & masks[i])) {
// arrays starts from zero index => +1
// users wants to affect 4 or 5 button but they are assigned
// to the wheel so => we have to shift it to the right by 2.
button = i + 3;
XTestFakeButtonEvent(awt_display, button, isMousePress, CurrentTime);
}
}
}
XSync(awt_display, False);
AWT_UNLOCK();
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XRobotPeer_mouseMoveImpl (JNIEnv *env,
jclass cls,
jobject xgc,
jint root_x,
jint root_y) {
AwtGraphicsConfigDataPtr adata;
AWT_LOCK();
DTRACE_PRINTLN3("RobotPeer: mouseMoveImpl(%lx, %i, %i)", xgc, root_x, root_y);
adata = (AwtGraphicsConfigDataPtr) JNU_GetLongFieldAsPtr(env, xgc, x11GraphicsConfigIDs.aData);
DASSERT(adata != NULL);
XWarpPointer(awt_display, None, XRootWindow(awt_display, adata->awt_visInfo.screen), 0, 0, 0, 0, root_x, root_y);
XSync(awt_display, False);
AWT_UNLOCK();
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XRobotPeer_getRGBPixelsImpl( JNIEnv *env,
jclass cls,
jobject xgc,
jint jx,
jint jy,
jint jwidth,
jint jheight,
jint scale,
jintArray pixelArray,
jboolean useGtk) {
XImage *image;
jint *ary; /* Array of jints for sending pixel values back
* to parent process.
*/
Window rootWindow;
XWindowAttributes attr;
AwtGraphicsConfigDataPtr adata;
DTRACE_PRINTLN6("RobotPeer: getRGBPixelsImpl(%lx, %d, %d, %d, %d, %x)", xgc, jx, jy, jwidth, jheight, pixelArray);
if (jwidth <= 0 || jheight <= 0) {
return;
}
adata = (AwtGraphicsConfigDataPtr) JNU_GetLongFieldAsPtr(env, xgc, x11GraphicsConfigIDs.aData);
DASSERT(adata != NULL);
AWT_LOCK();
jint sx = jx * scale;
jint sy = jy * scale;
jint swidth = jwidth * scale;
jint sheight = jheight * scale;
rootWindow = XRootWindow(awt_display, adata->awt_visInfo.screen);
if (!useGtk) {
if (hasXCompositeOverlayExtension(awt_display) &&
isXCompositeDisplay(awt_display, adata->awt_visInfo.screen))
{
rootWindow = compositeGetOverlayWindow(awt_display, rootWindow);
}
}
if (!XGetWindowAttributes(awt_display, rootWindow, &attr)
|| sx + swidth <= attr.x
|| attr.x + attr.width <= sx
|| sy + sheight <= attr.y
|| attr.y + attr.height <= sy) {
AWT_UNLOCK();
return; // Does not intersect with root window
}
gboolean gtk_failed = TRUE;
jint _x, _y;
jint x = MAX(sx, attr.x);
jint y = MAX(sy, attr.y);
jint width = MIN(sx + swidth, attr.x + attr.width) - x;
jint height = MIN(sy + sheight, attr.y + attr.height) - y;
int dx = attr.x > sx ? attr.x - sx : 0;
int dy = attr.y > sy ? attr.y - sy : 0;
int index;
if (useGtk) {
gtk->gdk_threads_enter();
gtk_failed = gtk->get_drawable_data(env, pixelArray, x, y, width,
height, jwidth, dx, dy, scale);
gtk->gdk_threads_leave();
}
if (gtk_failed) {
image = getWindowImage(awt_display, rootWindow, sx, sy, swidth, sheight);
ary = (*env)->GetPrimitiveArrayCritical(env, pixelArray, NULL);
if (!ary) {
XDestroyImage(image);
AWT_UNLOCK();
return;
}
dx /= scale;
dy /= scale;
width /= scale;
height /= scale;
/* convert to Java ARGB pixels */
for (_y = 0; _y < height; _y++) {
for (_x = 0; _x < width; _x++) {
jint pixel = (jint) XGetPixel(image, _x * scale, _y * scale);
/* Note ignore upper
* 32-bits on 64-bit
* OSes.
*/
pixel |= 0xff000000; /* alpha - full opacity */
index = (_y + dy) * jwidth + (_x + dx);
ary[index] = pixel;
}
}
XDestroyImage(image);
(*env)->ReleasePrimitiveArrayCritical(env, pixelArray, ary, 0);
}
AWT_UNLOCK();
}
/*
* Get the drawing surface info.
* The value returned may be cached, but the values may change if
* additional calls to Lock() or Unlock() are made.
* Lock() must be called before this can return a valid value.
* Returns NULL if an error has occurred.
* When finished with the returned value, FreeDrawingSurfaceInfo must be
* called.
*/
JNIEXPORT JAWT_DrawingSurfaceInfo* JNICALL
awt_DrawingSurface_GetDrawingSurfaceInfo(JAWT_DrawingSurface* ds)
{
JNIEnv* env;
jobject target, peer;
jclass componentClass;
JAWT_X11DrawingSurfaceInfo* px;
JAWT_DrawingSurfaceInfo* p;
XWindowAttributes attrs;
if (ds == NULL) {
#ifdef DEBUG
fprintf(stderr, "Drawing Surface is NULL\n");
#endif
return NULL;
}
env = ds->env;
target = ds->target;
/* Make sure the target is a java.awt.Component */
componentClass = (*env)->FindClass(env, "java/awt/Component");
if (!(*env)->IsInstanceOf(env, target, componentClass)) {
#ifdef DEBUG
fprintf(stderr, "DrawingSurface target must be a component\n");
#endif
return NULL;
}
if (!awtLockInited) {
return NULL;
}
AWT_LOCK();
/* Get the peer of the target component */
peer = (*env)->GetObjectField(env, target, componentIDs.peer);
if (JNU_IsNull(env, peer)) {
#ifdef DEBUG
fprintf(stderr, "Component peer is NULL\n");
#endif
AWT_UNLOCK();
return NULL;
}
AWT_UNLOCK();
/* Allocate platform-specific data */
px = (JAWT_X11DrawingSurfaceInfo*)
malloc(sizeof(JAWT_X11DrawingSurfaceInfo));
/* Set drawable and display */
px->drawable = (*env)->GetLongField(env, peer, windowID);
px->display = awt_display;
/* Get window attributes to set other values */
XGetWindowAttributes(awt_display, (Window)(px->drawable), &attrs);
/* Set the other values */
px->visualID = XVisualIDFromVisual(attrs.visual);
px->colormapID = attrs.colormap;
px->depth = attrs.depth;
px->GetAWTColor = awt_GetColor;
/* Allocate and initialize platform-independent data */
p = (JAWT_DrawingSurfaceInfo*)malloc(sizeof(JAWT_DrawingSurfaceInfo));
p->platformInfo = px;
p->ds = ds;
p->bounds.x = (*env)->GetIntField(env, target, componentIDs.x);
p->bounds.y = (*env)->GetIntField(env, target, componentIDs.y);
p->bounds.width = (*env)->GetIntField(env, target, componentIDs.width);
p->bounds.height = (*env)->GetIntField(env, target, componentIDs.height);
p->clipSize = 1;
p->clip = &(p->bounds);
/* Return our new structure */
return p;
}
static void awt_unlock_wrapper(JNIEnv *env) {
AWT_UNLOCK();
}
/*
* Class: sun_awt_X11SurfaceData
* Method: initIDs
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_sun_awt_X11SurfaceData_initIDs(JNIEnv *env, jclass xsd, jclass XORComp)
{
#ifndef HEADLESS
void *lib = 0;
union {
char c[4];
int i;
} endian;
endian.i = 0xff000000;
nativeByteOrder = (endian.c[0]) ? MSBFirst : LSBFirst;
cachedXImage = NULL;
if (sizeof(X11RIPrivate) > SD_RASINFO_PRIVATE_SIZE) {
JNU_ThrowInternalError(env, "Private RasInfo structure too large!");
return;
}
xorCompClass = (*env)->NewGlobalRef(env, XORComp);
if (getenv("NO_J2D_DGA") == NULL) {
/* we use RTLD_NOW because of bug 4032715 */
#ifdef DEBUG
lib = dlopen("libsunwjdga_g.so", RTLD_NOW);
#else
lib = dlopen("libsunwjdga.so", RTLD_NOW);
#endif
}
dgaAvailable = JNI_FALSE;
if (lib != NULL) {
JDgaStatus ret = JDGA_FAILED;
void *sym = dlsym(lib, "JDgaLibInit");
if (sym != NULL) {
theJDgaInfo.display = awt_display;
AWT_LOCK();
ret = (*(JDgaLibInitFunc *)sym)(env, &theJDgaInfo);
AWT_UNLOCK();
}
if (ret == JDGA_SUCCESS) {
pJDgaInfo = &theJDgaInfo;
dgaAvailable = JNI_TRUE;
useDGAWithPixmaps = (getenv("USE_DGA_PIXMAPS") != NULL);
} else {
dlclose(lib);
lib = NULL;
}
}
#ifdef MITSHM
if (getenv("NO_AWT_MITSHM") == NULL &&
getenv("NO_J2D_MITSHM") == NULL) {
char * force;
TryInitMITShm(env, &useMitShmExt, &useMitShmPixmaps);
useMitShmPixmaps = (useMitShmPixmaps == CAN_USE_MITSHM);
force = getenv("J2D_PIXMAPS");
if (force != NULL) {
if (strcmp(force, "shared") == 0) {
forceSharedPixmaps = JNI_TRUE;
} else if (strcmp(force, "server") == 0) {
useMitShmPixmaps = JNI_FALSE;
}
}
}
#endif /* MITSHM */
#endif /* !HEADLESS */
}
JNIEXPORT void JNICALL
Java_sun_awt_X11_XRobotPeer_getRGBPixelsImpl( JNIEnv *env,
jclass cls,
jobject xgc,
jint x,
jint y,
jint width,
jint height,
jintArray pixelArray) {
XImage *image;
jint *ary; /* Array of jints for sending pixel values back
* to parent process.
*/
Window rootWindow;
AwtGraphicsConfigDataPtr adata;
DTRACE_PRINTLN6("RobotPeer: getRGBPixelsImpl(%lx, %d, %d, %d, %d, %x)", xgc, x, y, width, height, pixelArray);
AWT_LOCK();
/* avoid a lot of work for empty rectangles */
if ((width * height) == 0) {
AWT_UNLOCK();
return;
}
DASSERT(width * height > 0); /* only allow positive size */
adata = (AwtGraphicsConfigDataPtr) JNU_GetLongFieldAsPtr(env, xgc, x11GraphicsConfigIDs.aData);
DASSERT(adata != NULL);
rootWindow = XRootWindow(awt_display, adata->awt_visInfo.screen);
image = getWindowImage(awt_display, rootWindow, x, y, width, height);
/* Array to use to crunch around the pixel values */
ary = (jint *) malloc(width * height * sizeof (jint));
if (ary == NULL) {
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
XDestroyImage(image);
AWT_UNLOCK();
return;
}
/* convert to Java ARGB pixels */
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
jint pixel = (jint) XGetPixel(image, x, y); /* Note ignore upper
* 32-bits on 64-bit
* OSes.
*/
pixel |= 0xff000000; /* alpha - full opacity */
ary[(y * width) + x] = pixel;
}
}
(*env)->SetIntArrayRegion(env, pixelArray, 0, height * width, ary);
free(ary);
XDestroyImage(image);
AWT_UNLOCK();
}
