rev 60071 : 8211999: Window positioning bugs due to overlapping GraphicsDevice bounds (Windows/HiDPI)
Reviewed-by: XXX

   1 /*
   2  * Copyright (c) 1999, 2020, 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 
  27 
  28 /**
  29  * This class holds the information for a particular graphics device.
  30  * Since a display change can cause the creation of new devices
  31  * at any time, there is no referencing of the devices array allowed.
  32  * Instead, anyone wishing to reference a device in the array (e.g.,
  33  * the current default device or a device for a given hWnd) must
  34  * call one of the static methods of this class with the index of
  35  * the device in question.  Those methods will then lock the devices
  36  * array and forward the request to the current device at that
  37  * array index.
  38  */
  39 
  40 #include <awt.h>
  41 #include <sun_awt_Win32GraphicsDevice.h>
  42 #include "awt_Canvas.h"
  43 #include "awt_Win32GraphicsDevice.h"
  44 #include "awt_Window.h"
  45 #include "java_awt_Transparency.h"
  46 #include "java_awt_color_ColorSpace.h"
  47 #include "sun_awt_Win32GraphicsDevice.h"
  48 #include "java_awt_image_DataBuffer.h"
  49 #include "dither.h"
  50 #include "img_util_md.h"
  51 #include "Devices.h"
  52 #include "systemScale.h"
  53 
  54 uns_ordered_dither_array img_oda_alpha;
  55 
  56 jclass      AwtWin32GraphicsDevice::indexCMClass;
  57 jclass      AwtWin32GraphicsDevice::wToolkitClass;
  58 jfieldID    AwtWin32GraphicsDevice::dynamicColorModelID;
  59 jfieldID    AwtWin32GraphicsDevice::indexCMrgbID;
  60 jfieldID    AwtWin32GraphicsDevice::indexCMcacheID;
  61 jmethodID   AwtWin32GraphicsDevice::paletteChangedMID;
  62 BOOL        AwtWin32GraphicsDevice::primaryPalettized;
  63 int         AwtWin32GraphicsDevice::primaryIndex = 0;
  64 
  65 
  66 /**
  67  * Construct this device.  Store the screen (index into the devices
  68  * array of this object), the array (used in static references via
  69  * particular device indices), the monitor/pMonitorInfo (which other
  70  * classes will inquire of this device), the bits per pixel of this
  71  * device, and information on whether the primary device is palettized.
  72  */
  73 AwtWin32GraphicsDevice::AwtWin32GraphicsDevice(int screen,
  74                                                HMONITOR mhnd, Devices *arr)
  75 {
  76     this->screen  = screen;
  77     this->devicesArray = arr;
  78     this->scaleX = 1;
  79     this->scaleY = 1;

  80     javaDevice = NULL;
  81     colorData = new ImgColorData;
  82     colorData->grayscale = GS_NOTGRAY;
  83     palette = NULL;
  84     cData = NULL;
  85     gpBitmapInfo = NULL;
  86     monitor = mhnd;
  87     pMonitorInfo = new MONITORINFOEX;
  88     pMonitorInfo->cbSize = sizeof(MONITORINFOEX);
  89     ::GetMonitorInfo(monitor, pMonitorInfo);
  90 
  91     // Set primary device info: other devices will need to know
  92     // whether the primary is palettized during the initialization
  93     // process
  94     HDC hDC = this->GetDC();
  95     colorData->bitsperpixel = ::GetDeviceCaps(hDC, BITSPIXEL);
  96     this->ReleaseDC(hDC);
  97     if (MONITORINFOF_PRIMARY & pMonitorInfo->dwFlags) {
  98         primaryIndex = screen;
  99         if (colorData->bitsperpixel > 8) {
 100             primaryPalettized = FALSE;
 101         } else {
 102             primaryPalettized = TRUE;
 103         }
 104     }
 105 }
 106 
 107 AwtWin32GraphicsDevice::~AwtWin32GraphicsDevice()
 108 {
 109     delete colorData;
 110     if (gpBitmapInfo) {
 111         free(gpBitmapInfo);
 112     }
 113     if (palette) {
 114         delete palette;
 115     }
 116     if (pMonitorInfo) {
 117         delete pMonitorInfo;
 118     }
 119     if (javaDevice) {
 120         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 121         env->DeleteWeakGlobalRef(javaDevice);
 122     }
 123     if (cData != NULL) {
 124         freeICMColorData(cData);
 125     }
 126 }
 127 
 128 HDC AwtWin32GraphicsDevice::MakeDCFromMonitor(HMONITOR hmMonitor) {
 129     HDC retCode = NULL;
 130     if (NULL != hmMonitor) {
 131         MONITORINFOEX mieInfo;
 132 
 133         memset((void*)(&mieInfo), 0, sizeof(MONITORINFOEX));
 134         mieInfo.cbSize = sizeof(MONITORINFOEX);
 135 
 136         if (TRUE == ::GetMonitorInfo(hmMonitor, (LPMONITORINFOEX)(&mieInfo))) {
 137             HDC hDC = CreateDC(mieInfo.szDevice, NULL, NULL, NULL);
 138             if (NULL != hDC) {
 139                 retCode = hDC;
 140             }
 141         }
 142     }
 143     return retCode;
 144 }
 145 
 146 HDC AwtWin32GraphicsDevice::GetDC()
 147 {
 148     return MakeDCFromMonitor(monitor);
 149 }
 150 
 151 void AwtWin32GraphicsDevice::ReleaseDC(HDC hDC)
 152 {
 153     if (hDC != NULL) {
 154         ::DeleteDC(hDC);
 155     }
 156 }
 157 
 158 /**
 159  * Init this device.  This creates the bitmap structure
 160  * used to hold the device color data and initializes any
 161  * appropriate palette structures.
 162  */
 163 void AwtWin32GraphicsDevice::Initialize()
 164 {
 165     unsigned int ri, gi, bi;
 166     if (colorData->bitsperpixel < 8) {
 167         // REMIND: how to handle?
 168     }
 169 
 170     // Create a BitmapInfo object for color data
 171     if (!gpBitmapInfo) {
 172         try {
 173             gpBitmapInfo = (BITMAPINFO *)
 174                 safe_Malloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
 175         } catch (std::bad_alloc&) {
 176             throw;
 177         }
 178         gpBitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 179     }
 180     gpBitmapInfo->bmiHeader.biBitCount = 0;
 181     HDC hBMDC = this->GetDC();
 182     HBITMAP hBM = ::CreateCompatibleBitmap(hBMDC, 1, 1);
 183     VERIFY(::GetDIBits(hBMDC, hBM, 0, 1, NULL, gpBitmapInfo, DIB_RGB_COLORS));
 184 
 185     if (colorData->bitsperpixel > 8) {
 186         if (MONITORINFOF_PRIMARY & pMonitorInfo->dwFlags) {
 187             primaryPalettized = FALSE;
 188         }
 189         if (colorData->bitsperpixel != 24) { // 15, 16, or 32 bpp
 190             int foo;
 191             gpBitmapInfo->bmiHeader.biCompression = BI_BITFIELDS;
 192             if (::GetDIBits(hBMDC, hBM, 0, 1, &foo, gpBitmapInfo,
 193                             DIB_RGB_COLORS) == 0)
 194             {
 195                 // Bug 4684966: If GetDIBits returns an error, we could
 196                 // get stuck in an infinite loop setting the colorData
 197                 // fields.  Hardcode bitColors to reasonable values instead.
 198                 // These values are picked according to standard masks
 199                 // for these bit depths on win9x, according to MSDN docs.
 200                 switch (colorData->bitsperpixel) {
 201                 case 15:
 202                     ((int *)gpBitmapInfo->bmiColors)[0] = 0x7c00;
 203                     ((int *)gpBitmapInfo->bmiColors)[1] = 0x03e0;
 204                     ((int *)gpBitmapInfo->bmiColors)[2] = 0x001f;
 205                     break;
 206                 case 16:
 207                     ((int *)gpBitmapInfo->bmiColors)[0] = 0xf800;
 208                     ((int *)gpBitmapInfo->bmiColors)[1] = 0x07e0;
 209                     ((int *)gpBitmapInfo->bmiColors)[2] = 0x001f;
 210                     break;
 211                 case 32:
 212                 default:
 213                     ((int *)gpBitmapInfo->bmiColors)[0] = 0xff0000;
 214                     ((int *)gpBitmapInfo->bmiColors)[1] = 0x00ff00;
 215                     ((int *)gpBitmapInfo->bmiColors)[2] = 0x0000ff;
 216                     break;
 217                 }
 218             }
 219             ri = ((unsigned int *)gpBitmapInfo->bmiColors)[0];
 220             colorData->rOff = 0;
 221             while ((ri & 1) == 0) {
 222                 colorData->rOff++;
 223                 ri >>= 1;
 224             }
 225             colorData->rScale = 0;
 226             while (ri < 0x80) {
 227                 colorData->rScale++;
 228                 ri <<= 1;
 229             }
 230             gi = ((unsigned int *)gpBitmapInfo->bmiColors)[1];
 231             colorData->gOff = 0;
 232             while ((gi & 1) == 0) {
 233                 colorData->gOff++;
 234                 gi >>= 1;
 235             }
 236             colorData->gScale = 0;
 237             while (gi < 0x80) {
 238                 colorData->gScale++;
 239                 gi <<= 1;
 240             }
 241             bi = ((unsigned int *)gpBitmapInfo->bmiColors)[2];
 242             colorData->bOff = 0;
 243             while ((bi & 1) == 0) {
 244                 colorData->bOff++;
 245                 bi >>= 1;
 246             }
 247             colorData->bScale = 0;
 248             while (bi < 0x80) {
 249                 colorData->bScale++;
 250                 bi <<= 1;
 251             }
 252             if (   (0 == colorData->bOff)
 253                 && (5 == colorData->gOff)
 254                 && (10 == colorData->rOff)
 255                 && (3 == colorData->bScale)
 256                 && (3 == colorData->gScale)
 257                 && (3 == colorData->rScale)) {
 258                 colorData->bitsperpixel = 15;
 259                 gpBitmapInfo->bmiHeader.biCompression = BI_RGB;
 260             }
 261         } else {    // 24 bpp
 262             gpBitmapInfo->bmiHeader.biBitCount = 24;
 263             gpBitmapInfo->bmiHeader.biCompression = BI_RGB;
 264 
 265             // Fill these values in as a convenience for the screen
 266             // ColorModel construction code below (see getColorModel())
 267             ((int *)gpBitmapInfo->bmiColors)[0] = 0x0000ff;
 268             ((int *)gpBitmapInfo->bmiColors)[1] = 0x00ff00;
 269             ((int *)gpBitmapInfo->bmiColors)[2] = 0xff0000;
 270         }
 271     } else {
 272         if (MONITORINFOF_PRIMARY & pMonitorInfo->dwFlags) {
 273             primaryPalettized = TRUE;
 274         }
 275         gpBitmapInfo->bmiHeader.biBitCount = 8;
 276         gpBitmapInfo->bmiHeader.biCompression = BI_RGB;
 277         gpBitmapInfo->bmiHeader.biClrUsed = 256;
 278         gpBitmapInfo->bmiHeader.biClrImportant = 256;
 279 
 280         // The initialization of cData is done prior to
 281         // calling palette->Update() since we need it
 282         // for calculating inverseGrayLut
 283         if (cData == NULL) {
 284             cData = (ColorData*)safe_Calloc(1, sizeof(ColorData));
 285             memset(cData, 0, sizeof(ColorData));
 286             initDitherTables(cData);
 287         }
 288 
 289         if (!palette) {
 290             palette = new AwtPalette(this);
 291         } else {
 292             palette->Update();
 293         }
 294         palette->UpdateLogical();
 295     }
 296     VERIFY(::DeleteObject(hBM));
 297     VERIFY(::DeleteDC(hBMDC));
 298 }
 299 
 300 /**
 301  * Creates a new colorModel given the current device configuration.
 302  * The dynamic flag determines whether we use the system palette
 303  * (dynamic == TRUE) or our custom palette in creating a new
 304  * IndexedColorModel.
 305  */
 306 jobject AwtWin32GraphicsDevice::GetColorModel(JNIEnv *env, jboolean dynamic)
 307 {
 308     jobject awt_colormodel;
 309     int i;
 310     if (colorData->bitsperpixel == 24) {
 311         awt_colormodel =
 312             JNU_NewObjectByName(env, "sun/awt/Win32ColorModel24", "()V");
 313     } else if (colorData->bitsperpixel > 8) {
 314         int *masks = (int *)gpBitmapInfo->bmiColors;
 315         int numbits = 0;
 316         unsigned int bits = (masks[0] | masks[1] | masks[2]);
 317         while (bits) {
 318             numbits++;
 319             bits >>= 1;
 320         }
 321         awt_colormodel = JNU_NewObjectByName(env,
 322                                              "java/awt/image/DirectColorModel",
 323                                              "(IIII)V", numbits,
 324                                              masks[0], masks[1], masks[2]);
 325     } else if (colorData->grayscale == GS_STATICGRAY) {
 326         jclass clazz;
 327         jclass clazz1;
 328         jmethodID mid;
 329         jobject cspace = NULL;
 330         jint bits[1];
 331         jintArray bitsArray;
 332 
 333         clazz1 = env->FindClass("java/awt/color/ColorSpace");
 334         CHECK_NULL_RETURN(clazz1, NULL);
 335         mid = env->GetStaticMethodID(clazz1, "getInstance",
 336               "(I)Ljava/awt/color/ColorSpace;");
 337         CHECK_NULL_RETURN(mid, NULL);
 338         cspace = env->CallStaticObjectMethod(clazz1, mid,
 339             java_awt_color_ColorSpace_CS_GRAY);
 340         CHECK_NULL_RETURN(cspace, NULL);
 341 
 342         bits[0] = 8;
 343         bitsArray = env->NewIntArray(1);
 344         if (bitsArray == 0) {
 345             return NULL;
 346         } else {
 347             env->SetIntArrayRegion(bitsArray, 0, 1, bits);
 348         }
 349 
 350         clazz = env->FindClass("java/awt/image/ComponentColorModel");
 351         CHECK_NULL_RETURN(clazz, NULL);
 352         mid = env->GetMethodID(clazz,"<init>",
 353             "(Ljava/awt/color/ColorSpace;[IZZII)V");
 354         CHECK_NULL_RETURN(mid, NULL);
 355 
 356         awt_colormodel = env->NewObject(clazz, mid,
 357                                         cspace,
 358                                         bitsArray,
 359                                         JNI_FALSE,
 360                                         JNI_FALSE,
 361                                         java_awt_Transparency_OPAQUE,
 362                                         java_awt_image_DataBuffer_TYPE_BYTE);
 363     } else {
 364         jintArray hRGB = env->NewIntArray(256);
 365         unsigned int *rgb = NULL, *rgbP = NULL;
 366         jboolean allvalid = JNI_TRUE;
 367         jbyte vbits[256/8];
 368         jobject validBits = NULL;
 369 
 370         CHECK_NULL_RETURN(hRGB, NULL);
 371         /* Create the LUT from the color map */
 372         try {
 373             rgb = (unsigned int *) env->GetPrimitiveArrayCritical(hRGB, 0);
 374             CHECK_NULL_RETURN(rgb, NULL);
 375             rgbP = rgb;
 376             if (!palette) {
 377                 palette = new AwtPalette(this);
 378                 palette->UpdateLogical();
 379             }
 380             if (colorData->grayscale == GS_INDEXGRAY) {
 381                 /* For IndexColorModel, pretend first 10 colors and last
 382                    10 colors are transparent black.  This makes
 383                    ICM.allgrayopaque true.
 384                 */
 385                 unsigned int *logicalEntries = palette->GetLogicalEntries();
 386 
 387                 for (i=0; i < 10; i++) {
 388                     rgbP[i] = 0x00000000;
 389                     rgbP[i+246] = 0x00000000;
 390                 }
 391                 memcpy(&rgbP[10], &logicalEntries[10], 236 * sizeof(RGBQUAD));
 392                 // We need to specify which entries in the colormap are
 393                 // valid so that the transparent black entries we have
 394                 // created do not affect the Transparency setting of the
 395                 // IndexColorModel.  The vbits array is used to construct
 396                 // a BigInteger such that the most significant bit of vbits[0]
 397                 // indicates the validity of the last color (#256) and the
 398                 // least significant bit of vbits[256/8] indicates the
 399                 // validity of the first color (#0).  We need to fill vbits
 400                 // with all 1's and then turn off the first and last 10 bits.
 401                 memset(vbits, 0xff, sizeof(vbits));
 402                 vbits[0] = 0;
 403                 vbits[1] = (jbyte) (0xff >> 2);
 404                 vbits[sizeof(vbits)-2] = (jbyte) (0xff << 2);
 405                 vbits[sizeof(vbits)-1] = 0;
 406                 allvalid = JNI_FALSE;
 407             } else {
 408                 if (!dynamic) {
 409                     // If we plan to use our custom palette (i.e., we are
 410                     // not running inside another app and we are not creating
 411                     // a dynamic colorModel object), then setup ICM with
 412                     // custom palette entries
 413                     unsigned int *logicalEntries = palette->GetLogicalEntries();
 414                     memcpy(rgbP, logicalEntries, 256 * sizeof(int));
 415                 } else {
 416                     // Else, use current system palette entries.
 417                     // REMIND: This may not give the result we want if
 418                     // we are running inside another app and that
 419                     // parent app is running in the background when we
 420                     // reach here.  We could at least cache an "ideal" set of
 421                     // system palette entries from the first time we are
 422                     // running in the foreground and then future ICM's will
 423                     // use that set instead.
 424                     unsigned int *systemEntries = palette->GetSystemEntries();
 425                     memcpy(rgbP, systemEntries, 256 * sizeof(int));
 426                 }
 427             }
 428         } catch (...) {
 429             env->ReleasePrimitiveArrayCritical(hRGB, rgb, 0);
 430             throw;
 431         }
 432 
 433         env->ReleasePrimitiveArrayCritical(hRGB, rgb, 0);
 434 
 435         // Construct a new color model
 436         if (!allvalid) {
 437             jbyteArray bArray = env->NewByteArray(sizeof(vbits));
 438             CHECK_NULL_RETURN(bArray, NULL);
 439             env->SetByteArrayRegion(bArray, 0, sizeof(vbits), vbits);
 440             validBits = JNU_NewObjectByName(env,
 441                                             "java/math/BigInteger",
 442                                             "([B)V", bArray);
 443             JNU_CHECK_EXCEPTION_RETURN(env, NULL);
 444         }
 445         awt_colormodel =
 446             JNU_NewObjectByName(env,
 447                                 "java/awt/image/IndexColorModel",
 448                                 "(II[IIILjava/math/BigInteger;)V",
 449                                 8, 256,
 450                                 hRGB, 0,
 451                                 java_awt_image_DataBuffer_TYPE_BYTE,
 452                                 validBits);
 453     }
 454     return awt_colormodel;
 455 }
 456 
 457 /**
 458  * Called from AwtPalette code when it is determined what grayscale
 459  * value (if any) the current logical palette has
 460  */
 461 void AwtWin32GraphicsDevice::SetGrayness(int grayValue)
 462 {
 463     colorData->grayscale = grayValue;
 464 }
 465 
 466 
 467 /**
 468  * Update our dynamic IndexedColorModel.  This happens after
 469  * a change to the system palette.  Any surfaces stored in vram
 470  * (Win32OffScreenSurfaceData and GDIWindowSurfaceData objects)
 471  * refer to this colorModel and use its lookup table and inverse
 472  * lookup to calculate correct index values for rgb colors.  So
 473  * the colorModel must always reflect the current state of the
 474  * system palette.
 475  */
 476 void AwtWin32GraphicsDevice::UpdateDynamicColorModel()
 477 {
 478     if (!javaDevice) {
 479         // javaDevice may not be set yet.  If not, return.  In
 480         // this situation, we probably don't need an update anyway
 481         // since the colorModel will be created with the correct
 482         // info when the java side is initialized.
 483         return;
 484     }
 485     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 486     jobject colorModel = env->GetObjectField(javaDevice,
 487         dynamicColorModelID);
 488     if (!colorModel) {
 489         return;
 490     }
 491     if (env->IsInstanceOf(colorModel, indexCMClass)) {
 492         // If colorModel not of type ICM then we're not in 8-bit mode and
 493         // don't need to update it
 494         jboolean isCopy;
 495         unsigned int *newEntries = palette->GetSystemEntries();
 496         jintArray rgbArray = (jintArray)env->GetObjectField(colorModel,
 497             AwtWin32GraphicsDevice::indexCMrgbID);
 498         jintArray cacheArray = (jintArray)env->GetObjectField(colorModel,
 499             AwtWin32GraphicsDevice::indexCMcacheID);
 500         if (!rgbArray || !cacheArray) {
 501             JNU_ThrowInternalError(env, "rgb or lookupcache array of IndexColorModel null");
 502             return;
 503         }
 504         int rgbLength = env->GetArrayLength(rgbArray);
 505         int cacheLength = env->GetArrayLength(cacheArray);
 506         jint *cmEntries = (jint *)env->GetPrimitiveArrayCritical(rgbArray, &isCopy);
 507         if (!cmEntries) {
 508             env->ExceptionClear();
 509             JNU_ThrowInternalError(env, "Problem retrieving rgb critical array");
 510             return;
 511         }
 512         jint *cache = (jint *)env->GetPrimitiveArrayCritical(cacheArray, &isCopy);
 513         if (!cache) {
 514             env->ExceptionClear();
 515             env->ReleasePrimitiveArrayCritical(rgbArray, cmEntries, JNI_ABORT);
 516             JNU_ThrowInternalError(env, "Problem retrieving cache critical array");
 517             return;
 518         }
 519         // Set the new rgb values
 520     int i;
 521     for (i = 0; i < rgbLength; ++i) {
 522             cmEntries[i] = newEntries[i];
 523         }
 524         // clear out the old cache
 525         for (i = 0; i < cacheLength; ++i) {
 526             cache[i] = 0;
 527         }
 528         env->ReleasePrimitiveArrayCritical(cacheArray, cache, 0);
 529         env->ReleasePrimitiveArrayCritical(rgbArray, cmEntries, 0);
 530 
 531         // Call WToolkit::paletteChanged() method; this will invalidate
 532         // the offscreen surfaces dependent on this dynamic colorModel
 533         // to ensure that they get redrawn with the correct color indices
 534         env->CallStaticVoidMethod(AwtWin32GraphicsDevice::wToolkitClass,
 535             paletteChangedMID);
 536     }
 537 }
 538 
 539 unsigned int *AwtWin32GraphicsDevice::GetSystemPaletteEntries()
 540 {
 541     // REMIND: What to do if palette NULL?  Need to throw
 542     // some kind of exception?
 543     return palette->GetSystemEntries();
 544 }
 545 
 546 unsigned char *AwtWin32GraphicsDevice::GetSystemInverseLUT()
 547 {
 548     // REMIND: What to do if palette NULL?  Need to throw
 549     // some kind of exception?
 550     return palette->GetSystemInverseLUT();
 551 }
 552 
 553 
 554 BOOL AwtWin32GraphicsDevice::UpdateSystemPalette()
 555 {
 556     if (colorData->bitsperpixel > 8) {
 557         return FALSE;
 558     } else {
 559         return palette->Update();
 560     }
 561 }
 562 
 563 HPALETTE AwtWin32GraphicsDevice::SelectPalette(HDC hDC)
 564 {
 565     if (palette) {
 566         return palette->Select(hDC);
 567     } else {
 568         return NULL;
 569     }
 570 }
 571 
 572 void AwtWin32GraphicsDevice::RealizePalette(HDC hDC)
 573 {
 574     if (palette) {
 575         palette->Realize(hDC);
 576     }
 577 }
 578 
 579 /**
 580  * Deterine which device the HWND exists on and return the
 581  * appropriate index into the devices array.
 582  */
 583 int AwtWin32GraphicsDevice::DeviceIndexForWindow(HWND hWnd)
 584 {
 585     HMONITOR mon = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
 586     int screen = AwtWin32GraphicsDevice::GetScreenFromHMONITOR(mon);
 587     return screen;
 588 }
 589 
 590 /**
 591  * Get the HPALETTE associated with this device
 592  */
 593 HPALETTE AwtWin32GraphicsDevice::GetPalette()
 594 {
 595     if (palette) {
 596         return palette->GetPalette();
 597     } else {
 598         return NULL;
 599     }
 600 }
 601 
 602 /**
 603  * Object referring to this device is releasing that reference.
 604  * This allows the array holding all devices to be released (once
 605  * all references to the array have gone away).
 606  */
 607 void AwtWin32GraphicsDevice::Release()
 608 {
 609     devicesArray->Release();
 610 }
 611 
 612 /**
 613  * Links this native object with its java Win32GraphicsDevice.
 614  * Need this link because the colorModel of the java device
 615  * may be updated from native code.
 616  */
 617 void AwtWin32GraphicsDevice::SetJavaDevice(JNIEnv *env, jobject objPtr)
 618 {
 619     javaDevice = env->NewWeakGlobalRef(objPtr);
 620 }
 621 
 622 /**
 623  * Sets horizontal and vertical scale factors
 624  */
 625 void AwtWin32GraphicsDevice::SetScale(float sx, float sy)
 626 {
 627     scaleX = sx;
 628     scaleY = sy;
 629 }
 630 
 631 int AwtWin32GraphicsDevice::ScaleUpX(int x)
 632 {
 633     return ClipRound(x * scaleX);
 634 }
 635 






 636 int AwtWin32GraphicsDevice::ScaleUpY(int y)
 637 {
 638     return ClipRound(y * scaleY);
 639 }
 640 






 641 int AwtWin32GraphicsDevice::ScaleDownX(int x)
 642 {
 643     return ClipRound(x / scaleX);
 644 }
 645 






 646 int AwtWin32GraphicsDevice::ScaleDownY(int y)
 647 {
 648     return ClipRound(y / scaleY);
 649 }
 650 






 651 int AwtWin32GraphicsDevice::ClipRound(double value)
 652 {
 653     value -= 0.5;
 654     if (value < INT_MIN)
 655     {
 656         return INT_MIN;
 657     }
 658 
 659     if (value > INT_MAX)
 660     {
 661         return INT_MAX;
 662     }
 663 
 664     return (int)ceil(value);
 665 }
 666 
 667 void AwtWin32GraphicsDevice::InitDesktopScales()
 668 {
 669     float dpiX = -1.0f;
 670     float dpiY = -1.0f;
 671     GetScreenDpi(GetMonitor(), &dpiX, &dpiY);
 672     if (dpiX > 0 && dpiY > 0) {
 673         SetScale(dpiX / 96, dpiY / 96);
 674     }

 675 }
 676 
 677 float AwtWin32GraphicsDevice::GetScaleX()
 678 {
 679     return scaleX;
 680 }
 681 
 682 float AwtWin32GraphicsDevice::GetScaleY()
 683 {
 684     return scaleY;
 685 }
 686 
 687 /**
 688  * Disables offscreen acceleration for this device.  This
 689  * sets a flag in the java object that is used to determine
 690  * whether offscreen surfaces can be created on the device.
 691  */
 692 void AwtWin32GraphicsDevice::DisableOffscreenAcceleration()
 693 {
 694     // REMIND: noop for now
 695 }
 696 





 697 /**
 698  * Invalidates the GraphicsDevice object associated with this
 699  * device by disabling offscreen acceleration and calling
 700  * invalidate(defIndex) on the java object.
 701  */
 702 void AwtWin32GraphicsDevice::Invalidate(JNIEnv *env)
 703 {
 704     int defIndex = AwtWin32GraphicsDevice::GetDefaultDeviceIndex();
 705     DisableOffscreenAcceleration();
 706     jobject javaDevice = GetJavaDevice();
 707     if (!JNU_IsNull(env, javaDevice)) {
 708         JNU_CallMethodByName(env, NULL, javaDevice, "invalidate",
 709                              "(I)V", defIndex);
 710     }
 711 }
 712 
 713 /**
 714  * Static deviceIndex-based methods
 715  *
 716  * The following methods take a deviceIndex for the list of devices
 717  * and perform the appropriate action on that device.  This way of
 718  * dereferencing the list of devices allows us to do appropriate
 719  * locks around the list to ensure multi-threaded safety.
 720  */
 721 
 722 
 723 jobject AwtWin32GraphicsDevice::GetColorModel(JNIEnv *env, jboolean dynamic,
 724                                               int deviceIndex)
 725 {
 726     Devices::InstanceAccess devices;
 727     return devices->GetDevice(deviceIndex)->GetColorModel(env, dynamic);
 728 }
 729 
 730 LPMONITORINFO AwtWin32GraphicsDevice::GetMonitorInfo(int deviceIndex)
 731 {
 732     Devices::InstanceAccess devices;
 733     return devices->GetDevice(deviceIndex)->GetMonitorInfo();
 734 }
 735 
 736 /**
 737  * This function updates the data in the MONITORINFOEX structure pointed to by
 738  * pMonitorInfo for all monitors on the system.  Added for 4654713.
 739  */
 740 void AwtWin32GraphicsDevice::ResetAllMonitorInfo()
 741 {
 742     //IE in some circumstances generates WM_SETTINGCHANGE message on appearance
 743     //and thus triggers this method
 744     //but we may not have the devices list initialized yet.
 745     if (!Devices::GetInstance()){
 746         return;
 747     }
 748     Devices::InstanceAccess devices;
 749     int devicesNum = devices->GetNumDevices();
 750     for (int deviceIndex = 0; deviceIndex < devicesNum; deviceIndex++) {
 751         HMONITOR monitor = devices->GetDevice(deviceIndex)->GetMonitor();
 752         ::GetMonitorInfo(monitor,
 753                          devices->GetDevice(deviceIndex)->pMonitorInfo);
 754     }
 755 }
 756 















 757 void AwtWin32GraphicsDevice::DisableOffscreenAccelerationForDevice(
 758     HMONITOR hMonitor)
 759 {
 760     Devices::InstanceAccess devices;
 761     if (hMonitor == NULL) {
 762         devices->GetDevice(0)->DisableOffscreenAcceleration();
 763     } else {
 764         int devicesNum = devices->GetNumDevices();
 765         for (int i = 0; i < devicesNum; ++i) {
 766             if (devices->GetDevice(i)->GetMonitor() == hMonitor) {
 767                 devices->GetDevice(i)->DisableOffscreenAcceleration();
 768             }
 769         }
 770     }
 771 }
 772 
 773 HMONITOR AwtWin32GraphicsDevice::GetMonitor(int deviceIndex)
 774 {
 775     Devices::InstanceAccess devices;
 776     return devices->GetDevice(deviceIndex)->GetMonitor();
 777 }
 778 
 779 HPALETTE AwtWin32GraphicsDevice::GetPalette(int deviceIndex)
 780 {
 781     Devices::InstanceAccess devices;
 782     return devices->GetDevice(deviceIndex)->GetPalette();
 783 }
 784 
 785 void AwtWin32GraphicsDevice::UpdateDynamicColorModel(int deviceIndex)
 786 {
 787     Devices::InstanceAccess devices;
 788     devices->GetDevice(deviceIndex)->UpdateDynamicColorModel();
 789 }
 790 
 791 BOOL AwtWin32GraphicsDevice::UpdateSystemPalette(int deviceIndex)
 792 {
 793     Devices::InstanceAccess devices;
 794     return devices->GetDevice(deviceIndex)->UpdateSystemPalette();
 795 }
 796 
 797 HPALETTE AwtWin32GraphicsDevice::SelectPalette(HDC hDC, int deviceIndex)
 798 {
 799     Devices::InstanceAccess devices;
 800     return devices->GetDevice(deviceIndex)->SelectPalette(hDC);
 801 }
 802 
 803 void AwtWin32GraphicsDevice::RealizePalette(HDC hDC, int deviceIndex)
 804 {
 805     Devices::InstanceAccess devices;
 806     devices->GetDevice(deviceIndex)->RealizePalette(hDC);
 807 }
 808 
 809 ColorData *AwtWin32GraphicsDevice::GetColorData(int deviceIndex)
 810 {
 811     Devices::InstanceAccess devices;
 812     return devices->GetDevice(deviceIndex)->GetColorData();
 813 }
 814 
 815 /**
 816  * Return the grayscale value for the indicated device.
 817  */
 818 int AwtWin32GraphicsDevice::GetGrayness(int deviceIndex)
 819 {
 820     Devices::InstanceAccess devices;
 821     return devices->GetDevice(deviceIndex)->GetGrayness();
 822 }
 823 
 824 HDC AwtWin32GraphicsDevice::GetDCFromScreen(int screen) {
 825     J2dTraceLn1(J2D_TRACE_INFO,
 826                 "AwtWin32GraphicsDevice::GetDCFromScreen screen=%d", screen);
 827     Devices::InstanceAccess devices;
 828     AwtWin32GraphicsDevice *dev = devices->GetDevice(screen);
 829     return MakeDCFromMonitor(dev->GetMonitor());
 830 }
 831 
 832 /** Compare elements of MONITORINFOEX structures for the given HMONITORs.
 833  * If equal, return TRUE
 834  */
 835 BOOL AwtWin32GraphicsDevice::AreSameMonitors(HMONITOR mon1, HMONITOR mon2) {
 836     J2dTraceLn2(J2D_TRACE_INFO,
 837                 "AwtWin32GraphicsDevice::AreSameMonitors mhnd1=%x mhnd2=%x",
 838                 mon1, mon2);
 839     DASSERT(mon1 != NULL);
 840     DASSERT(mon2 != NULL);
 841 
 842     MONITORINFOEX mi1;
 843     MONITORINFOEX mi2;
 844 
 845     memset((void*)(&mi1), 0, sizeof(MONITORINFOEX));
 846     mi1.cbSize = sizeof(MONITORINFOEX);
 847     memset((void*)(&mi2), 0, sizeof(MONITORINFOEX));
 848     mi2.cbSize = sizeof(MONITORINFOEX);
 849 
 850     if (::GetMonitorInfo(mon1, &mi1) != 0 &&
 851         ::GetMonitorInfo(mon2, &mi2) != 0 )
 852     {
 853         if (::EqualRect(&mi1.rcMonitor, &mi2.rcMonitor) &&
 854             ::EqualRect(&mi1.rcWork, &mi2.rcWork) &&
 855             (mi1.dwFlags  == mi1.dwFlags))
 856         {
 857 
 858             J2dTraceLn(J2D_TRACE_VERBOSE, "  the monitors are the same");
 859             return TRUE;
 860         }
 861     }
 862     J2dTraceLn(J2D_TRACE_VERBOSE, "  the monitors are not the same");
 863     return FALSE;
 864 }
 865 
 866 int AwtWin32GraphicsDevice::GetScreenFromHMONITOR(HMONITOR mon) {
 867     J2dTraceLn1(J2D_TRACE_INFO,
 868                 "AwtWin32GraphicsDevice::GetScreenFromHMONITOR mhnd=%x", mon);
 869 
 870     DASSERT(mon != NULL);
 871     JNIEnv *env = (JNIEnv*) JNU_GetEnv(jvm, JNI_VERSION_1_2);
 872     if (!Devices::GetInstance()) {
 873        Devices::UpdateInstance(env);
 874     }
 875     Devices::InstanceAccess devices;
 876 
 877     for (int i = 0; i < devices->GetNumDevices(); i++) {
 878         HMONITOR mhnd = devices->GetDevice(i)->GetMonitor();
 879         if (AreSameMonitors(mon, mhnd)) {
 880             J2dTraceLn1(J2D_TRACE_VERBOSE, "  Found device: %d", i);
 881             return i;
 882         }
 883     }
 884 
 885     J2dTraceLn1(J2D_TRACE_WARNING,
 886                 "AwtWin32GraphicsDevice::GetScreenFromHMONITOR(): "\
 887                 "couldn't find screen for HMONITOR %x, returning default", mon);
 888     return AwtWin32GraphicsDevice::GetDefaultDeviceIndex();
 889 }
 890 
 891 
 892 /**
 893  * End of static deviceIndex-based methods
 894  */
 895 
 896 
 897     const DWORD REQUIRED_FLAGS = (   //Flags which must be set in
 898      PFD_SUPPORT_GDI |               //in the PixelFormatDescriptor.
 899      PFD_DRAW_TO_WINDOW);            //Used to choose the default config
 900                                      //and to check formats in
 901                                      //isPixFmtSupported()
 902 extern "C" {
 903 
 904 JNIEXPORT void JNICALL
 905 Java_sun_awt_Win32GraphicsDevice_initIDs(JNIEnv *env, jclass cls)
 906 {
 907     TRY;
 908 
 909     /* class ids */
 910     jclass iCMClass = env->FindClass("java/awt/image/IndexColorModel");
 911     CHECK_NULL(iCMClass);
 912     AwtWin32GraphicsDevice::indexCMClass = (jclass) env->NewGlobalRef(iCMClass);
 913     env->DeleteLocalRef(iCMClass);
 914     DASSERT(AwtWin32GraphicsDevice::indexCMClass);
 915     CHECK_NULL(AwtWin32GraphicsDevice::indexCMClass);
 916 
 917     jclass wTClass = env->FindClass("sun/awt/windows/WToolkit");
 918     CHECK_NULL(wTClass);
 919     AwtWin32GraphicsDevice::wToolkitClass = (jclass)env->NewGlobalRef(wTClass);
 920     env->DeleteLocalRef(wTClass);
 921     DASSERT(AwtWin32GraphicsDevice::wToolkitClass);
 922     CHECK_NULL(AwtWin32GraphicsDevice::wToolkitClass);
 923 
 924     /* field ids */
 925     AwtWin32GraphicsDevice::dynamicColorModelID = env->GetFieldID(cls,
 926         "dynamicColorModel", "Ljava/awt/image/ColorModel;");
 927     DASSERT(AwtWin32GraphicsDevice::dynamicColorModelID);
 928     CHECK_NULL(AwtWin32GraphicsDevice::dynamicColorModelID);
 929 
 930     AwtWin32GraphicsDevice::indexCMrgbID =
 931         env->GetFieldID(AwtWin32GraphicsDevice::indexCMClass, "rgb", "[I");
 932     DASSERT(AwtWin32GraphicsDevice::indexCMrgbID);
 933     CHECK_NULL(AwtWin32GraphicsDevice::indexCMrgbID);
 934 
 935     AwtWin32GraphicsDevice::indexCMcacheID =
 936         env->GetFieldID(AwtWin32GraphicsDevice::indexCMClass,
 937         "lookupcache", "[I");
 938     DASSERT(AwtWin32GraphicsDevice::indexCMcacheID);
 939     CHECK_NULL(AwtWin32GraphicsDevice::indexCMcacheID);
 940 
 941     /* method ids */
 942     AwtWin32GraphicsDevice::paletteChangedMID = env->GetStaticMethodID(
 943         AwtWin32GraphicsDevice::wToolkitClass, "paletteChanged", "()V");
 944     DASSERT(AwtWin32GraphicsDevice::paletteChangedMID);
 945     CHECK_NULL(AwtWin32GraphicsDevice::paletteChangedMID);
 946 
 947     // Only want to call this once per session
 948     make_uns_ordered_dither_array(img_oda_alpha, 256);
 949 
 950     // workaround JDK-6477756, ignore return value to keep dll in memory
 951     JDK_LoadSystemLibrary("opengl32.dll");
 952 
 953     CATCH_BAD_ALLOC;
 954 }
 955 
 956 } /* extern "C" */
 957 
 958 
 959 /*
 960  * Class:     sun_awt_Win32GraphicsDevice
 961  * Method:    getMaxConfigsImpl
 962  * Signature: ()I
 963  */
 964 
 965 JNIEXPORT jint JNICALL Java_sun_awt_Win32GraphicsDevice_getMaxConfigsImpl
 966     (JNIEnv* jniEnv, jobject theThis, jint screen) {
 967         TRY;
 968     HDC hDC = AwtWin32GraphicsDevice::GetDCFromScreen(screen);
 969 
 970     PIXELFORMATDESCRIPTOR pfd;
 971     int max = ::DescribePixelFormat(hDC, 1, sizeof(PIXELFORMATDESCRIPTOR),
 972         &pfd);
 973     if (hDC != NULL) {
 974         VERIFY(::DeleteDC(hDC));
 975         hDC = NULL;
 976     }
 977     //If ::DescribePixelFormat() fails, max = 0
 978     //In this case, we return 1 config with visual number 0
 979     if (max == 0) {
 980         max = 1;
 981     }
 982     return (jint)max;
 983         CATCH_BAD_ALLOC_RET(0);
 984 }
 985 
 986 /*
 987  * Class:     sun_awt_Win32GraphicsDevice
 988  * Method:    isPixFmtSupported
 989  * Signature: (I)Z
 990  */
 991 
 992 JNIEXPORT jboolean JNICALL Java_sun_awt_Win32GraphicsDevice_isPixFmtSupported
 993     (JNIEnv* env, jobject theThis, jint pixFmtID, jint screen) {
 994         TRY;
 995     jboolean suppColor = JNI_TRUE;
 996     HDC hDC = AwtWin32GraphicsDevice::GetDCFromScreen(screen);
 997 
 998     if (pixFmtID == 0) {
 999         return true;
1000     }
1001 
1002     PIXELFORMATDESCRIPTOR pfd;
1003     int max = ::DescribePixelFormat(hDC, (int)pixFmtID,
1004         sizeof(PIXELFORMATDESCRIPTOR), &pfd);
1005     DASSERT(max);
1006 
1007     //Check for supported ColorModel
1008     if ((pfd.cColorBits < 8) ||
1009        ((pfd.cColorBits == 8) && (pfd.iPixelType != PFD_TYPE_COLORINDEX))) {
1010         //Note: this still allows for PixelFormats with > 8 color bits
1011         //which use COLORINDEX instead of RGB.  This seems to work fine,
1012         //although issues may crop up involving PFD_NEED_PALETTE, which
1013         //is not currently taken into account.
1014         //If changes are made, they should also be reflected in
1015         //getDefaultPixID.
1016         suppColor = JNI_FALSE;
1017     }
1018 
1019     if (hDC != NULL) {
1020         VERIFY(::DeleteDC(hDC));
1021         hDC = NULL;
1022     }
1023     return (((pfd.dwFlags & REQUIRED_FLAGS) == REQUIRED_FLAGS) && suppColor) ?
1024      JNI_TRUE : JNI_FALSE;
1025         CATCH_BAD_ALLOC_RET(FALSE);
1026 }
1027 
1028 /*
1029  * Class:     sun_awt_Win32GraphicsDevice
1030  * Method:    getDefaultPixIDImpl
1031  * Signature: (I)I
1032  */
1033 
1034 JNIEXPORT jint JNICALL Java_sun_awt_Win32GraphicsDevice_getDefaultPixIDImpl
1035     (JNIEnv* env, jobject theThis, jint screen) {
1036         TRY;
1037     int pixFmtID = 0;
1038     HDC hDC = AwtWin32GraphicsDevice::GetDCFromScreen(screen);
1039 
1040     PIXELFORMATDESCRIPTOR pfd = {
1041         sizeof(PIXELFORMATDESCRIPTOR),
1042         1,               //version
1043         REQUIRED_FLAGS,  //flags
1044         0,               //iPixelType
1045         0,               //cColorBits
1046         0,0,0,0,0,0,0,0, //cRedBits, cRedShift, green, blue, alpha
1047         0,0,0,0,0,       //cAccumBits, cAccumRedBits, green, blue, alpha
1048         0,0,0,0,0,0,0,0  //etc.
1049     };
1050 
1051     //If 8-bit mode, must use Indexed mode
1052     if (8 == ::GetDeviceCaps(hDC, BITSPIXEL)) {
1053         pfd.iPixelType = PFD_TYPE_COLORINDEX;
1054     }
1055 
1056     pixFmtID = ::ChoosePixelFormat(hDC, &pfd);
1057     if (pixFmtID == 0) {
1058         //Return 0 if GDI call fails.
1059         if (hDC != NULL) {
1060             VERIFY(::DeleteDC(hDC));
1061             hDC = NULL;
1062         }
1063         return pixFmtID;
1064     }
1065 
1066     if (JNI_FALSE == Java_sun_awt_Win32GraphicsDevice_isPixFmtSupported(
1067      env, theThis, pixFmtID, screen)) {
1068         /* Can't find a suitable pixel format ID.  Fall back on 0. */
1069         pixFmtID = 0;
1070     }
1071 
1072     VERIFY(::DeleteDC(hDC));
1073     hDC = NULL;
1074     return (jint)pixFmtID;
1075         CATCH_BAD_ALLOC_RET(0);
1076 }
1077 
1078 /*
1079  * Class:     sun_awt_Win32GraphicsDevice
1080  * Method:    enterFullScreenExclusive
1081  * Signature: (Ljava/awt/peer/WindowPeer;)V
1082  */
1083 
1084 JNIEXPORT void JNICALL
1085 Java_sun_awt_Win32GraphicsDevice_enterFullScreenExclusive(
1086         JNIEnv* env, jobject graphicsDevice,
1087         jint screen, jobject windowPeer) {
1088 
1089     TRY;
1090 
1091     PDATA pData;
1092     JNI_CHECK_PEER_RETURN(windowPeer);
1093 
1094     AwtWindow *window = (AwtWindow *)pData;  // safe cast since we are called
1095                                              // with the WWindowPeer object
1096     HWND hWnd = window->GetHWnd();
1097 
1098     if (!::SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0,
1099                         SWP_NOMOVE|SWP_NOOWNERZORDER|SWP_NOSIZE))
1100     {
1101         J2dTraceLn1(J2D_TRACE_ERROR,
1102                     "Error %d setting topmost attribute to fs window",
1103                     ::GetLastError());
1104     }
1105 
1106     CATCH_BAD_ALLOC;
1107 }
1108 
1109 /*
1110  * Class:     sun_awt_Win32GraphicsDevice
1111  * Method:    exitFullScreenExclusive
1112  * Signature: (Ljava/awt/peer/WindowPeer;)V
1113  */
1114 
1115 JNIEXPORT void JNICALL
1116 Java_sun_awt_Win32GraphicsDevice_exitFullScreenExclusive(
1117         JNIEnv* env, jobject graphicsDevice,
1118         jint screen, jobject windowPeer) {
1119 
1120     TRY;
1121 
1122     PDATA pData;
1123     JNI_CHECK_PEER_RETURN(windowPeer);
1124 
1125     AwtWindow *window = (AwtWindow *)pData;  // safe cast since we are called
1126                                              // with the WWindowPeer object
1127     HWND hWnd = window->GetHWnd();
1128 
1129     jobject target = env->GetObjectField(windowPeer, AwtObject::targetID);
1130     jboolean alwaysOnTop = JNU_GetFieldByName(env, NULL, target, "alwaysOnTop", "Z").z;
1131     env->DeleteLocalRef(target);
1132 
1133     if (!::SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
1134                         SWP_NOMOVE|SWP_NOOWNERZORDER|SWP_NOSIZE))
1135     {
1136         J2dTraceLn1(J2D_TRACE_ERROR,
1137                     "Error %d unsetting topmost attribute to fs window",
1138                     ::GetLastError());
1139     }
1140 
1141     // We should restore alwaysOnTop state as it's anyway dropped here
1142     Java_sun_awt_windows_WWindowPeer_setAlwaysOnTopNative(env, windowPeer, alwaysOnTop);
1143 
1144     CATCH_BAD_ALLOC;
1145 }
1146 
1147 jobject CreateDisplayMode(JNIEnv* env, jint width, jint height,
1148     jint bitDepth, jint refreshRate) {
1149 
1150     TRY;
1151 
1152     jclass displayModeClass = env->FindClass("java/awt/DisplayMode");
1153     if (JNU_IsNull(env, displayModeClass)) {
1154         env->ExceptionClear();
1155         JNU_ThrowInternalError(env, "Could not get display mode class");
1156         return NULL;
1157     }
1158 
1159     jmethodID cid = env->GetMethodID(displayModeClass, "<init>", "(IIII)V");
1160     if (cid == NULL) {
1161         env->ExceptionClear();
1162         JNU_ThrowInternalError(env, "Could not get display mode constructor");
1163         return NULL;
1164     }
1165 
1166     jobject displayMode = env->NewObject(displayModeClass, cid, width,
1167         height, bitDepth, refreshRate);
1168     return displayMode;
1169 
1170     CATCH_BAD_ALLOC_RET(NULL);
1171 }
1172 
1173 /**
1174  * A utility function which retrieves a DISPLAY_DEVICE information
1175  * given a screen number.
1176  *
1177  * If the function was able to find an attached device for the given screen
1178  * number, the lpDisplayDevice will be initialized with the data and
1179  * the function will return TRUE, otherwise it returns FALSE and contents
1180  * of the structure pointed to by lpDisplayDevice is undefined.
1181  */
1182 static BOOL
1183 GetAttachedDisplayDevice(int screen, DISPLAY_DEVICE *lpDisplayDevice)
1184 {
1185     DWORD dwDeviceNum = 0;
1186     lpDisplayDevice->cb = sizeof(DISPLAY_DEVICE);
1187     while (EnumDisplayDevices(NULL, dwDeviceNum, lpDisplayDevice, 0) &&
1188            dwDeviceNum < 20) // avoid infinite loop with buggy drivers
1189     {
1190         if (lpDisplayDevice->StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) {
1191             Devices::InstanceAccess devices;
1192             MONITORINFOEX *pMonInfo =
1193                 (LPMONITORINFOEX)devices->GetDevice(screen)->GetMonitorInfo();
1194             // make sure the device names match
1195             if (wcscmp(pMonInfo->szDevice, lpDisplayDevice->DeviceName) == 0) {
1196                 return TRUE;
1197             }
1198         }
1199         dwDeviceNum++;
1200     }
1201     return FALSE;
1202 }
1203 
1204 /*
1205  * Class:     sun_awt_Win32GraphicsDevice
1206  * Method:    getCurrentDisplayMode
1207  * Signature: (IZ)Ljava/awt/DisplayMode;
1208  */
1209 JNIEXPORT jobject JNICALL
1210 Java_sun_awt_Win32GraphicsDevice_getCurrentDisplayMode
1211     (JNIEnv* env, jobject graphicsDevice, jint screen)
1212 {
1213     TRY;
1214 
1215     DEVMODE dm;
1216     LPTSTR pName = NULL;
1217 
1218     dm.dmSize = sizeof(dm);
1219     dm.dmDriverExtra = 0;
1220 
1221     DISPLAY_DEVICE displayDevice;
1222     if (GetAttachedDisplayDevice(screen, &displayDevice)) {
1223         pName = displayDevice.DeviceName;
1224     }
1225     if (!EnumDisplaySettings(pName, ENUM_CURRENT_SETTINGS, &dm))
1226     {
1227         return NULL;
1228     }
1229 
1230     return CreateDisplayMode(env, dm.dmPelsWidth,
1231         dm.dmPelsHeight, dm.dmBitsPerPel, dm.dmDisplayFrequency);
1232 
1233     CATCH_BAD_ALLOC_RET(NULL);
1234 }
1235 
1236 /*
1237  * Class:     sun_awt_Win32GraphicsDevice
1238  * Method:    configDisplayMode
1239  * Signature: (IIIIZ)V
1240  */
1241 JNIEXPORT void JNICALL
1242 Java_sun_awt_Win32GraphicsDevice_configDisplayMode
1243     (JNIEnv* env, jobject graphicsDevice, jint screen, jobject windowPeer,
1244      jint width, jint height, jint bitDepth, jint refreshRate)
1245 {
1246     TRY;
1247 
1248         DEVMODE dm;
1249 
1250     dm.dmSize = sizeof(dm);
1251     dm.dmDriverExtra = 0;
1252     dm.dmPelsWidth = width;
1253     dm.dmPelsHeight = height;
1254     dm.dmBitsPerPel = bitDepth;
1255     dm.dmDisplayFrequency = refreshRate;
1256     dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT |
1257         DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
1258 
1259     // ChangeDisplaySettings works only on the primary screen.
1260     // ChangeDisplaySettingsEx is not available on NT,
1261     // so it'd be nice not to break it if we can help it.
1262     if (screen == AwtWin32GraphicsDevice::GetDefaultDeviceIndex()) {
1263         if (::ChangeDisplaySettings(&dm, CDS_FULLSCREEN) !=
1264             DISP_CHANGE_SUCCESSFUL)
1265         {
1266             JNU_ThrowInternalError(env,
1267                                    "Could not set display mode");
1268         }
1269         return;
1270     }
1271 
1272     DISPLAY_DEVICE displayDevice;
1273     if (!GetAttachedDisplayDevice(screen, &displayDevice) ||
1274         (::ChangeDisplaySettingsEx(displayDevice.DeviceName, &dm, NULL, CDS_FULLSCREEN, NULL) !=
1275           DISP_CHANGE_SUCCESSFUL))
1276     {
1277         JNU_ThrowInternalError(env,
1278                                "Could not set display mode");
1279     }
1280 
1281     CATCH_BAD_ALLOC;
1282 }
1283 
1284 class EnumDisplayModeParam {
1285 public:
1286     EnumDisplayModeParam(JNIEnv* e, jobject a) : env(e), arrayList(a) {}
1287     JNIEnv* env;
1288     jobject arrayList;
1289 };
1290 
1291 void addDisplayMode(JNIEnv* env, jobject arrayList, jint width,
1292     jint height, jint bitDepth, jint refreshRate) {
1293 
1294     TRY;
1295 
1296     jobject displayMode = CreateDisplayMode(env, width, height,
1297         bitDepth, refreshRate);
1298     if (!JNU_IsNull(env, displayMode)) {
1299         jclass arrayListClass = env->GetObjectClass(arrayList);
1300         if (JNU_IsNull(env, arrayListClass)) {
1301             JNU_ThrowInternalError(env,
1302                 "Could not get class java.util.ArrayList");
1303             return;
1304         }
1305         jmethodID mid = env->GetMethodID(arrayListClass, "add",
1306         "(Ljava/lang/Object;)Z");
1307         if (mid == NULL) {
1308             env->ExceptionClear();
1309             JNU_ThrowInternalError(env,
1310                 "Could not get method java.util.ArrayList.add()");
1311             return;
1312         }
1313         env->CallObjectMethod(arrayList, mid, displayMode);
1314         env->DeleteLocalRef(displayMode);
1315     }
1316 
1317     CATCH_BAD_ALLOC;
1318 }
1319 
1320 /*
1321  * Class:     sun_awt_Win32GraphicsDevice
1322  * Method:    enumDisplayModes
1323  * Signature: (Ljava/util/ArrayList;Z)V
1324  */
1325 JNIEXPORT void JNICALL Java_sun_awt_Win32GraphicsDevice_enumDisplayModes
1326     (JNIEnv* env, jobject graphicsDevice, jint screen, jobject arrayList)
1327 {
1328 
1329     TRY;
1330 
1331     DEVMODE dm;
1332     LPTSTR pName = NULL;
1333     DISPLAY_DEVICE displayDevice;
1334 
1335 
1336     if (GetAttachedDisplayDevice(screen, &displayDevice)) {
1337         pName = displayDevice.DeviceName;
1338     }
1339 
1340     dm.dmSize = sizeof(dm);
1341     dm.dmDriverExtra = 0;
1342 
1343     BOOL bContinue = TRUE;
1344     for (int i = 0; bContinue; i++) {
1345         bContinue = EnumDisplaySettings(pName, i, &dm);
1346         if (dm.dmBitsPerPel >= 8) {
1347             addDisplayMode(env, arrayList, dm.dmPelsWidth, dm.dmPelsHeight,
1348                            dm.dmBitsPerPel, dm.dmDisplayFrequency);
1349             JNU_CHECK_EXCEPTION(env);
1350         }
1351     }
1352 
1353     CATCH_BAD_ALLOC;
1354 }
1355 
1356 /*
1357  * Class:     sun_awt_Win32GraphicsDevice
1358  * Method:    makeColorModel
1359  * Signature: ()Ljava/awt/image/ColorModel
1360  */
1361 
1362 JNIEXPORT jobject JNICALL
1363     Java_sun_awt_Win32GraphicsDevice_makeColorModel
1364     (JNIEnv *env, jobject thisPtr, jint screen, jboolean dynamic)
1365 {
1366     Devices::InstanceAccess devices;
1367     return devices->GetDevice(screen)->GetColorModel(env, dynamic);
1368 }
1369 
1370 /*
1371  * Class:     sun_awt_Win32GraphicsDevice
1372  * Method:    initDevice
1373  * Signature: (I)V
1374  */
1375 JNIEXPORT void JNICALL
1376     Java_sun_awt_Win32GraphicsDevice_initDevice
1377     (JNIEnv *env, jobject thisPtr, jint screen)
1378 {
1379     Devices::InstanceAccess devices;
1380     devices->GetDevice(screen)->SetJavaDevice(env, thisPtr);
1381 }
1382 
1383 /*
1384  * Class:     sun_awt_Win32GraphicsDevice
1385  * Method:    setNativeScale
1386  * Signature: (I,F,F)V
1387  */
1388 JNIEXPORT void JNICALL
1389     Java_sun_awt_Win32GraphicsDevice_setNativeScale
1390     (JNIEnv *env, jobject thisPtr, jint screen, jfloat scaleX, jfloat scaleY)
1391 {
1392     Devices::InstanceAccess devices;
1393     AwtWin32GraphicsDevice *device = devices->GetDevice(screen);
1394 
1395     if (device != NULL ) {

1396         device->SetScale(scaleX, scaleY);
1397     }
1398 }
1399 
1400 /*
1401  * Class:     sun_awt_Win32GraphicsDevice
1402  * Method:    getNativeScaleX
1403  * Signature: (I)F
1404  */
1405 JNIEXPORT jfloat JNICALL
1406     Java_sun_awt_Win32GraphicsDevice_getNativeScaleX
1407     (JNIEnv *env, jobject thisPtr, jint screen)
1408 {
1409     Devices::InstanceAccess devices;
1410     AwtWin32GraphicsDevice *device = devices->GetDevice(screen);
1411     return (device == NULL) ? 1 : device->GetScaleX();
1412 }
1413 
1414 /*
1415  * Class:     sun_awt_Win32GraphicsDevice
1416  * Method:    getNativeScaleY
1417  * Signature: (I)F
1418  */
1419 JNIEXPORT jfloat JNICALL
1420     Java_sun_awt_Win32GraphicsDevice_getNativeScaleY
1421     (JNIEnv *env, jobject thisPtr, jint screen)
1422 {
1423     Devices::InstanceAccess devices;
1424     AwtWin32GraphicsDevice *device = devices->GetDevice(screen);
1425     return (device == NULL) ? 1 : device->GetScaleY();
1426 }
1427 
1428 /*
1429 * Class:     sun_awt_Win32GraphicsDevice
1430 * Method:    initNativeScale
1431 * Signature: (I)V;
1432 */
1433 JNIEXPORT void JNICALL
1434 Java_sun_awt_Win32GraphicsDevice_initNativeScale
1435 (JNIEnv *env, jobject thisPtr, jint screen)
1436 {
1437     Devices::InstanceAccess devices;
1438     AwtWin32GraphicsDevice *device = devices->GetDevice(screen);
1439 
1440     if (device != NULL) {
1441         device->InitDesktopScales();
1442     }
1443 }
1444 
--- EOF ---