1 /*
   2  * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #ifdef HEADLESS
  27     #error This file should not be included in headless library
  28 #endif
  29 
  30 #include "awt_p.h"
  31 #include "awt_GraphicsEnv.h"
  32 #define XK_MISCELLANY
  33 #include <X11/keysymdef.h>
  34 #include <X11/Intrinsic.h>
  35 #include <X11/Xutil.h>
  36 #include <X11/Xmd.h>
  37 #include <X11/extensions/xtestext1.h>
  38 #include <X11/extensions/XTest.h>
  39 #include <X11/extensions/XInput.h>
  40 #include <X11/extensions/XI.h>
  41 #include <X11/extensions/Xcomposite.h>
  42 #include <jni.h>
  43 #include <sizecalc.h>
  44 #include "robot_common.h"
  45 #include "canvas.h"
  46 #include "wsutils.h"
  47 #include "list.h"
  48 #include "multiVis.h"
  49 
  50 #if defined(__linux__) || defined(MACOSX)
  51 #include <sys/socket.h>
  52 #endif
  53 
  54 extern struct X11GraphicsConfigIDs x11GraphicsConfigIDs;
  55 
  56 static jint * masks;
  57 static jint num_buttons;
  58 
  59 static int32_t isXTestAvailable() {
  60     int32_t major_opcode, first_event, first_error;
  61     int32_t  event_basep, error_basep, majorp, minorp;
  62     int32_t isXTestAvailable;
  63 
  64     /* check if XTest is available */
  65     isXTestAvailable = XQueryExtension(awt_display, XTestExtensionName, &major_opcode, &first_event, &first_error);
  66     DTRACE_PRINTLN3("RobotPeer: XQueryExtension(XTEST) returns major_opcode = %d, first_event = %d, first_error = %d",
  67                     major_opcode, first_event, first_error);
  68     if (isXTestAvailable) {
  69         /* check if XTest version is OK */
  70         XTestQueryExtension(awt_display, &event_basep, &error_basep, &majorp, &minorp);
  71         DTRACE_PRINTLN4("RobotPeer: XTestQueryExtension returns event_basep = %d, error_basep = %d, majorp = %d, minorp = %d",
  72                         event_basep, error_basep, majorp, minorp);
  73         if (majorp < 2 || (majorp == 2 && minorp < 2)) {
  74             /* bad version*/
  75             DTRACE_PRINTLN2("XRobotPeer: XTEST version is %d.%d \n", majorp, minorp);
  76             if (majorp == 2 && minorp == 1) {
  77                 DTRACE_PRINTLN("XRobotPeer: XTEST is 2.1 - no grab is available\n");
  78             } else {
  79                 isXTestAvailable = False;
  80             }
  81         } else {
  82             /* allow XTest calls even if someone else has the grab; e.g. during
  83              * a window resize operation. Works only with XTEST2.2*/
  84             XTestGrabControl(awt_display, True);
  85         }
  86     } else {
  87         DTRACE_PRINTLN("RobotPeer: XTEST extension is unavailable");
  88     }
  89 
  90     return isXTestAvailable;
  91 }
  92 
  93 static Bool hasXCompositeOverlayExtension(Display *display) {
  94     int xoverlay = False;
  95     int eventBase, errorBase;
  96     if (XCompositeQueryExtension(display, &eventBase, &errorBase)) {
  97         int major = 0;
  98         int minor = 0;
  99     
 100         XCompositeQueryVersion(display, &major, &minor);
 101         if (major > 0 || minor >= 3) {
 102             xoverlay = True;
 103         }
 104     }
 105     
 106     return xoverlay;
 107 }
 108   
 109 static jboolean isXCompositeDisplay(Display *display, int screenNumber) {
 110   
 111     char NET_WM_CM_Sn[25];
 112     snprintf(NET_WM_CM_Sn, sizeof(NET_WM_CM_Sn), "_NET_WM_CM_S%d\0", screenNumber);
 113  
 114     Atom managerSelection = XInternAtom(display, NET_WM_CM_Sn, 0);
 115     Window owner = XGetSelectionOwner(display, managerSelection);
 116     
 117     return owner != 0;
 118 }
 119 
 120 static XImage *getWindowImage(Display * display, Window window,
 121                               int32_t x, int32_t y,
 122                               int32_t w, int32_t h) {
 123     XImage         *image;
 124     int32_t        transparentOverlays;
 125     int32_t        numVisuals;
 126     XVisualInfo    *pVisuals;
 127     int32_t        numOverlayVisuals;
 128     OverlayInfo    *pOverlayVisuals;
 129     int32_t        numImageVisuals;
 130     XVisualInfo    **pImageVisuals;
 131     list_ptr       vis_regions;    /* list of regions to read from */
 132     list_ptr       vis_image_regions ;
 133     int32_t        allImage = 0 ;
 134     int32_t        format = ZPixmap;
 135 
 136     /* prevent user from moving stuff around during the capture */
 137     XGrabServer(display);
 138 
 139     /*
 140      * The following two functions live in multiVis.c-- they are pretty
 141      * much verbatim taken from the source to the xwd utility from the
 142      * X11 source. This version of the xwd source was somewhat better written
 143      * for reuse compared to Sun's version.
 144      *
 145      *        ftp.x.org/pub/R6.3/xc/programs/xwd
 146      *
 147      * We use these functions since they do the very tough job of capturing
 148      * the screen correctly when it contains multiple visuals. They take into
 149      * account the depth/colormap of each visual and produce a capture as a
 150      * 24-bit RGB image so we don't have to fool around with colormaps etc.
 151      */
 152 
 153     GetMultiVisualRegions(
 154         display,
 155         window,
 156         x, y, w, h,
 157         &transparentOverlays,
 158         &numVisuals,
 159         &pVisuals,
 160         &numOverlayVisuals,
 161         &pOverlayVisuals,
 162         &numImageVisuals,
 163         &pImageVisuals,
 164         &vis_regions,
 165         &vis_image_regions,
 166         &allImage );
 167 
 168     image = ReadAreaToImage(
 169         display,
 170         window,
 171         x, y, w, h,
 172         numVisuals,
 173         pVisuals,
 174         numOverlayVisuals,
 175         pOverlayVisuals,
 176         numImageVisuals,
 177         pImageVisuals,
 178         vis_regions,
 179         vis_image_regions,
 180         format,
 181         allImage );
 182 
 183     /* allow user to do stuff again */
 184     XUngrabServer(display);
 185 
 186     /* make sure the grab/ungrab is flushed */
 187     XSync(display, False);
 188 
 189     return image;
 190 }
 191 
 192 /*********************************************************************************************/
 193 
 194 // this should be called from XRobotPeer constructor
 195 JNIEXPORT void JNICALL
 196 Java_sun_awt_X11_XRobotPeer_setup (JNIEnv * env, jclass cls, jint numberOfButtons, jintArray buttonDownMasks)
 197 {
 198     int32_t xtestAvailable;
 199     jint *tmp;
 200     int i;
 201 
 202     DTRACE_PRINTLN("RobotPeer: setup()");
 203 
 204     num_buttons = numberOfButtons;
 205     tmp = (*env)->GetIntArrayElements(env, buttonDownMasks, JNI_FALSE);
 206     CHECK_NULL(tmp);
 207 
 208     masks = (jint *)SAFE_SIZE_ARRAY_ALLOC(malloc, sizeof(jint), num_buttons);
 209     if (masks == (jint *) NULL) {
 210         (*env)->ExceptionClear(env);
 211         (*env)->ReleaseIntArrayElements(env, buttonDownMasks, tmp, 0);
 212         JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), NULL);
 213         return;
 214     }
 215     for (i = 0; i < num_buttons; i++) {
 216         masks[i] = tmp[i];
 217     }
 218     (*env)->ReleaseIntArrayElements(env, buttonDownMasks, tmp, 0);
 219 
 220     AWT_LOCK();
 221     xtestAvailable = isXTestAvailable();
 222     DTRACE_PRINTLN1("RobotPeer: XTest available = %d", xtestAvailable);
 223     if (!xtestAvailable) {
 224         JNU_ThrowByName(env, "java/awt/AWTException", "java.awt.Robot requires your X server support the XTEST extension version 2.2");
 225     }
 226 
 227     AWT_UNLOCK();
 228 }
 229 
 230 
 231 JNIEXPORT void JNICALL
 232 Java_sun_awt_X11_XRobotPeer_getRGBPixelsImpl( JNIEnv *env,
 233                              jclass cls,
 234                              jobject xgc,
 235                              jint jx,
 236                              jint jy,
 237                              jint jwidth,
 238                              jint jheight,
 239                              jint scale,
 240                              jintArray pixelArray) {
 241     XImage *image;
 242     jint *ary;               /* Array of jints for sending pixel values back
 243                               * to parent process.
 244                               */
 245     Window rootWindow;
 246     XWindowAttributes attr;
 247     AwtGraphicsConfigDataPtr adata;
 248 
 249     DTRACE_PRINTLN6("RobotPeer: getRGBPixelsImpl(%lx, %d, %d, %d, %d, %x)", xgc, jx, jy, jwidth, jheight, pixelArray);
 250 
 251     if (jwidth <= 0 || jheight <= 0) {
 252         return;
 253     }
 254 
 255     adata = (AwtGraphicsConfigDataPtr) JNU_GetLongFieldAsPtr(env, xgc, x11GraphicsConfigIDs.aData);
 256     DASSERT(adata != NULL);
 257 
 258     AWT_LOCK();
 259 
 260     jint sx = jx * scale;
 261     jint sy = jy * scale;
 262     jint swidth = jwidth * scale;
 263     jint sheight = jheight * scale;
 264 
 265     rootWindow = XRootWindow(awt_display, adata->awt_visInfo.screen);
 266     if (isXCompositeDisplay(awt_display, adata->awt_visInfo.screen) &&
 267         hasXCompositeOverlayExtension(awt_display))
 268     {
 269       rootWindow = XCompositeGetOverlayWindow(awt_display, rootWindow);
 270     }
 271  
 272     if (!XGetWindowAttributes(awt_display, rootWindow, &attr)
 273             || sx + swidth <= attr.x
 274             || attr.x + attr.width <= sx
 275             || sy + sheight <= attr.y
 276             || attr.y + attr.height <= sy) {
 277 
 278         AWT_UNLOCK();
 279         return; // Does not intersect with root window
 280     }
 281 
 282     jint _x, _y;
 283 
 284     jint x = MAX(sx, attr.x);
 285     jint y = MAX(sy, attr.y);
 286     jint width = MIN(sx + swidth, attr.x + attr.width) - x;
 287     jint height = MIN(sy + sheight, attr.y + attr.height) - y;
 288 
 289 
 290     int dx = attr.x > sx ? attr.x - sx : 0;
 291     int dy = attr.y > sy ? attr.y - sy : 0;
 292 
 293     int index;
 294  
 295     image = getWindowImage(awt_display, rootWindow, sx, sy, swidth, sheight);
 296 
 297     ary = (*env)->GetPrimitiveArrayCritical(env, pixelArray, NULL);
 298 
 299     if (!ary) {
 300       XDestroyImage(image);
 301       AWT_UNLOCK();
 302       return;
 303     }
 304 
 305     dx /= scale;
 306     dy /= scale;
 307     width /= scale;
 308     height /= scale;
 309     
 310     /* convert to Java ARGB pixels */
 311     for (_y = 0; _y < height; _y++) {
 312       for (_x = 0; _x < width; _x++) {
 313         jint pixel = (jint) XGetPixel(image, _x * scale, _y * scale);
 314         /* Note ignore upper
 315          * 32-bits on 64-bit
 316          * OSes.
 317          */
 318         pixel |= 0xff000000; /* alpha - full opacity */
 319         
 320         index = (_y + dy) * jwidth + (_x + dx);
 321         ary[index] = pixel;
 322       }
 323     }
 324     
 325     XDestroyImage(image);
 326     (*env)->ReleasePrimitiveArrayCritical(env, pixelArray, ary, 0);
 327 
 328     AWT_UNLOCK();
 329 }
 330 
 331 JNIEXPORT void JNICALL
 332 Java_sun_awt_X11_XRobotPeer_keyPressImpl (JNIEnv *env,
 333                          jclass cls,
 334                          jint keycode) {
 335 
 336     AWT_LOCK();
 337 
 338     DTRACE_PRINTLN1("RobotPeer: keyPressImpl(%i)", keycode);
 339 
 340     XTestFakeKeyEvent(awt_display,
 341                       XKeysymToKeycode(awt_display, awt_getX11KeySym(keycode)),
 342                       True,
 343                       CurrentTime);
 344 
 345     XSync(awt_display, False);
 346 
 347     AWT_UNLOCK();
 348 
 349 }
 350 
 351 JNIEXPORT void JNICALL
 352 Java_sun_awt_X11_XRobotPeer_keyReleaseImpl (JNIEnv *env,
 353                            jclass cls,
 354                            jint keycode) {
 355     AWT_LOCK();
 356 
 357     DTRACE_PRINTLN1("RobotPeer: keyReleaseImpl(%i)", keycode);
 358 
 359     XTestFakeKeyEvent(awt_display,
 360                       XKeysymToKeycode(awt_display, awt_getX11KeySym(keycode)),
 361                       False,
 362                       CurrentTime);
 363 
 364     XSync(awt_display, False);
 365 
 366     AWT_UNLOCK();
 367 }
 368 
 369 JNIEXPORT void JNICALL
 370 Java_sun_awt_X11_XRobotPeer_mouseMoveImpl (JNIEnv *env,
 371                           jclass cls,
 372                           jobject xgc,
 373                           jint root_x,
 374                           jint root_y) {
 375 
 376     AwtGraphicsConfigDataPtr adata;
 377 
 378     AWT_LOCK();
 379 
 380     DTRACE_PRINTLN3("RobotPeer: mouseMoveImpl(%lx, %i, %i)", xgc, root_x, root_y);
 381 
 382     adata = (AwtGraphicsConfigDataPtr) JNU_GetLongFieldAsPtr(env, xgc, x11GraphicsConfigIDs.aData);
 383     DASSERT(adata != NULL);
 384 
 385     XWarpPointer(awt_display, None, XRootWindow(awt_display, adata->awt_visInfo.screen), 0, 0, 0, 0, root_x, root_y);
 386     XSync(awt_display, False);
 387 
 388     AWT_UNLOCK();
 389 }
 390 
 391 /*
 392   * Function joining the code of mousePressImpl and mouseReleaseImpl
 393   */
 394 void mouseAction(JNIEnv *env,
 395                  jclass cls,
 396                  jint buttonMask,
 397                  Bool isMousePress)
 398 {
 399     AWT_LOCK();
 400 
 401     DTRACE_PRINTLN1("RobotPeer: mouseAction(%i)", buttonMask);
 402     DTRACE_PRINTLN1("RobotPeer: mouseAction, press = %d", isMousePress);
 403 
 404     if (buttonMask & java_awt_event_InputEvent_BUTTON1_MASK ||
 405         buttonMask & java_awt_event_InputEvent_BUTTON1_DOWN_MASK )
 406     {
 407         XTestFakeButtonEvent(awt_display, 1, isMousePress, CurrentTime);
 408     }
 409     if ((buttonMask & java_awt_event_InputEvent_BUTTON2_MASK ||
 410          buttonMask & java_awt_event_InputEvent_BUTTON2_DOWN_MASK) &&
 411         (num_buttons >= 2)) {
 412         XTestFakeButtonEvent(awt_display, 2, isMousePress, CurrentTime);
 413     }
 414     if ((buttonMask & java_awt_event_InputEvent_BUTTON3_MASK ||
 415          buttonMask & java_awt_event_InputEvent_BUTTON3_DOWN_MASK) &&
 416         (num_buttons >= 3)) {
 417         XTestFakeButtonEvent(awt_display, 3, isMousePress, CurrentTime);
 418     }
 419 
 420     if (num_buttons > 3){
 421         int32_t i;
 422         int32_t button = 0;
 423         for (i = 3; i<num_buttons; i++){
 424             if ((buttonMask & masks[i])) {
 425                 // arrays starts from zero index => +1
 426                 // users wants to affect 4 or 5 button but they are assigned
 427                 // to the wheel so => we have to shift it to the right by 2.
 428                 button = i + 3;
 429                 XTestFakeButtonEvent(awt_display, button, isMousePress, CurrentTime);
 430             }
 431         }
 432     }
 433 
 434     XSync(awt_display, False);
 435     AWT_UNLOCK();
 436 }
 437 
 438 JNIEXPORT void JNICALL
 439 Java_sun_awt_X11_XRobotPeer_mousePressImpl (JNIEnv *env,
 440                            jclass cls,
 441                            jint buttonMask) {
 442     mouseAction(env, cls, buttonMask, True);
 443 }
 444 
 445 JNIEXPORT void JNICALL
 446 Java_sun_awt_X11_XRobotPeer_mouseReleaseImpl (JNIEnv *env,
 447                              jclass cls,
 448                              jint buttonMask) {
 449     mouseAction(env, cls, buttonMask, False);
 450 }
 451 
 452 JNIEXPORT void JNICALL
 453 Java_sun_awt_X11_XRobotPeer_mouseWheelImpl (JNIEnv *env,
 454                            jclass cls,
 455                            jint wheelAmt) {
 456 /* Mouse wheel is implemented as a button press of button 4 and 5, so it */
 457 /* probably could have been hacked into robot_mouseButtonEvent, but it's */
 458 /* cleaner to give it its own command type, in case the implementation   */
 459 /* needs to be changed later.  -bchristi, 6/20/01                        */
 460 
 461     int32_t repeat = abs(wheelAmt);
 462     int32_t button = wheelAmt < 0 ? 4 : 5;  /* wheel up:   button 4 */
 463                                                  /* wheel down: button 5 */
 464     int32_t loopIdx;
 465 
 466     AWT_LOCK();
 467 
 468     DTRACE_PRINTLN1("RobotPeer: mouseWheelImpl(%i)", wheelAmt);
 469 
 470     for (loopIdx = 0; loopIdx < repeat; loopIdx++) { /* do nothing for   */
 471                                                      /* wheelAmt == 0    */
 472         XTestFakeButtonEvent(awt_display, button, True, CurrentTime);
 473         XTestFakeButtonEvent(awt_display, button, False, CurrentTime);
 474     }
 475     XSync(awt_display, False);
 476 
 477     AWT_UNLOCK();
 478 }