1 /*
   2  * Copyright (c) 1998, 2014, 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 #include "awt.h"
  27 #include "awt_Toolkit.h"
  28 #include "awt_Component.h"
  29 #include "awt_Robot.h"
  30 #include "sun_awt_windows_WRobotPeer.h"
  31 #include "java_awt_event_InputEvent.h"
  32 #include <winuser.h>
  33 
  34 AwtRobot::AwtRobot( jobject peer )
  35 {
  36     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
  37     m_peerObject = env->NewWeakGlobalRef(peer);
  38     JNU_CHECK_EXCEPTION(env);
  39     JNI_SET_PDATA(peer, this);
  40 }
  41 
  42 AwtRobot::~AwtRobot()
  43 {
  44 }
  45 
  46 #ifndef SPI_GETMOUSESPEED
  47 #define SPI_GETMOUSESPEED 112
  48 #endif
  49 
  50 #ifndef SPI_SETMOUSESPEED
  51 #define SPI_SETMOUSESPEED 113
  52 #endif
  53 
  54 void AwtRobot::MouseMove( jint x, jint y)
  55 {
  56     // Fix for Bug 4288230. See Q193003 from MSDN.
  57       int oldAccel[3], newAccel[3];
  58       INT_PTR oldSpeed, newSpeed;
  59       BOOL bResult;
  60 
  61    // The following values set mouse ballistics to 1 mickey/pixel.
  62       newAccel[0] = 0;
  63       newAccel[1] = 0;
  64       newAccel[2] = 0;
  65       newSpeed = 10;
  66 
  67       // Save the Current Mouse Acceleration Constants
  68       bResult = SystemParametersInfo(SPI_GETMOUSE,0,oldAccel,0);
  69       bResult = SystemParametersInfo(SPI_GETMOUSESPEED, 0, &oldSpeed,0);
  70       // Set the new Mouse Acceleration Constants (Disabled).
  71       bResult = SystemParametersInfo(SPI_SETMOUSE,0,newAccel,SPIF_SENDCHANGE);
  72       bResult = SystemParametersInfo(SPI_SETMOUSESPEED, 0,
  73                 // 4504963: Though the third argument to SystemParameterInfo is
  74                 // declared as a PVOID, as of Windows 2000 it is apparently
  75                 // interpreted as an int.  (The MSDN docs for SPI_SETMOUSESPEED
  76                 // say that it's an integer between 1 and 20, the default being
  77                 // 10).  Instead of passing the @ of the desired value, the
  78                 // value itself is now passed, cast as a PVOID so as to
  79                 // compile.  -bchristi 10/02/2001
  80                                      (PVOID)newSpeed,
  81                                      SPIF_SENDCHANGE);
  82 
  83       int primaryIndex = AwtWin32GraphicsDevice::GetDefaultDeviceIndex();
  84       Devices::InstanceAccess devices;
  85       AwtWin32GraphicsDevice *device = devices->GetDevice(primaryIndex);
  86 
  87       x = (device == NULL) ? x : device->ScaleUpX(x);
  88       y = (device == NULL) ? y : device->ScaleUpY(y);
  89 
  90       POINT curPos;
  91       ::GetCursorPos(&curPos);
  92       x -= curPos.x;
  93       y -= curPos.y;
  94 
  95       mouse_event(MOUSEEVENTF_MOVE,x,y,0,0);
  96       // Move the cursor to the desired coordinates.
  97 
  98       // Restore the old Mouse Acceleration Constants.
  99       bResult = SystemParametersInfo(SPI_SETMOUSE,0, oldAccel, SPIF_SENDCHANGE);
 100       bResult = SystemParametersInfo(SPI_SETMOUSESPEED, 0, (PVOID)oldSpeed,
 101                                      SPIF_SENDCHANGE);
 102 }
 103 
 104 void AwtRobot::MousePress( jint buttonMask )
 105 {
 106     DWORD dwFlags = 0L;
 107     // According to MSDN: Software Driving Software
 108     // application should consider SM_SWAPBUTTON to correctly emulate user with
 109     // left handed mouse setup
 110     BOOL bSwap = ::GetSystemMetrics(SM_SWAPBUTTON);
 111 
 112     if ( buttonMask & java_awt_event_InputEvent_BUTTON1_MASK ||
 113         buttonMask & java_awt_event_InputEvent_BUTTON1_DOWN_MASK)
 114     {
 115         dwFlags |= !bSwap ? MOUSEEVENTF_LEFTDOWN : MOUSEEVENTF_RIGHTDOWN;
 116     }
 117 
 118     if ( buttonMask & java_awt_event_InputEvent_BUTTON3_MASK ||
 119          buttonMask & java_awt_event_InputEvent_BUTTON3_DOWN_MASK)
 120     {
 121         dwFlags |= !bSwap ? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_LEFTDOWN;
 122     }
 123 
 124     if ( buttonMask & java_awt_event_InputEvent_BUTTON2_MASK ||
 125          buttonMask & java_awt_event_InputEvent_BUTTON2_DOWN_MASK)
 126     {
 127         dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
 128     }
 129 
 130     INPUT mouseInput = {0};
 131     mouseInput.type = INPUT_MOUSE;
 132     mouseInput.mi.time = 0;
 133     mouseInput.mi.dwFlags = dwFlags;
 134     if ( buttonMask & AwtComponent::masks[3] ) {
 135         mouseInput.mi.dwFlags = mouseInput.mi.dwFlags | MOUSEEVENTF_XDOWN;
 136         mouseInput.mi.mouseData = XBUTTON1;
 137     }
 138 
 139     if ( buttonMask & AwtComponent::masks[4] ) {
 140         mouseInput.mi.dwFlags = mouseInput.mi.dwFlags | MOUSEEVENTF_XDOWN;
 141         mouseInput.mi.mouseData = XBUTTON2;
 142     }
 143     ::SendInput(1, &mouseInput, sizeof(mouseInput));
 144 }
 145 
 146 void AwtRobot::MouseRelease( jint buttonMask )
 147 {
 148     DWORD dwFlags = 0L;
 149     // According to MSDN: Software Driving Software
 150     // application should consider SM_SWAPBUTTON to correctly emulate user with
 151     // left handed mouse setup
 152     BOOL bSwap = ::GetSystemMetrics(SM_SWAPBUTTON);
 153 
 154     if ( buttonMask & java_awt_event_InputEvent_BUTTON1_MASK ||
 155         buttonMask & java_awt_event_InputEvent_BUTTON1_DOWN_MASK)
 156     {
 157         dwFlags |= !bSwap ? MOUSEEVENTF_LEFTUP : MOUSEEVENTF_RIGHTUP;
 158     }
 159 
 160     if ( buttonMask & java_awt_event_InputEvent_BUTTON3_MASK ||
 161          buttonMask & java_awt_event_InputEvent_BUTTON3_DOWN_MASK)
 162     {
 163         dwFlags |= !bSwap ? MOUSEEVENTF_RIGHTUP : MOUSEEVENTF_LEFTUP;
 164     }
 165 
 166     if ( buttonMask & java_awt_event_InputEvent_BUTTON2_MASK ||
 167         buttonMask & java_awt_event_InputEvent_BUTTON2_DOWN_MASK)
 168     {
 169         dwFlags |= MOUSEEVENTF_MIDDLEUP;
 170     }
 171 
 172     INPUT mouseInput = {0};
 173     mouseInput.type = INPUT_MOUSE;
 174     mouseInput.mi.time = 0;
 175     mouseInput.mi.dwFlags = dwFlags;
 176 
 177     if ( buttonMask & AwtComponent::masks[3] ) {
 178         mouseInput.mi.dwFlags = mouseInput.mi.dwFlags | MOUSEEVENTF_XUP;
 179         mouseInput.mi.mouseData = XBUTTON1;
 180     }
 181 
 182     if ( buttonMask & AwtComponent::masks[4] ) {
 183         mouseInput.mi.dwFlags = mouseInput.mi.dwFlags | MOUSEEVENTF_XUP;
 184         mouseInput.mi.mouseData = XBUTTON2;
 185     }
 186     ::SendInput(1, &mouseInput, sizeof(mouseInput));
 187 }
 188 
 189 void AwtRobot::MouseWheel (jint wheelAmt) {
 190     mouse_event(MOUSEEVENTF_WHEEL, 0, 0, wheelAmt * -1 * WHEEL_DELTA, 0);
 191 }
 192 
 193 inline jint AwtRobot::WinToJavaPixel(USHORT r, USHORT g, USHORT b)
 194 {
 195     jint value =
 196             0xFF << 24 | // alpha channel is always turned all the way up
 197             r << 16 |
 198             g << 8  |
 199             b << 0;
 200     return value;
 201 }
 202 
 203 void AwtRobot::GetRGBPixels(jint x, jint y, jint width, jint height, jintArray pixelArray)
 204 {
 205     DASSERT(width > 0 && height > 0);
 206 
 207     HDC hdcScreen = ::CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);
 208     HDC hdcMem = ::CreateCompatibleDC(hdcScreen);
 209     HBITMAP hbitmap;
 210     HBITMAP hOldBitmap;
 211     HPALETTE hOldPalette = NULL;
 212     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 213 
 214     // create an offscreen bitmap
 215     hbitmap = ::CreateCompatibleBitmap(hdcScreen, width, height);
 216     if (hbitmap == NULL) {
 217         throw std::bad_alloc();
 218     }
 219     hOldBitmap = (HBITMAP)::SelectObject(hdcMem, hbitmap);
 220 
 221     // REMIND: not multimon-friendly...
 222     int primaryIndex = AwtWin32GraphicsDevice::GetDefaultDeviceIndex();
 223     hOldPalette =
 224         AwtWin32GraphicsDevice::SelectPalette(hdcMem, primaryIndex);
 225     AwtWin32GraphicsDevice::RealizePalette(hdcMem, primaryIndex);
 226 
 227     Devices::InstanceAccess devices;
 228     AwtWin32GraphicsDevice *device = devices->GetDevice(primaryIndex);
 229     int sWidth = (device == NULL) ? width : device->ScaleUpX(width);
 230     int sHeight = (device == NULL) ? height : device->ScaleUpY(height);
 231 
 232     // copy screen image to offscreen bitmap
 233     // CAPTUREBLT flag is required to capture WS_EX_LAYERED windows' contents
 234     // correctly on Win2K/XP
 235     if (width == sWidth && height == sHeight) {
 236         VERIFY(::BitBlt(hdcMem, 0, 0, width, height, hdcScreen, x, y,
 237                SRCCOPY | CAPTUREBLT) != 0);
 238     } else {
 239         int sX = (device == NULL) ? x : device->ScaleUpX(x);
 240         int sY = (device == NULL) ? y : device->ScaleUpY(y);
 241         VERIFY(::StretchBlt(hdcMem, 0, 0, width, height,
 242                hdcScreen, sX, sY, sWidth, sHeight,
 243                SRCCOPY | CAPTUREBLT) != 0);
 244     }
 245 
 246     static const int BITS_PER_PIXEL = 32;
 247     static const int BYTES_PER_PIXEL = BITS_PER_PIXEL/8;
 248 
 249     if (!IS_SAFE_SIZE_MUL(width, height)) throw std::bad_alloc();
 250     int numPixels = width*height;
 251     if (!IS_SAFE_SIZE_MUL(BYTES_PER_PIXEL, numPixels)) throw std::bad_alloc();
 252     int pixelDataSize = BYTES_PER_PIXEL*numPixels;
 253     DASSERT(pixelDataSize > 0 && pixelDataSize % 4 == 0);
 254     // allocate memory for BITMAPINFO + pixel data
 255     // 4620932: When using BI_BITFIELDS, GetDIBits expects an array of 3
 256     // RGBQUADS to follow the BITMAPINFOHEADER, but we were only allocating the
 257     // 1 that is included in BITMAPINFO.  Thus, GetDIBits was writing off the
 258     // end of our block of memory.  Now we allocate sufficient memory.
 259     // See MSDN docs for BITMAPINFOHEADER -bchristi
 260 
 261     if (!IS_SAFE_SIZE_ADD(sizeof(BITMAPINFOHEADER) + 3 * sizeof(RGBQUAD), pixelDataSize)) {
 262         throw std::bad_alloc();
 263     }
 264     BITMAPINFO * pinfo = (BITMAPINFO *)(new BYTE[sizeof(BITMAPINFOHEADER) + 3 * sizeof(RGBQUAD) + pixelDataSize]);
 265 
 266     // pixel data starts after 3 RGBQUADS for color masks
 267     RGBQUAD *pixelData = &pinfo->bmiColors[3];
 268 
 269     // prepare BITMAPINFO for a 32-bit RGB bitmap
 270     ::memset(pinfo, 0, sizeof(*pinfo));
 271     pinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 272     pinfo->bmiHeader.biWidth = width;
 273     pinfo->bmiHeader.biHeight = -height; // negative height means a top-down DIB
 274     pinfo->bmiHeader.biPlanes = 1;
 275     pinfo->bmiHeader.biBitCount = BITS_PER_PIXEL;
 276     pinfo->bmiHeader.biCompression = BI_BITFIELDS;
 277 
 278     // Setup up color masks
 279     static const RGBQUAD redMask =   {0, 0, 0xFF, 0};
 280     static const RGBQUAD greenMask = {0, 0xFF, 0, 0};
 281     static const RGBQUAD blueMask =  {0xFF, 0, 0, 0};
 282 
 283     pinfo->bmiColors[0] = redMask;
 284     pinfo->bmiColors[1] = greenMask;
 285     pinfo->bmiColors[2] = blueMask;
 286 
 287     // Get the bitmap data in device-independent, 32-bit packed pixel format
 288     ::GetDIBits(hdcMem, hbitmap, 0, height, pixelData, pinfo, DIB_RGB_COLORS);
 289 
 290     // convert Win32 pixel format (BGRX) to Java format (ARGB)
 291     DASSERT(sizeof(jint) == sizeof(RGBQUAD));
 292     for(int nPixel = 0; nPixel < numPixels; nPixel++) {
 293         RGBQUAD * prgbq = &pixelData[nPixel];
 294         jint jpixel = WinToJavaPixel(prgbq->rgbRed, prgbq->rgbGreen, prgbq->rgbBlue);
 295         // stuff the 32-bit pixel back into the 32-bit RGBQUAD
 296         *prgbq = *( (RGBQUAD *)(&jpixel) );
 297     }
 298 
 299     // copy pixels into Java array
 300     env->SetIntArrayRegion(pixelArray, 0, numPixels, (jint *)pixelData);
 301     delete pinfo;
 302 
 303     // free all the GDI objects we made
 304     ::SelectObject(hdcMem, hOldBitmap);
 305     if (hOldPalette != NULL) {
 306         ::SelectPalette(hdcMem, hOldPalette, FALSE);
 307     }
 308     ::DeleteObject(hbitmap);
 309     ::DeleteDC(hdcMem);
 310     ::DeleteDC(hdcScreen);
 311 }
 312 
 313 void AwtRobot::KeyPress( jint jkey )
 314 {
 315     DoKeyEvent(jkey, 0); // no flags means key down
 316 }
 317 
 318 void AwtRobot::KeyRelease( jint jkey )
 319 {
 320     DoKeyEvent(jkey, KEYEVENTF_KEYUP);
 321 }
 322 
 323 void AwtRobot::DoKeyEvent( jint jkey, DWORD dwFlags )
 324 {
 325     UINT        vkey;
 326     UINT        modifiers;
 327     UINT        scancode;
 328     JNIEnv *    env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 329 
 330     // convert Java key into Windows key (and modifiers too)
 331     AwtComponent::JavaKeyToWindowsKey(jkey, &vkey, &modifiers);
 332     if (vkey == 0) {
 333         // no equivalent Windows key found for given Java keycode
 334         JNU_ThrowIllegalArgumentException(env, "Invalid key code");
 335     } else {
 336         // get the scancode from the virtual key
 337         scancode = ::MapVirtualKey(vkey, 0);
 338         if (vkey == VK_RMENU ||
 339             vkey == VK_DELETE ||
 340             vkey == VK_INSERT ||
 341             vkey == VK_NEXT ||
 342             vkey == VK_PRIOR ||
 343             vkey == VK_HOME ||
 344             vkey == VK_END ||
 345             vkey == VK_LEFT ||
 346             vkey == VK_RIGHT ||
 347             vkey == VK_UP ||
 348             vkey == VK_DOWN) {
 349             dwFlags |= KEYEVENTF_EXTENDEDKEY;
 350         }
 351         keybd_event(vkey, scancode, dwFlags, 0);
 352     }
 353 }
 354 
 355 //
 356 // utility function to get the C++ object from the Java one
 357 //
 358 // (static)
 359 AwtRobot * AwtRobot::GetRobot( jobject self )
 360 {
 361     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 362     AwtRobot * robot = (AwtRobot *)JNI_GET_PDATA(self);
 363     DASSERT( !::IsBadWritePtr( robot, sizeof(AwtRobot)));
 364     return robot;
 365 }
 366 
 367 //////////////////////////////////////////////////////////////////////////////////////////////
 368 // Native method declarations
 369 //
 370 
 371 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_create(
 372     JNIEnv * env, jobject self)
 373 {
 374     TRY;
 375 
 376     new AwtRobot(self);
 377 
 378     CATCH_BAD_ALLOC;
 379 }
 380 
 381 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer__1dispose(
 382     JNIEnv *env, jobject self)
 383 {
 384     TRY_NO_VERIFY;
 385 
 386     AwtObject::_Dispose(self);
 387 
 388     CATCH_BAD_ALLOC;
 389 }
 390 
 391 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_mouseMoveImpl(
 392     JNIEnv * env, jobject self, jint x, jint y)
 393 {
 394     TRY;
 395 
 396     AwtRobot::GetRobot(self)->MouseMove(x, y);
 397 
 398     CATCH_BAD_ALLOC;
 399 }
 400 
 401 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_mousePress(
 402     JNIEnv * env, jobject self, jint buttons)
 403 {
 404     TRY;
 405 
 406     AwtRobot::GetRobot(self)->MousePress(buttons);
 407 
 408     CATCH_BAD_ALLOC;
 409 }
 410 
 411 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_mouseRelease(
 412     JNIEnv * env, jobject self, jint buttons)
 413 {
 414     TRY;
 415 
 416     AwtRobot::GetRobot(self)->MouseRelease(buttons);
 417 
 418     CATCH_BAD_ALLOC;
 419 }
 420 
 421 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_mouseWheel(
 422     JNIEnv * env, jobject self, jint wheelAmt)
 423 {
 424     TRY;
 425 
 426     AwtRobot::GetRobot(self)->MouseWheel(wheelAmt);
 427 
 428     CATCH_BAD_ALLOC;
 429 }
 430 
 431 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_getRGBPixels(
 432     JNIEnv *env, jobject self, jint x, jint y, jint width, jint height, jintArray pixelArray)
 433 {
 434     TRY;
 435 
 436     AwtRobot::GetRobot(self)->GetRGBPixels(x, y, width, height, pixelArray);
 437 
 438     CATCH_BAD_ALLOC;
 439 }
 440 
 441 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_keyPress(
 442   JNIEnv *, jobject self, jint javakey )
 443 {
 444     TRY;
 445 
 446     AwtRobot::GetRobot(self)->KeyPress(javakey);
 447 
 448     CATCH_BAD_ALLOC;
 449 }
 450 
 451 JNIEXPORT void JNICALL Java_sun_awt_windows_WRobotPeer_keyRelease(
 452   JNIEnv *, jobject self, jint javakey )
 453 {
 454     TRY;
 455 
 456     AwtRobot::GetRobot(self)->KeyRelease(javakey);
 457 
 458     CATCH_BAD_ALLOC;
 459 }