1 /*
   2  * Copyright (c) 1996, 2017, 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 
  28 #include <jlong.h>
  29 
  30 #include "awt_Component.h"
  31 #include "awt_Container.h"
  32 #include "awt_Frame.h"
  33 #include "awt_Dialog.h"
  34 #include "awt_Insets.h"
  35 #include "awt_Panel.h"
  36 #include "awt_Toolkit.h"
  37 #include "awt_Window.h"
  38 #include "awt_Win32GraphicsDevice.h"
  39 #include "awt_BitmapUtil.h"
  40 #include "awt_IconCursor.h"
  41 #include "ComCtl32Util.h"
  42 
  43 #include "java_awt_Insets.h"
  44 #include <java_awt_Container.h>
  45 #include <java_awt_event_ComponentEvent.h>
  46 #include "sun_awt_windows_WCanvasPeer.h"
  47 
  48 #include <windowsx.h>
  49 #include <math.h>
  50 #if !defined(__int3264)
  51 typedef __int32 LONG_PTR;
  52 #endif // __int3264
  53 
  54 #if defined(_MSC_VER) && _MSC_VER >= 1800
  55 #  define ROUND_TO_INT(num)    ((int) round(num))
  56 #else
  57 #  define ROUND_TO_INT(num)    ((int) floor((num) + 0.5))
  58 #endif
  59 // Used for Swing's Menu/Tooltip animation Support
  60 const int UNSPECIFIED = 0;
  61 const int TOOLTIP = 1;
  62 const int MENU = 2;
  63 const int SUBMENU = 3;
  64 const int POPUPMENU = 4;
  65 const int COMBOBOX_POPUP = 5;
  66 const int TYPES_COUNT = 6;
  67 jint windowTYPES[TYPES_COUNT];
  68 
  69 
  70 /* IMPORTANT! Read the README.JNI file for notes on JNI converted AWT code.
  71  */
  72 
  73 /***********************************************************************/
  74 // struct for _SetAlwaysOnTop() method
  75 struct SetAlwaysOnTopStruct {
  76     jobject window;
  77     jboolean value;
  78 };
  79 // struct for _SetTitle() method
  80 struct SetTitleStruct {
  81     jobject window;
  82     jstring title;
  83 };
  84 // struct for _SetResizable() method
  85 struct SetResizableStruct {
  86     jobject window;
  87     jboolean resizable;
  88 };
  89 // struct for _UpdateInsets() method
  90 struct UpdateInsetsStruct {
  91     jobject window;
  92     jobject insets;
  93 };
  94 // struct for _ReshapeFrame() method
  95 struct ReshapeFrameStruct {
  96     jobject frame;
  97     jint x, y;
  98     jint w, h;
  99 };
 100 // struct for _SetIconImagesData
 101 struct SetIconImagesDataStruct {
 102     jobject window;
 103     jintArray iconRaster;
 104     jint w, h;
 105     jintArray smallIconRaster;
 106     jint smw, smh;
 107 };
 108 // struct for _SetMinSize() method
 109 // and other methods setting sizes
 110 struct SizeStruct {
 111     jobject window;
 112     jint w, h;
 113 };
 114 // struct for _SetFocusableWindow() method
 115 struct SetFocusableWindowStruct {
 116     jobject window;
 117     jboolean isFocusableWindow;
 118 };
 119 // struct for _ModalDisable() method
 120 struct ModalDisableStruct {
 121     jobject window;
 122     jlong blockerHWnd;
 123 };
 124 // struct for _SetOpacity() method
 125 struct OpacityStruct {
 126     jobject window;
 127     jint iOpacity;
 128 };
 129 // struct for _SetOpaque() method
 130 struct OpaqueStruct {
 131     jobject window;
 132     jboolean isOpaque;
 133 };
 134 // struct for _UpdateWindow() method
 135 struct UpdateWindowStruct {
 136     jobject window;
 137     jintArray data;
 138     HBITMAP hBitmap;
 139     jint width, height;
 140 };
 141 // Struct for _RequestWindowFocus() method
 142 struct RequestWindowFocusStruct {
 143     jobject component;
 144     jboolean isMouseEventCause;
 145 };
 146 // struct for _RepositionSecurityWarning() method
 147 struct RepositionSecurityWarningStruct {
 148     jobject window;
 149 };
 150 
 151 struct SetFullScreenExclusiveModeStateStruct {
 152     jobject window;
 153     jboolean isFSEMState;
 154 };
 155 
 156 // struct for _WindowDPIChange() method
 157 struct ScaleStruct {
 158     jobject window;
 159     jint prevScreen;
 160     jfloat prevScaleX;
 161     jfloat prevScaleY;
 162     jint screen;
 163     jfloat scaleX;
 164     jfloat scaleY;
 165 };
 166 
 167 struct OverrideHandle {
 168     jobject frame;
 169     HWND handle;
 170 };
 171 
 172 /************************************************************************
 173  * AwtWindow fields
 174  */
 175 
 176 jfieldID AwtWindow::warningStringID;
 177 jfieldID AwtWindow::locationByPlatformID;
 178 jfieldID AwtWindow::autoRequestFocusID;
 179 jfieldID AwtWindow::securityWarningWidthID;
 180 jfieldID AwtWindow::securityWarningHeightID;
 181 
 182 jfieldID AwtWindow::sysXID;
 183 jfieldID AwtWindow::sysYID;
 184 jfieldID AwtWindow::sysWID;
 185 jfieldID AwtWindow::sysHID;
 186 jfieldID AwtWindow::windowTypeID;
 187 
 188 jmethodID AwtWindow::getWarningStringMID;
 189 jmethodID AwtWindow::calculateSecurityWarningPositionMID;
 190 jmethodID AwtWindow::windowTypeNameMID;
 191 
 192 int AwtWindow::ms_instanceCounter = 0;
 193 HHOOK AwtWindow::ms_hCBTFilter;
 194 AwtWindow * AwtWindow::m_grabbedWindow = NULL;
 195 BOOL AwtWindow::sm_resizing = FALSE;
 196 UINT AwtWindow::untrustedWindowsCounter = 0;
 197 
 198 /************************************************************************
 199  * AwtWindow class methods
 200  */
 201 
 202 AwtWindow::AwtWindow() {
 203     m_sizePt.x = m_sizePt.y = 0;
 204     m_owningFrameDialog = NULL;
 205     m_isResizable = FALSE;//Default value is replaced after construction
 206     m_minSize.x = m_minSize.y = 0;
 207     m_hIcon = NULL;
 208     m_hIconSm = NULL;
 209     m_iconInherited = FALSE;
 210     VERIFY(::SetRectEmpty(&m_insets));
 211     VERIFY(::SetRectEmpty(&m_old_insets));
 212     VERIFY(::SetRectEmpty(&m_warningRect));
 213 
 214     // what's the best initial value?
 215     m_screenNum = -1;
 216     ms_instanceCounter++;
 217     m_grabbed = FALSE;
 218     m_isFocusableWindow = TRUE;
 219     m_isRetainingHierarchyZOrder = FALSE;
 220     m_filterFocusAndActivation = FALSE;
 221 
 222     if (AwtWindow::ms_instanceCounter == 1) {
 223         AwtWindow::ms_hCBTFilter =
 224             ::SetWindowsHookEx(WH_CBT, (HOOKPROC)AwtWindow::CBTFilter,
 225                                0, AwtToolkit::MainThread());
 226     }
 227 
 228     m_opaque = TRUE;
 229     m_opacity = 0xff;
 230 
 231 
 232     warningString = NULL;
 233     warningWindow = NULL;
 234     securityTooltipWindow = NULL;
 235     securityWarningAnimationStage = 0;
 236     currentWmSizeState = SIZE_RESTORED;
 237 
 238     hContentBitmap = NULL;
 239 
 240     ::InitializeCriticalSection(&contentBitmapCS);
 241 
 242     m_windowType = NORMAL;
 243     m_alwaysOnTop = false;
 244 
 245     fullScreenExclusiveModeState = FALSE;
 246     m_winSizeMove = FALSE;
 247     prevScaleRec.screen = -1;
 248     prevScaleRec.scaleX = -1.0f;
 249     prevScaleRec.scaleY = -1.0f;
 250     m_overridenHwnd = NULL;
 251 }
 252 
 253 AwtWindow::~AwtWindow()
 254 {
 255     if (warningString != NULL) {
 256         delete [] warningString;
 257     }
 258     DeleteContentBitmap();
 259     ::DeleteCriticalSection(&contentBitmapCS);
 260 }
 261 
 262 void AwtWindow::Dispose()
 263 {
 264     // Fix 4745575 GDI Resource Leak
 265     // MSDN
 266     // Before a window is destroyed (that is, before it returns from processing
 267     // the WM_NCDESTROY message), an application must remove all entries it has
 268     // added to the property list. The application must use the RemoveProp function
 269     // to remove the entries.
 270 
 271     if (--AwtWindow::ms_instanceCounter == 0) {
 272         ::UnhookWindowsHookEx(AwtWindow::ms_hCBTFilter);
 273     }
 274 
 275     ::RemoveProp(GetHWnd(), ModalBlockerProp);
 276 
 277     if (m_grabbedWindow == this) {
 278         Ungrab();
 279     }
 280     if ((m_hIcon != NULL) && !m_iconInherited) {
 281         ::DestroyIcon(m_hIcon);
 282     }
 283     if ((m_hIconSm != NULL) && !m_iconInherited) {
 284         ::DestroyIcon(m_hIconSm);
 285     }
 286 
 287     AwtCanvas::Dispose();
 288 }
 289 
 290 void
 291 AwtWindow::Grab() {
 292     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 293     if (m_grabbedWindow != NULL) {
 294         m_grabbedWindow->Ungrab();
 295     }
 296     m_grabbed = TRUE;
 297     m_grabbedWindow = this;
 298     if (AwtComponent::GetFocusedWindow() == NULL && IsFocusableWindow()) {
 299         // we shouldn't perform grab in this case (see 4841881 & 6539458)
 300         Ungrab();
 301     } else if (GetHWnd() != AwtComponent::GetFocusedWindow()) {
 302         _ToFront(env->NewGlobalRef(GetPeer(env)));
 303         // Global ref was deleted in _ToFront
 304     }
 305 }
 306 
 307 void
 308 AwtWindow::Ungrab(BOOL doPost) {
 309     if (m_grabbed && m_grabbedWindow == this) {
 310         if (doPost) {
 311             PostUngrabEvent();
 312         }
 313         m_grabbedWindow = NULL;
 314         m_grabbed = FALSE;
 315     }
 316 }
 317 
 318 void
 319 AwtWindow::Ungrab() {
 320     Ungrab(TRUE);
 321 }
 322 
 323 void AwtWindow::_Grab(void * param) {
 324     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 325 
 326     jobject self = (jobject)param;
 327 
 328     if (env->EnsureLocalCapacity(1) < 0)
 329     {
 330         env->DeleteGlobalRef(self);
 331         return;
 332     }
 333 
 334     AwtWindow *p = NULL;
 335 
 336     PDATA pData;
 337     JNI_CHECK_PEER_GOTO(self, ret);
 338     p = (AwtWindow *)pData;
 339     p->Grab();
 340 
 341   ret:
 342     env->DeleteGlobalRef(self);
 343 }
 344 
 345 void AwtWindow::_Ungrab(void * param) {
 346     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 347 
 348     jobject self = (jobject)param;
 349 
 350     if (env->EnsureLocalCapacity(1) < 0)
 351     {
 352         env->DeleteGlobalRef(self);
 353         return;
 354     }
 355 
 356     AwtWindow *p = NULL;
 357 
 358     PDATA pData;
 359     JNI_CHECK_PEER_GOTO(self, ret);
 360     p = (AwtWindow *)pData;
 361     p->Ungrab(FALSE);
 362 
 363   ret:
 364     env->DeleteGlobalRef(self);
 365 }
 366 
 367 MsgRouting AwtWindow::WmNcMouseDown(WPARAM hitTest, int x, int y, int button) {
 368     if (m_grabbedWindow != NULL && !m_grabbedWindow->IsOneOfOwnersOf(this)) {
 369         m_grabbedWindow->Ungrab();
 370     }
 371     return AwtCanvas::WmNcMouseDown(hitTest, x, y, button);
 372 }
 373 
 374 MsgRouting AwtWindow::WmWindowPosChanging(LPARAM windowPos) {
 375     return mrDoDefault;
 376 }
 377 
 378 void AwtWindow::RepositionSecurityWarning(JNIEnv *env)
 379 {
 380     RECT rect;
 381     CalculateWarningWindowBounds(env, &rect);
 382 
 383     ::SetWindowPos(warningWindow, IsAlwaysOnTop() ? HWND_TOPMOST : HWND_NOTOPMOST,
 384             rect.left, rect.top,
 385             rect.right - rect.left, rect.bottom - rect.top,
 386             SWP_ASYNCWINDOWPOS | SWP_NOACTIVATE |
 387             SWP_NOOWNERZORDER
 388             );
 389 }
 390 
 391 MsgRouting AwtWindow::WmWindowPosChanged(LPARAM windowPos) {
 392     WINDOWPOS * wp = (WINDOWPOS *)windowPos;
 393 
 394     // Reposition the warning window
 395     if (IsUntrusted() && warningWindow != NULL) {
 396         if (wp->flags & SWP_HIDEWINDOW) {
 397             UpdateSecurityWarningVisibility();
 398         }
 399 
 400         RepositionSecurityWarning((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2));
 401 
 402         if (wp->flags & SWP_SHOWWINDOW) {
 403             UpdateSecurityWarningVisibility();
 404         }
 405     }
 406 
 407     if (wp->flags & SWP_HIDEWINDOW) {
 408         EnableTranslucency(FALSE);
 409     }
 410     if (wp->flags & SWP_SHOWWINDOW) {
 411         EnableTranslucency(TRUE);
 412     }
 413 
 414     return mrDoDefault;
 415 }
 416 
 417 LPCTSTR AwtWindow::GetClassName() {
 418   return TEXT("SunAwtWindow");
 419 }
 420 
 421 void AwtWindow::FillClassInfo(WNDCLASSEX *lpwc)
 422 {
 423     AwtComponent::FillClassInfo(lpwc);
 424     /*
 425      * This line causes bug #4189244 (Swing Popup menu is not being refreshed (cleared) under a Dialog)
 426      * so it's comment out (son@sparc.spb.su)
 427      *
 428      * lpwc->style     |= CS_SAVEBITS; // improve pull-down menu performance
 429      */
 430     lpwc->cbWndExtra = DLGWINDOWEXTRA;
 431 }
 432 
 433 bool AwtWindow::IsWarningWindow(HWND hWnd)
 434 {
 435     const UINT len = 128;
 436     TCHAR windowClassName[len];
 437 
 438     ::RealGetWindowClass(hWnd, windowClassName, len);
 439     return 0 == _tcsncmp(windowClassName,
 440             AwtWindow::GetWarningWindowClassName(), len);
 441 }
 442 
 443 LRESULT CALLBACK AwtWindow::CBTFilter(int nCode, WPARAM wParam, LPARAM lParam)
 444 {
 445     if (nCode == HCBT_ACTIVATE || nCode == HCBT_SETFOCUS) {
 446         HWND hWnd = (HWND)wParam;
 447         AwtComponent *comp = AwtComponent::GetComponent(hWnd);
 448 
 449         if (comp == NULL) {
 450             // Check if it's a security warning icon
 451             // See: 5091224, 6181725, 6732583
 452             if (AwtWindow::IsWarningWindow(hWnd)) {
 453                 return 1;
 454             }
 455         } else {
 456             if (comp->IsTopLevel()) {
 457                 AwtWindow* win = (AwtWindow*)comp;
 458 
 459                 if (!win->IsFocusableWindow() ||
 460                         win->m_filterFocusAndActivation)
 461                 {
 462                     return 1; // Don't change focus/activation.
 463                 }
 464             }
 465         }
 466     }
 467     return ::CallNextHookEx(AwtWindow::ms_hCBTFilter, nCode, wParam, lParam);
 468 }
 469 
 470 void AwtWindow::InitSecurityWarningSize(JNIEnv *env)
 471 {
 472     warningWindowWidth = ::GetSystemMetrics(SM_CXSMICON);
 473     warningWindowHeight = ::GetSystemMetrics(SM_CYSMICON);
 474 
 475     jobject target = GetTarget(env);
 476 
 477     env->SetIntField(target, AwtWindow::securityWarningWidthID,
 478             warningWindowWidth);
 479     env->SetIntField(target, AwtWindow::securityWarningHeightID,
 480             warningWindowHeight);
 481 
 482     env->DeleteLocalRef(target);
 483 }
 484 
 485 void AwtWindow::CreateHWnd(JNIEnv *env, LPCWSTR title,
 486         DWORD windowStyle,
 487         DWORD windowExStyle,
 488         int x, int y, int w, int h,
 489         HWND hWndParent, HMENU hMenu,
 490         COLORREF colorForeground,
 491         COLORREF colorBackground,
 492         jobject peer)
 493 {
 494     // Retrieve the warning string
 495     // Note: we need to get it before CreateHWnd() happens because
 496     // the isUntrusted() method may be invoked while the HWND
 497     // is being created in response to some window messages.
 498     jobject target = env->GetObjectField(peer, AwtObject::targetID);
 499     jstring javaWarningString =
 500         (jstring)env->CallObjectMethod(target, AwtWindow::getWarningStringMID);
 501 
 502     if (javaWarningString != NULL) {
 503         size_t length = env->GetStringLength(javaWarningString) + 1;
 504         warningString = new WCHAR[length];
 505         env->GetStringRegion(javaWarningString, 0,
 506                 static_cast<jsize>(length - 1), reinterpret_cast<jchar*>(warningString));
 507         warningString[length-1] = L'\0';
 508 
 509         env->DeleteLocalRef(javaWarningString);
 510     }
 511     env->DeleteLocalRef(target);
 512 
 513     InitType(env, peer);
 514     JNU_CHECK_EXCEPTION(env);
 515 
 516     TweakStyle(windowStyle, windowExStyle);
 517 
 518     AwtCanvas::CreateHWnd(env, title,
 519             windowStyle,
 520             windowExStyle,
 521             x, y, w, h,
 522             hWndParent, hMenu,
 523             colorForeground,
 524             colorBackground,
 525             peer);
 526 
 527     // Now we need to create the warning window.
 528     CreateWarningWindow(env);
 529 }
 530 
 531 void AwtWindow::CreateWarningWindow(JNIEnv *env)
 532 {
 533     if (!IsUntrusted()) {
 534         return;
 535     }
 536 
 537     if (++AwtWindow::untrustedWindowsCounter == 1) {
 538         AwtToolkit::GetInstance().InstallMouseLowLevelHook();
 539     }
 540 
 541     InitSecurityWarningSize(env);
 542 
 543     RECT rect;
 544     CalculateWarningWindowBounds(env, &rect);
 545 
 546     RegisterWarningWindowClass();
 547     warningWindow = ::CreateWindowEx(
 548             WS_EX_NOACTIVATE,
 549             GetWarningWindowClassName(),
 550             warningString,
 551             WS_POPUP,
 552             rect.left, rect.top,
 553             rect.right - rect.left, rect.bottom - rect.top,
 554             GetHWnd(), // owner
 555             NULL, // menu
 556             AwtToolkit::GetInstance().GetModuleHandle(),
 557             NULL // lParam
 558             );
 559     if (warningWindow == NULL) {
 560         //XXX: actually this is bad... We didn't manage to create the window.
 561         return;
 562     }
 563 
 564     HICON hIcon = GetSecurityWarningIcon();
 565 
 566     ICONINFO ii;
 567     ::GetIconInfo(hIcon, &ii);
 568 
 569     //Note: we assume that every security icon has exactly the same shape.
 570     HRGN rgn = BitmapUtil::BitmapToRgn(ii.hbmColor);
 571     if (rgn) {
 572         ::SetWindowRgn(warningWindow, rgn, TRUE);
 573     }
 574 
 575     // Now we need to create the tooltip control for this window.
 576     if (!ComCtl32Util::GetInstance().IsToolTipControlInitialized()) {
 577         return;
 578     }
 579 
 580     securityTooltipWindow = ::CreateWindowEx(
 581             WS_EX_TOPMOST,
 582             TOOLTIPS_CLASS,
 583             NULL,
 584             WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
 585             CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 586             warningWindow,
 587             NULL,
 588             AwtToolkit::GetInstance().GetModuleHandle(),
 589             NULL
 590             );
 591 
 592     ::SetWindowPos(securityTooltipWindow,
 593             HWND_TOPMOST, 0, 0, 0, 0,
 594             SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 595 
 596 
 597     // We currently don't expect changing the size of the window,
 598     // hence we may not care of updating the TOOL position/size.
 599     ::GetClientRect(warningWindow, &rect);
 600 
 601     TOOLINFO ti;
 602 
 603     ti.cbSize = sizeof(ti);
 604     ti.uFlags = TTF_SUBCLASS;
 605     ti.hwnd = warningWindow;
 606     ti.hinst = AwtToolkit::GetInstance().GetModuleHandle();
 607     ti.uId = 0;
 608     ti.lpszText = warningString;
 609     ti.rect.left = rect.left;
 610     ti.rect.top = rect.top;
 611     ti.rect.right = rect.right;
 612     ti.rect.bottom = rect.bottom;
 613 
 614     ::SendMessage(securityTooltipWindow, TTM_ADDTOOL,
 615             0, (LPARAM) (LPTOOLINFO) &ti);
 616 }
 617 
 618 void AwtWindow::DestroyWarningWindow()
 619 {
 620     if (!IsUntrusted()) {
 621         return;
 622     }
 623     if (--AwtWindow::untrustedWindowsCounter == 0) {
 624         AwtToolkit::GetInstance().UninstallMouseLowLevelHook();
 625     }
 626     if (warningWindow != NULL) {
 627         // Note that the warningWindow is an owned window, and hence
 628         // it would be destroyed automatically. However, the window
 629         // class may only be unregistered if there's no any single
 630         // window left using this class. Thus, we're destroying the
 631         // warning window manually. Note that the tooltip window
 632         // will be destroyed automatically because it's an owned
 633         // window as well.
 634         ::DestroyWindow(warningWindow);
 635         warningWindow = NULL;
 636         securityTooltipWindow = NULL;
 637         UnregisterWarningWindowClass();
 638     }
 639 }
 640 
 641 void AwtWindow::DestroyHWnd()
 642 {
 643     DestroyWarningWindow();
 644     AwtCanvas::DestroyHWnd();
 645 }
 646 
 647 LPCTSTR AwtWindow::GetWarningWindowClassName()
 648 {
 649     return TEXT("SunAwtWarningWindow");
 650 }
 651 
 652 void AwtWindow::FillWarningWindowClassInfo(WNDCLASS *lpwc)
 653 {
 654     lpwc->style         = 0L;
 655     lpwc->lpfnWndProc   = (WNDPROC)WarningWindowProc;
 656     lpwc->cbClsExtra    = 0;
 657     lpwc->cbWndExtra    = 0;
 658     lpwc->hInstance     = AwtToolkit::GetInstance().GetModuleHandle(),
 659     lpwc->hIcon         = AwtToolkit::GetInstance().GetAwtIcon();
 660     lpwc->hCursor       = ::LoadCursor(NULL, IDC_ARROW);
 661     lpwc->hbrBackground = NULL;
 662     lpwc->lpszMenuName  = NULL;
 663     lpwc->lpszClassName = AwtWindow::GetWarningWindowClassName();
 664 }
 665 
 666 void AwtWindow::RegisterWarningWindowClass()
 667 {
 668     WNDCLASS  wc;
 669 
 670     ::ZeroMemory(&wc, sizeof(wc));
 671 
 672     if (!::GetClassInfo(AwtToolkit::GetInstance().GetModuleHandle(),
 673                         AwtWindow::GetWarningWindowClassName(), &wc))
 674     {
 675         AwtWindow::FillWarningWindowClassInfo(&wc);
 676         ATOM atom = ::RegisterClass(&wc);
 677         DASSERT(atom != 0);
 678     }
 679 }
 680 
 681 void AwtWindow::UnregisterWarningWindowClass()
 682 {
 683     ::UnregisterClass(AwtWindow::GetWarningWindowClassName(), AwtToolkit::GetInstance().GetModuleHandle());
 684 }
 685 
 686 HICON AwtWindow::GetSecurityWarningIcon()
 687 {
 688     // It is assumed that the icon at index 0 is gray
 689     const UINT index = securityAnimationKind == akShow ?
 690         securityWarningAnimationStage : 0;
 691     HICON ico = AwtToolkit::GetInstance().GetSecurityWarningIcon(index,
 692             warningWindowWidth, warningWindowHeight);
 693     return ico;
 694 }
 695 
 696 // This function calculates the bounds of the warning window and stores them
 697 // into the RECT structure pointed by the argument rect.
 698 void AwtWindow::CalculateWarningWindowBounds(JNIEnv *env, LPRECT rect)
 699 {
 700     RECT windowBounds;
 701     AwtToolkit::GetWindowRect(GetHWnd(), &windowBounds);
 702 
 703     jobject target = GetTarget(env);
 704     jobject point2D = env->CallObjectMethod(target,
 705             calculateSecurityWarningPositionMID,
 706             (jdouble)windowBounds.left, (jdouble)windowBounds.top,
 707             (jdouble)(windowBounds.right - windowBounds.left),
 708             (jdouble)(windowBounds.bottom - windowBounds.top));
 709     env->DeleteLocalRef(target);
 710 
 711     static jclass point2DClassID = NULL;
 712     static jmethodID point2DGetXMID = NULL;
 713     static jmethodID point2DGetYMID = NULL;
 714 
 715     if (point2DClassID == NULL) {
 716         jclass point2DClassIDLocal = env->FindClass("java/awt/geom/Point2D");
 717         if (point2DClassIDLocal == NULL) {
 718             env->DeleteLocalRef(point2D);
 719             return;
 720         }
 721         point2DClassID = (jclass)env->NewGlobalRef(point2DClassIDLocal);
 722         env->DeleteLocalRef(point2DClassIDLocal);
 723     }
 724 
 725     if (point2DGetXMID == NULL) {
 726         point2DGetXMID = env->GetMethodID(point2DClassID, "getX", "()D");
 727         if (point2DGetXMID == NULL) {
 728             env->DeleteLocalRef(point2D);
 729             return;
 730         }
 731     }
 732     if (point2DGetYMID == NULL) {
 733         point2DGetYMID = env->GetMethodID(point2DClassID, "getY", "()D");
 734         if (point2DGetYMID == NULL) {
 735             env->DeleteLocalRef(point2D);
 736             return;
 737         }
 738     }
 739 
 740 
 741     int x = (int)env->CallDoubleMethod(point2D, point2DGetXMID);
 742     int y = (int)env->CallDoubleMethod(point2D, point2DGetYMID);
 743 
 744     env->DeleteLocalRef(point2D);
 745 
 746     rect->left = x;
 747     rect->top = y;
 748     rect->right = rect->left + warningWindowWidth;
 749     rect->bottom = rect->top + warningWindowHeight;
 750 }
 751 
 752 LRESULT CALLBACK AwtWindow::WarningWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 753 {
 754     switch (uMsg) {
 755         case WM_PAINT:
 756             PaintWarningWindow(hwnd);
 757             return 0;
 758 
 759         case WM_MOUSEACTIVATE:
 760             {
 761                 // Retrive the owner of the warning window.
 762                 HWND javaWindow = ::GetParent(hwnd);
 763                 if (javaWindow) {
 764                     // If the window is blocked by a modal dialog, substitute
 765                     // its handle with the topmost blocker.
 766                     HWND topmostBlocker = GetTopmostModalBlocker(javaWindow);
 767                     if (::IsWindow(topmostBlocker)) {
 768                         javaWindow = topmostBlocker;
 769                     }
 770 
 771                     ::BringWindowToTop(javaWindow);
 772 
 773                     AwtWindow * window =
 774                         (AwtWindow*)AwtComponent::GetComponent(javaWindow);
 775                     if (window == NULL) {
 776                         // Quite unlikely to go into here, but it's way better
 777                         // than getting a crash.
 778                         ::SetForegroundWindow(javaWindow);
 779                     } else {
 780                         // Activate the window if it is focusable and inactive
 781                         if (window->IsFocusableWindow() &&
 782                                 javaWindow != ::GetActiveWindow()) {
 783                             ::SetForegroundWindow(javaWindow);
 784                         } else {
 785                             // ...otherwise just start the animation.
 786                             window->StartSecurityAnimation(akShow);
 787                         }
 788                     }
 789 
 790                     // In every case if there's a top-most blocker, we need to
 791                     // enable modal animation.
 792                     if (::IsWindow(topmostBlocker)) {
 793                         AwtDialog::AnimateModalBlocker(topmostBlocker);
 794                     }
 795                 }
 796                 return MA_NOACTIVATEANDEAT;
 797             }
 798     }
 799     return ::DefWindowProc(hwnd, uMsg, wParam, lParam);
 800 }
 801 
 802 void AwtWindow::PaintWarningWindow(HWND warningWindow)
 803 {
 804     RECT updateRect;
 805 
 806     if (!::GetUpdateRect(warningWindow, &updateRect, FALSE)) {
 807         // got nothing to update
 808         return;
 809     }
 810 
 811     PAINTSTRUCT ps;
 812     HDC hdc = ::BeginPaint(warningWindow, &ps);
 813     if (hdc == NULL) {
 814         // indicates an error
 815         return;
 816     }
 817 
 818     PaintWarningWindow(warningWindow, hdc);
 819 
 820     ::EndPaint(warningWindow, &ps);
 821 }
 822 
 823 void AwtWindow::PaintWarningWindow(HWND warningWindow, HDC hdc)
 824 {
 825     HWND javaWindow = ::GetParent(warningWindow);
 826 
 827     AwtWindow * window = (AwtWindow*)AwtComponent::GetComponent(javaWindow);
 828     if (window == NULL) {
 829         return;
 830     }
 831 
 832     ::DrawIconEx(hdc, 0, 0, window->GetSecurityWarningIcon(),
 833             window->warningWindowWidth, window->warningWindowHeight,
 834             0, NULL, DI_NORMAL);
 835 }
 836 
 837 static const UINT_PTR IDT_AWT_SECURITYANIMATION = 0x102;
 838 
 839 // Approximately 6 times a second. 0.75 seconds total.
 840 static const UINT securityAnimationTimerElapse = 150;
 841 static const UINT securityAnimationMaxIterations = 5;
 842 
 843 void AwtWindow::RepaintWarningWindow()
 844 {
 845     HDC hdc = ::GetDC(warningWindow);
 846     PaintWarningWindow(warningWindow, hdc);
 847     ::ReleaseDC(warningWindow, hdc);
 848 }
 849 
 850 void AwtWindow::SetLayered(HWND window, bool layered)
 851 {
 852     const LONG ex_style = ::GetWindowLong(window, GWL_EXSTYLE);
 853     ::SetWindowLong(window, GWL_EXSTYLE, layered ?
 854             ex_style | WS_EX_LAYERED : ex_style & ~WS_EX_LAYERED);
 855 }
 856 
 857 bool AwtWindow::IsLayered(HWND window)
 858 {
 859     const LONG ex_style = ::GetWindowLong(window, GWL_EXSTYLE);
 860     return ex_style & WS_EX_LAYERED;
 861 }
 862 
 863 void AwtWindow::StartSecurityAnimation(AnimationKind kind)
 864 {
 865     if (!IsUntrusted()) {
 866         return;
 867     }
 868     if (warningWindow == NULL) {
 869         return;
 870     }
 871 
 872     securityAnimationKind = kind;
 873 
 874     securityWarningAnimationStage = 1;
 875     ::SetTimer(GetHWnd(), IDT_AWT_SECURITYANIMATION,
 876             securityAnimationTimerElapse, NULL);
 877 
 878     if (securityAnimationKind == akShow) {
 879         ::SetWindowPos(warningWindow,
 880                 IsAlwaysOnTop() ? HWND_TOPMOST : HWND_NOTOPMOST,
 881                 0, 0, 0, 0,
 882                 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE |
 883                 SWP_SHOWWINDOW | SWP_NOOWNERZORDER);
 884 
 885         ::SetLayeredWindowAttributes(warningWindow, RGB(0, 0, 0),
 886                 0xFF, LWA_ALPHA);
 887         AwtWindow::SetLayered(warningWindow, false);
 888         ::RedrawWindow(warningWindow, NULL, NULL,
 889                 RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
 890     } else if (securityAnimationKind == akPreHide) {
 891         // Pre-hiding means fading-out. We have to make the window layered.
 892         // Note: Some VNC clients do not support layered windows, hence
 893         // we dynamically turn it on and off. See 6805231.
 894         AwtWindow::SetLayered(warningWindow, true);
 895     }
 896 }
 897 
 898 void AwtWindow::StopSecurityAnimation()
 899 {
 900     if (!IsUntrusted()) {
 901         return;
 902     }
 903     if (warningWindow == NULL) {
 904         return;
 905     }
 906 
 907     securityWarningAnimationStage = 0;
 908     ::KillTimer(GetHWnd(), IDT_AWT_SECURITYANIMATION);
 909 
 910     switch (securityAnimationKind) {
 911         case akHide:
 912         case akPreHide:
 913             ::SetWindowPos(warningWindow, HWND_NOTOPMOST, 0, 0, 0, 0,
 914                     SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE |
 915                     SWP_HIDEWINDOW | SWP_NOOWNERZORDER);
 916             break;
 917         case akShow:
 918             RepaintWarningWindow();
 919             break;
 920     }
 921 
 922     securityAnimationKind = akNone;
 923 }
 924 
 925 MsgRouting AwtWindow::WmTimer(UINT_PTR timerID)
 926 {
 927     if (timerID != IDT_AWT_SECURITYANIMATION) {
 928         return mrPassAlong;
 929     }
 930 
 931     if (securityWarningAnimationStage == 0) {
 932         return mrConsume;
 933     }
 934 
 935     securityWarningAnimationStage++;
 936     if (securityWarningAnimationStage >= securityAnimationMaxIterations) {
 937         if (securityAnimationKind == akPreHide) {
 938             // chain real hiding
 939             StartSecurityAnimation(akHide);
 940         } else {
 941             StopSecurityAnimation();
 942         }
 943     } else {
 944         switch (securityAnimationKind) {
 945             case akHide:
 946                 {
 947                     BYTE opacity = ((int)0xFF *
 948                             (securityAnimationMaxIterations -
 949                              securityWarningAnimationStage)) /
 950                         securityAnimationMaxIterations;
 951                     ::SetLayeredWindowAttributes(warningWindow,
 952                             RGB(0, 0, 0), opacity, LWA_ALPHA);
 953                 }
 954                 break;
 955             case akShow:
 956             case akNone: // quite unlikely, but quite safe
 957                 RepaintWarningWindow();
 958                 break;
 959         }
 960     }
 961 
 962     return mrConsume;
 963 }
 964 
 965 // The security warning is visible if:
 966 //    1. The window has the keyboard window focus, OR
 967 //    2. The mouse pointer is located within the window bounds,
 968 //       or within the security warning icon.
 969 void AwtWindow::UpdateSecurityWarningVisibility()
 970 {
 971     if (!IsUntrusted()) {
 972         return;
 973     }
 974     if (warningWindow == NULL) {
 975         return;
 976     }
 977 
 978     bool show = false;
 979 
 980     if (IsVisible() && currentWmSizeState != SIZE_MINIMIZED &&
 981             !isFullScreenExclusiveMode())
 982     {
 983         if (AwtComponent::GetFocusedWindow() == GetHWnd()) {
 984             show = true;
 985         }
 986 
 987         HWND hwnd = AwtToolkit::GetInstance().GetWindowUnderMouse();
 988         if (hwnd == GetHWnd()) {
 989             show = true;
 990         }
 991         if (hwnd == warningWindow) {
 992             show = true;
 993         }
 994     }
 995 
 996     if (show && (!::IsWindowVisible(warningWindow) ||
 997                 securityAnimationKind == akHide ||
 998                 securityAnimationKind == akPreHide)) {
 999         StartSecurityAnimation(akShow);
1000     }
1001     if (!show && ::IsWindowVisible(warningWindow)) {
1002         StartSecurityAnimation(akPreHide);
1003     }
1004 }
1005 
1006 void AwtWindow::FocusedWindowChanged(HWND from, HWND to)
1007 {
1008     AwtWindow * fw = (AwtWindow *)AwtComponent::GetComponent(from);
1009     AwtWindow * tw = (AwtWindow *)AwtComponent::GetComponent(to);
1010 
1011     if (fw != NULL) {
1012         fw->UpdateSecurityWarningVisibility();
1013     }
1014     if (tw != NULL) {
1015         tw->UpdateSecurityWarningVisibility();
1016 
1017         // Flash on receiving the keyboard focus even if the warning
1018         // has already been shown (e.g. by hovering with the mouse)
1019         tw->StartSecurityAnimation(akShow);
1020     }
1021 }
1022 
1023 void AwtWindow::_RepositionSecurityWarning(void* param)
1024 {
1025     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1026 
1027     RepositionSecurityWarningStruct *rsws =
1028         (RepositionSecurityWarningStruct *)param;
1029     jobject self = rsws->window;
1030 
1031     PDATA pData;
1032     JNI_CHECK_PEER_GOTO(self, ret);
1033     AwtWindow *window = (AwtWindow *)pData;
1034 
1035     window->RepositionSecurityWarning(env);
1036 
1037   ret:
1038     env->DeleteGlobalRef(self);
1039     delete rsws;
1040 }
1041 
1042 void AwtWindow::InitType(JNIEnv *env, jobject peer)
1043 {
1044     jobject type = env->GetObjectField(peer, windowTypeID);
1045     if (type == NULL) {
1046         return;
1047     }
1048 
1049     jstring value = (jstring)env->CallObjectMethod(type, windowTypeNameMID);
1050     if (value == NULL) {
1051         env->DeleteLocalRef(type);
1052         return;
1053     }
1054 
1055     const char* valueNative = env->GetStringUTFChars(value, 0);
1056     if (valueNative == NULL) {
1057         env->DeleteLocalRef(value);
1058         env->DeleteLocalRef(type);
1059         return;
1060     }
1061 
1062     if (strcmp(valueNative, "UTILITY") == 0) {
1063         m_windowType = UTILITY;
1064     } else if (strcmp(valueNative, "POPUP") == 0) {
1065         m_windowType = POPUP;
1066     }
1067 
1068     env->ReleaseStringUTFChars(value, valueNative);
1069     env->DeleteLocalRef(value);
1070     env->DeleteLocalRef(type);
1071 }
1072 
1073 void AwtWindow::TweakStyle(DWORD & style, DWORD & exStyle)
1074 {
1075     switch (GetType()) {
1076         case UTILITY:
1077             exStyle |= WS_EX_TOOLWINDOW;
1078             break;
1079         case POPUP:
1080             style &= ~WS_OVERLAPPED;
1081             style |= WS_POPUP;
1082             break;
1083     }
1084 }
1085 
1086 /* Create a new AwtWindow object and window.   */
1087 AwtWindow* AwtWindow::Create(jobject self, jobject parent)
1088 {
1089     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1090 
1091     jobject target = NULL;
1092     AwtWindow* window = NULL;
1093 
1094     try {
1095         if (env->EnsureLocalCapacity(1) < 0) {
1096             return NULL;
1097         }
1098 
1099         AwtWindow* awtParent = NULL;
1100 
1101         PDATA pData;
1102         if (parent != NULL) {
1103             JNI_CHECK_PEER_GOTO(parent, done);
1104             awtParent = (AwtWindow *)pData;
1105         }
1106 
1107         target = env->GetObjectField(self, AwtObject::targetID);
1108         JNI_CHECK_NULL_GOTO(target, "null target", done);
1109 
1110         window = new AwtWindow();
1111 
1112         {
1113             if (JNU_IsInstanceOfByName(env, target, "javax/swing/Popup$HeavyWeightWindow") > 0) {
1114                 window->m_isRetainingHierarchyZOrder = TRUE;
1115             }
1116             if (env->ExceptionCheck()) goto done;
1117             DWORD style = WS_CLIPCHILDREN | WS_POPUP;
1118             DWORD exStyle = WS_EX_NOACTIVATE;
1119             if (GetRTL()) {
1120                 exStyle |= WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR;
1121                 if (GetRTLReadingOrder())
1122                     exStyle |= WS_EX_RTLREADING;
1123             }
1124             if (awtParent != NULL) {
1125                 window->InitOwner(awtParent);
1126             } else {
1127                 // specify WS_EX_TOOLWINDOW to remove parentless windows from taskbar
1128                 exStyle |= WS_EX_TOOLWINDOW;
1129             }
1130             window->CreateHWnd(env, L"",
1131                                style, exStyle,
1132                                0, 0, 0, 0,
1133                                (awtParent != NULL) ? awtParent->GetHWnd() : NULL,
1134                                NULL,
1135                                ::GetSysColor(COLOR_WINDOWTEXT),
1136                                ::GetSysColor(COLOR_WINDOW),
1137                                self);
1138 
1139             jint x = env->GetIntField(target, AwtComponent::xID);
1140             jint y = env->GetIntField(target, AwtComponent::yID);
1141             jint width = env->GetIntField(target, AwtComponent::widthID);
1142             jint height = env->GetIntField(target, AwtComponent::heightID);
1143 
1144             /*
1145              * Initialize icon as inherited from parent if it exists
1146              */
1147             if (parent != NULL) {
1148                 window->m_hIcon = awtParent->GetHIcon();
1149                 window->m_hIconSm = awtParent->GetHIconSm();
1150                 window->m_iconInherited = TRUE;
1151             }
1152             window->DoUpdateIcon();
1153 
1154 
1155             /*
1156              * Reshape here instead of during create, so that a WM_NCCALCSIZE
1157              * is sent.
1158              */
1159             window->Reshape(x, y, width, height);
1160         }
1161     } catch (...) {
1162         env->DeleteLocalRef(target);
1163         throw;
1164     }
1165 
1166 done:
1167     env->DeleteLocalRef(target);
1168     return window;
1169 }
1170 
1171 BOOL AwtWindow::IsOneOfOwnersOf(AwtWindow * wnd) {
1172     while (wnd != NULL) {
1173         if (wnd == this || wnd->GetOwningFrameOrDialog() == this) return TRUE;
1174         wnd = (AwtWindow*)GetComponent(::GetWindow(wnd->GetHWnd(), GW_OWNER));
1175     }
1176     return FALSE;
1177 }
1178 
1179 void AwtWindow::InitOwner(AwtWindow *owner)
1180 {
1181     DASSERT(owner != NULL);
1182     AwtWindow *initialOwner = owner;
1183     while (owner != NULL && owner->IsSimpleWindow()) {
1184 
1185         HWND ownerOwnerHWND = ::GetWindow(owner->GetHWnd(), GW_OWNER);
1186         if (ownerOwnerHWND == NULL) {
1187             owner = NULL;
1188             break;
1189         }
1190         owner = (AwtWindow *)AwtComponent::GetComponent(ownerOwnerHWND);
1191     }
1192     if (!owner) {
1193         owner = initialOwner->GetOwningFrameOrDialog();
1194     }
1195     m_owningFrameDialog = (AwtFrame *)owner;
1196 }
1197 
1198 void AwtWindow::moveToDefaultLocation() {
1199     HWND boggy = ::CreateWindow(GetClassName(), L"BOGGY", WS_OVERLAPPED, CW_USEDEFAULT, 0 ,0, 0,
1200         NULL, NULL, NULL, NULL);
1201     RECT defLoc;
1202 
1203     // Fixed 6477497: Windows drawn off-screen on Win98, even when java.awt.Window.locationByPlatform is set
1204     //    Win9x does not position a window until the window is shown.
1205     //    The behavior is slightly opposite to the WinNT (and up), where
1206     //    Windows will position the window upon creation of the window.
1207     //    That's why we have to manually set the left & top values of
1208     //    the defLoc to 0 if the GetWindowRect function returns FALSE.
1209     BOOL result = ::GetWindowRect(boggy, &defLoc);
1210     if (!result) {
1211         defLoc.left = defLoc.top = 0;
1212     }
1213     VERIFY(::DestroyWindow(boggy));
1214     VERIFY(::SetWindowPos(GetHWnd(), NULL, defLoc.left, defLoc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER));
1215 }
1216 
1217 void AwtWindow::Show()
1218 {
1219     m_visible = true;
1220     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1221     BOOL  done = false;
1222     HWND hWnd = GetHWnd();
1223 
1224     if (env->EnsureLocalCapacity(2) < 0) {
1225         return;
1226     }
1227     jobject target = GetTarget(env);
1228     INT nCmdShow;
1229 
1230     AwtFrame* owningFrame = GetOwningFrameOrDialog();
1231     if (IsFocusableWindow() && IsAutoRequestFocus() && owningFrame != NULL &&
1232         ::GetForegroundWindow() == owningFrame->GetHWnd())
1233     {
1234         nCmdShow = SW_SHOW;
1235     } else {
1236         nCmdShow = SW_SHOWNA;
1237     }
1238 
1239     BOOL locationByPlatform = env->GetBooleanField(GetTarget(env), AwtWindow::locationByPlatformID);
1240 
1241     if (locationByPlatform) {
1242          moveToDefaultLocation();
1243     }
1244 
1245     EnableTranslucency(TRUE);
1246 
1247     // The following block exists to support Menu/Tooltip animation for
1248     // Swing programs in a way which avoids introducing any new public api into
1249     // AWT or Swing.
1250     // This code should eventually be replaced by a better longterm solution
1251     // which might involve tagging java.awt.Window instances with a semantic
1252     // property so platforms can animate/decorate/etc accordingly.
1253     //
1254     if (JNU_IsInstanceOfByName(env, target, "com/sun/java/swing/plaf/windows/WindowsPopupWindow") > 0)
1255     {
1256         // need this global ref to make the class unloadable (see 6500204)
1257         static jclass windowsPopupWindowCls;
1258         static jfieldID windowTypeFID = NULL;
1259         jint windowType = 0;
1260         BOOL  animateflag = FALSE;
1261         BOOL  fadeflag = FALSE;
1262         DWORD animateStyle = 0;
1263 
1264         if (windowTypeFID == NULL) {
1265             // Initialize Window type constants ONCE...
1266 
1267             jfieldID windowTYPESFID[TYPES_COUNT];
1268             jclass cls = env->GetObjectClass(target);
1269             windowTypeFID = env->GetFieldID(cls, "windowType", "I");
1270 
1271             windowTYPESFID[UNSPECIFIED] = env->GetStaticFieldID(cls, "UNDEFINED_WINDOW_TYPE", "I");
1272             windowTYPESFID[TOOLTIP] = env->GetStaticFieldID(cls, "TOOLTIP_WINDOW_TYPE", "I");
1273             windowTYPESFID[MENU] = env->GetStaticFieldID(cls, "MENU_WINDOW_TYPE", "I");
1274             windowTYPESFID[SUBMENU] = env->GetStaticFieldID(cls, "SUBMENU_WINDOW_TYPE", "I");
1275             windowTYPESFID[POPUPMENU] = env->GetStaticFieldID(cls, "POPUPMENU_WINDOW_TYPE", "I");
1276             windowTYPESFID[COMBOBOX_POPUP] = env->GetStaticFieldID(cls, "COMBOBOX_POPUP_WINDOW_TYPE", "I");
1277 
1278             for (int i=0; i < 6; i++) {
1279                 windowTYPES[i] = env->GetStaticIntField(cls, windowTYPESFID[i]);
1280             }
1281             windowsPopupWindowCls = (jclass) env->NewGlobalRef(cls);
1282             env->DeleteLocalRef(cls);
1283         }
1284         windowType = env->GetIntField(target, windowTypeFID);
1285 
1286         if (windowType == windowTYPES[TOOLTIP]) {
1287             SystemParametersInfo(SPI_GETTOOLTIPANIMATION, 0, &animateflag, 0);
1288             SystemParametersInfo(SPI_GETTOOLTIPFADE, 0, &fadeflag, 0);
1289             if (animateflag) {
1290               // AW_BLEND currently produces runtime parameter error
1291               // animateStyle = fadeflag? AW_BLEND : AW_SLIDE | AW_VER_POSITIVE;
1292                  animateStyle = fadeflag? 0 : AW_SLIDE | AW_VER_POSITIVE;
1293             }
1294         } else if (windowType == windowTYPES[MENU] || windowType == windowTYPES[SUBMENU] ||
1295                    windowType == windowTYPES[POPUPMENU]) {
1296             SystemParametersInfo(SPI_GETMENUANIMATION, 0, &animateflag, 0);
1297             if (animateflag) {
1298                 SystemParametersInfo(SPI_GETMENUFADE, 0, &fadeflag, 0);
1299                 if (fadeflag) {
1300                     // AW_BLEND currently produces runtime parameter error
1301                     //animateStyle = AW_BLEND;
1302                 }
1303                 if (animateStyle == 0 && !fadeflag) {
1304                     animateStyle = AW_SLIDE;
1305                     if (windowType == windowTYPES[MENU]) {
1306                       animateStyle |= AW_VER_POSITIVE;
1307                     } else if (windowType == windowTYPES[SUBMENU]) {
1308                       animateStyle |= AW_HOR_POSITIVE;
1309                     } else { /* POPUPMENU */
1310                       animateStyle |= (AW_VER_POSITIVE | AW_HOR_POSITIVE);
1311                     }
1312                 }
1313             }
1314         } else if (windowType == windowTYPES[COMBOBOX_POPUP]) {
1315             SystemParametersInfo(SPI_GETCOMBOBOXANIMATION, 0, &animateflag, 0);
1316             if (animateflag) {
1317                  animateStyle = AW_SLIDE | AW_VER_POSITIVE;
1318             }
1319         }
1320 
1321         if (animateStyle != 0) {
1322             BOOL result = ::AnimateWindow(hWnd, (DWORD)200, animateStyle);
1323             if (!result) {
1324                 // TODO: log message
1325             } else {
1326                 // WM_PAINT is not automatically sent when invoking AnimateWindow,
1327                 // so force an expose event
1328                 RECT rect;
1329                 ::GetWindowRect(hWnd,&rect);
1330                 ::ScreenToClient(hWnd, (LPPOINT)&rect);
1331                 ::InvalidateRect(hWnd, &rect, TRUE);
1332                 ::UpdateWindow(hWnd);
1333                 done = TRUE;
1334             }
1335         }
1336     }
1337     if (!done) {
1338         // transient windows shouldn't change the owner window's position in the z-order
1339         if (IsRetainingHierarchyZOrder()){
1340             UINT flags = SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW | SWP_NOOWNERZORDER;
1341             if (nCmdShow == SW_SHOWNA) {
1342                 flags |= SWP_NOACTIVATE;
1343             }
1344             ::SetWindowPos(GetHWnd(), HWND_TOPMOST, 0, 0, 0, 0, flags);
1345         } else {
1346             ::ShowWindow(GetHWnd(), nCmdShow);
1347         }
1348     }
1349     env->DeleteLocalRef(target);
1350 }
1351 
1352 /*
1353  * Get and return the insets for this window (container, really).
1354  * Calculate & cache them while we're at it, for use by AwtGraphics
1355  */
1356 BOOL AwtWindow::UpdateInsets(jobject insets)
1357 {
1358     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1359     DASSERT(GetPeer(env) != NULL);
1360     if (env->EnsureLocalCapacity(2) < 0) {
1361         return FALSE;
1362     }
1363 
1364     // fix 4167248 : don't update insets when frame is iconified
1365     // to avoid bizarre window/client rectangles
1366     if (::IsIconic(GetHWnd())) {
1367         return FALSE;
1368     }
1369 
1370     /*
1371      * Code to calculate insets. Stores results in frame's data
1372      * members, and in the peer's Inset object.
1373      */
1374     RECT outside;
1375     RECT inside;
1376     int extraBottomInsets = 0;
1377 
1378     ::GetClientRect(GetHWnd(), &inside);
1379     ::GetWindowRect(GetHWnd(), &outside);
1380 
1381     /* Update our inset member */
1382     if (outside.right - outside.left > 0 && outside.bottom - outside.top > 0) {
1383         ::MapWindowPoints(GetHWnd(), 0, (LPPOINT)&inside, 2);
1384         m_insets.top = inside.top - outside.top;
1385         m_insets.bottom = outside.bottom - inside.bottom + extraBottomInsets;
1386         m_insets.left = inside.left - outside.left;
1387         m_insets.right = outside.right - inside.right;
1388     } else {
1389         m_insets.top = -1;
1390     }
1391     if (m_insets.left < 0 || m_insets.top < 0 ||
1392         m_insets.right < 0 || m_insets.bottom < 0)
1393     {
1394         /* This window hasn't been sized yet -- use system metrics. */
1395         jobject target = GetTarget(env);
1396         if (IsUndecorated() == FALSE) {
1397             /* Get outer frame sizes. */
1398             LONG style = GetStyle();
1399             if (style & WS_THICKFRAME) {
1400                 m_insets.left = m_insets.right =
1401                     ::GetSystemMetrics(SM_CXSIZEFRAME);
1402                 m_insets.top = m_insets.bottom =
1403                     ::GetSystemMetrics(SM_CYSIZEFRAME);
1404             } else {
1405                 m_insets.left = m_insets.right =
1406                     ::GetSystemMetrics(SM_CXDLGFRAME);
1407                 m_insets.top = m_insets.bottom =
1408                     ::GetSystemMetrics(SM_CYDLGFRAME);
1409             }
1410 
1411 
1412             /* Add in title. */
1413             m_insets.top += ::GetSystemMetrics(SM_CYCAPTION);
1414         }
1415         else {
1416             /* fix for 4418125: Undecorated frames are off by one */
1417             /* undo the -1 set above */
1418             /* Additional fix for 5059656 */
1419                 /* Also, 5089312: Window insets should be 0. */
1420             ::memset(&m_insets, 0, sizeof(m_insets));
1421         }
1422 
1423         /* Add in menuBar, if any. */
1424         if (JNU_IsInstanceOfByName(env, target, "java/awt/Frame") > 0 &&
1425             ((AwtFrame*)this)->GetMenuBar()) {
1426             m_insets.top += ::GetSystemMetrics(SM_CYMENU);
1427         }
1428         if (env->ExceptionCheck()) {
1429             env->DeleteLocalRef(target);
1430             return FALSE;
1431         }
1432         m_insets.bottom += extraBottomInsets;
1433         env->DeleteLocalRef(target);
1434     }
1435 
1436     BOOL insetsChanged = FALSE;
1437 
1438     jobject peer = GetPeer(env);
1439     /* Get insets into our peer directly */
1440     jobject peerInsets = (env)->GetObjectField(peer, AwtPanel::insets_ID);
1441     DASSERT(!safe_ExceptionOccurred(env));
1442 
1443     if (peerInsets != NULL) { // may have been called during creation
1444         (env)->SetIntField(peerInsets, AwtInsets::topID, ScaleDownY(m_insets.top));
1445         (env)->SetIntField(peerInsets, AwtInsets::bottomID, ScaleDownY(m_insets.bottom));
1446         (env)->SetIntField(peerInsets, AwtInsets::leftID, ScaleDownX(m_insets.left));
1447         (env)->SetIntField(peerInsets, AwtInsets::rightID, ScaleDownX(m_insets.right));
1448     }
1449     /* Get insets into the Inset object (if any) that was passed */
1450     if (insets != NULL) {
1451         (env)->SetIntField(insets, AwtInsets::topID, ScaleDownY(m_insets.top));
1452         (env)->SetIntField(insets, AwtInsets::bottomID, ScaleDownY(m_insets.bottom));
1453         (env)->SetIntField(insets, AwtInsets::leftID, ScaleDownX(m_insets.left));
1454         (env)->SetIntField(insets, AwtInsets::rightID, ScaleDownX(m_insets.right));
1455     }
1456     env->DeleteLocalRef(peerInsets);
1457 
1458     insetsChanged = !::EqualRect( &m_old_insets, &m_insets );
1459     ::CopyRect( &m_old_insets, &m_insets );
1460 
1461     if (insetsChanged) {
1462         // Since insets are changed we need to update the surfaceData object
1463         // to reflect that change
1464         env->CallVoidMethod(peer, AwtComponent::replaceSurfaceDataLaterMID);
1465     }
1466 
1467     return insetsChanged;
1468 }
1469 
1470 /**
1471  * Sometimes we need the hWnd that actually owns this Window's hWnd (if
1472  * there is an owner).
1473  */
1474 HWND AwtWindow::GetTopLevelHWnd()
1475 {
1476     return m_owningFrameDialog ? m_owningFrameDialog->GetHWnd() :
1477                                  GetHWnd();
1478 }
1479 
1480 /*
1481  * Although this function sends ComponentEvents, it needs to be defined
1482  * here because only top-level windows need to have move and resize
1483  * events fired from native code.  All contained windows have these events
1484  * fired from common Java code.
1485  */
1486 void AwtWindow::SendComponentEvent(jint eventId)
1487 {
1488     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1489 
1490     static jclass classEvent = NULL;
1491     if (classEvent == NULL) {
1492         if (env->PushLocalFrame(1) < 0)
1493             return;
1494         classEvent = env->FindClass("java/awt/event/ComponentEvent");
1495         if (classEvent != NULL) {
1496             classEvent = (jclass)env->NewGlobalRef(classEvent);
1497         }
1498         env->PopLocalFrame(0);
1499         CHECK_NULL(classEvent);
1500     }
1501     static jmethodID eventInitMID = NULL;
1502     if (eventInitMID == NULL) {
1503         eventInitMID = env->GetMethodID(classEvent, "<init>",
1504                                         "(Ljava/awt/Component;I)V");
1505         CHECK_NULL(eventInitMID);
1506     }
1507     if (env->EnsureLocalCapacity(2) < 0) {
1508         return;
1509     }
1510     jobject target = GetTarget(env);
1511     jobject event = env->NewObject(classEvent, eventInitMID,
1512                                    target, eventId);
1513     DASSERT(!safe_ExceptionOccurred(env));
1514     DASSERT(event != NULL);
1515     if (event == NULL) {
1516         env->DeleteLocalRef(target);
1517         return;
1518     }
1519     SendEvent(event);
1520 
1521     env->DeleteLocalRef(target);
1522     env->DeleteLocalRef(event);
1523 }
1524 
1525 void AwtWindow::SendWindowEvent(jint id, HWND opposite,
1526                                 jint oldState, jint newState)
1527 {
1528     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1529 
1530     static jclass wClassEvent;
1531     if (wClassEvent == NULL) {
1532         if (env->PushLocalFrame(1) < 0)
1533             return;
1534         wClassEvent = env->FindClass("sun/awt/TimedWindowEvent");
1535         if (wClassEvent != NULL) {
1536             wClassEvent = (jclass)env->NewGlobalRef(wClassEvent);
1537         }
1538         env->PopLocalFrame(0);
1539         if (wClassEvent == NULL) {
1540             return;
1541         }
1542     }
1543 
1544     static jmethodID wEventInitMID;
1545     if (wEventInitMID == NULL) {
1546         wEventInitMID =
1547             env->GetMethodID(wClassEvent, "<init>",
1548                              "(Ljava/awt/Window;ILjava/awt/Window;IIJ)V");
1549         DASSERT(wEventInitMID);
1550         if (wEventInitMID == NULL) {
1551             return;
1552         }
1553     }
1554 
1555     static jclass sequencedEventCls;
1556     if (sequencedEventCls == NULL) {
1557         jclass sequencedEventClsLocal
1558             = env->FindClass("java/awt/SequencedEvent");
1559         DASSERT(sequencedEventClsLocal);
1560         CHECK_NULL(sequencedEventClsLocal);
1561         sequencedEventCls =
1562             (jclass)env->NewGlobalRef(sequencedEventClsLocal);
1563         env->DeleteLocalRef(sequencedEventClsLocal);
1564     }
1565 
1566     static jmethodID sequencedEventConst;
1567     if (sequencedEventConst == NULL) {
1568         sequencedEventConst =
1569             env->GetMethodID(sequencedEventCls, "<init>",
1570                              "(Ljava/awt/AWTEvent;)V");
1571         CHECK_NULL(sequencedEventConst);
1572     }
1573 
1574     if (env->EnsureLocalCapacity(3) < 0) {
1575         return;
1576     }
1577 
1578     jobject target = GetTarget(env);
1579     jobject jOpposite = NULL;
1580     if (opposite != NULL) {
1581         AwtComponent *awtOpposite = AwtComponent::GetComponent(opposite);
1582         if (awtOpposite != NULL) {
1583             jOpposite = awtOpposite->GetTarget(env);
1584         }
1585     }
1586     jobject event = env->NewObject(wClassEvent, wEventInitMID, target, id,
1587                                    jOpposite, oldState, newState, ::JVM_CurrentTimeMillis(NULL, 0));
1588     DASSERT(!safe_ExceptionOccurred(env));
1589     DASSERT(event != NULL);
1590     if (jOpposite != NULL) {
1591         env->DeleteLocalRef(jOpposite); jOpposite = NULL;
1592     }
1593     env->DeleteLocalRef(target); target = NULL;
1594     CHECK_NULL(event);
1595 
1596     if (id == java_awt_event_WindowEvent_WINDOW_GAINED_FOCUS ||
1597         id == java_awt_event_WindowEvent_WINDOW_LOST_FOCUS)
1598     {
1599         jobject sequencedEvent = env->NewObject(sequencedEventCls,
1600                                                 sequencedEventConst,
1601                                                 event);
1602         DASSERT(!safe_ExceptionOccurred(env));
1603         DASSERT(sequencedEvent != NULL);
1604         env->DeleteLocalRef(event);
1605         event = sequencedEvent;
1606     }
1607 
1608     SendEvent(event);
1609 
1610     env->DeleteLocalRef(event);
1611 }
1612 
1613 BOOL AwtWindow::AwtSetActiveWindow(BOOL isMouseEventCause, UINT hittest)
1614 {
1615     // We used to reject non mouse window activation if our app wasn't active.
1616     // This code since has been removed as the fix for 7185280
1617 
1618     HWND proxyContainerHWnd = GetProxyToplevelContainer();
1619     HWND proxyHWnd = GetProxyFocusOwner();
1620 
1621     if (proxyContainerHWnd == NULL || proxyHWnd == NULL) {
1622         return FALSE;
1623     }
1624 
1625     // Activate the proxy toplevel container
1626     if (::GetActiveWindow() != proxyContainerHWnd) {
1627         sm_suppressFocusAndActivation = TRUE;
1628         ::BringWindowToTop(proxyContainerHWnd);
1629         ::SetForegroundWindow(proxyContainerHWnd);
1630         sm_suppressFocusAndActivation = FALSE;
1631 
1632         if (::GetActiveWindow() != proxyContainerHWnd) {
1633             return FALSE; // activation has been rejected
1634         }
1635     }
1636 
1637     // Focus the proxy itself
1638     if (::GetFocus() != proxyHWnd) {
1639         sm_suppressFocusAndActivation = TRUE;
1640         ::SetFocus(proxyHWnd);
1641         sm_suppressFocusAndActivation = FALSE;
1642 
1643         if (::GetFocus() != proxyHWnd) {
1644             return FALSE; // focus has been rejected (that is unlikely)
1645         }
1646     }
1647 
1648     const HWND focusedWindow = AwtComponent::GetFocusedWindow();
1649     if (focusedWindow != GetHWnd()) {
1650         if (focusedWindow != NULL) {
1651             // Deactivate the old focused window
1652             AwtWindow::SynthesizeWmActivate(FALSE, focusedWindow, GetHWnd());
1653         }
1654         // Activate the new focused window.
1655         AwtWindow::SynthesizeWmActivate(TRUE, GetHWnd(), focusedWindow);
1656     }
1657     return TRUE;
1658 }
1659 
1660 MsgRouting AwtWindow::WmActivate(UINT nState, BOOL fMinimized, HWND opposite)
1661 {
1662     jint type;
1663 
1664     if (nState != WA_INACTIVE) {
1665         type = java_awt_event_WindowEvent_WINDOW_GAINED_FOCUS;
1666         AwtComponent::SetFocusedWindow(GetHWnd());
1667     } else {
1668         // The owner is not necassarily getting WM_ACTIVATE(WA_INACTIVE).
1669         // So, initiate retaining the actualFocusedWindow.
1670         AwtFrame *owner = GetOwningFrameOrDialog();
1671         if (owner) {
1672             owner->CheckRetainActualFocusedWindow(opposite);
1673         }
1674 
1675         if (m_grabbedWindow != NULL && !m_grabbedWindow->IsOneOfOwnersOf(this)) {
1676             m_grabbedWindow->Ungrab();
1677         }
1678         type = java_awt_event_WindowEvent_WINDOW_LOST_FOCUS;
1679         AwtComponent::SetFocusedWindow(NULL);
1680         sm_focusOwner = NULL;
1681     }
1682 
1683     SendWindowEvent(type, opposite);
1684     return mrConsume;
1685 }
1686 
1687 MsgRouting AwtWindow::WmCreate()
1688 {
1689     return mrDoDefault;
1690 }
1691 
1692 MsgRouting AwtWindow::WmClose()
1693 {
1694     SendWindowEvent(java_awt_event_WindowEvent_WINDOW_CLOSING);
1695 
1696     /* Rely on above notification to handle quitting as needed */
1697     return mrConsume;
1698 }
1699 
1700 MsgRouting AwtWindow::WmDestroy()
1701 {
1702     SendWindowEvent(java_awt_event_WindowEvent_WINDOW_CLOSED);
1703     return AwtComponent::WmDestroy();
1704 }
1705 
1706 MsgRouting AwtWindow::WmShowWindow(BOOL show, UINT status)
1707 {
1708     /*
1709      * Original fix for 4810575. Modified for 6386592.
1710      * If a simple window gets disposed we should synthesize
1711      * WM_ACTIVATE for its nearest owner. This is not performed by default because
1712      * the owner frame/dialog is natively active.
1713      */
1714     HWND hwndSelf = GetHWnd();
1715     HWND hwndOwner = ::GetParent(hwndSelf);
1716 
1717     if (!show && IsSimpleWindow() && hwndSelf == AwtComponent::GetFocusedWindow() &&
1718         hwndOwner != NULL && ::IsWindowVisible(hwndOwner))
1719     {
1720         AwtFrame *owner = (AwtFrame*)AwtComponent::GetComponent(hwndOwner);
1721         if (owner != NULL) {
1722             owner->AwtSetActiveWindow();
1723         }
1724     }
1725 
1726     //Fixed 4842599: REGRESSION: JPopupMenu not Hidden Properly After Iconified and Deiconified
1727     if (show && (status == SW_PARENTOPENING)) {
1728         if (!IsVisible()) {
1729             return mrConsume;
1730         }
1731     }
1732     return AwtCanvas::WmShowWindow(show, status);
1733 }
1734 
1735 /*
1736  * Override AwtComponent's move handling to first update the
1737  * java AWT target's position fields directly, since Windows
1738  * and below can be resized from outside of java (by user)
1739  */
1740 MsgRouting AwtWindow::WmMove(int x, int y)
1741 {
1742     if ( ::IsIconic(GetHWnd()) ) {
1743     // fixes 4065534 (robi.khan@eng)
1744     // if a window is iconified we don't want to update
1745     // it's target's position since minimized Win32 windows
1746     // move to -32000, -32000 for whatever reason
1747     // NOTE: See also AwtWindow::Reshape
1748         return mrDoDefault;
1749     }
1750 
1751     if (m_screenNum == -1) {
1752     // Set initial value
1753         m_screenNum = GetScreenImOn();
1754     }
1755     else {
1756         CheckIfOnNewScreen();
1757     }
1758 
1759     /* Update the java AWT target component's fields directly */
1760     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1761     if (env->EnsureLocalCapacity(1) < 0) {
1762         return mrConsume;
1763     }
1764     jobject peer = GetPeer(env);
1765     jobject target = env->GetObjectField(peer, AwtObject::targetID);
1766 
1767     RECT rect;
1768     ::GetWindowRect(GetHWnd(), &rect);
1769 
1770     (env)->SetIntField(target, AwtComponent::xID, ScaleDownX(rect.left));
1771     (env)->SetIntField(target, AwtComponent::yID, ScaleDownY(rect.top));
1772     (env)->SetIntField(peer, AwtWindow::sysXID, ScaleDownX(rect.left));
1773     (env)->SetIntField(peer, AwtWindow::sysYID, ScaleDownY(rect.top));
1774     SendComponentEvent(java_awt_event_ComponentEvent_COMPONENT_MOVED);
1775 
1776     env->DeleteLocalRef(target);
1777     return AwtComponent::WmMove(x, y);
1778 }
1779 
1780 MsgRouting AwtWindow::WmGetMinMaxInfo(LPMINMAXINFO lpmmi)
1781 {
1782     MsgRouting r = AwtCanvas::WmGetMinMaxInfo(lpmmi);
1783     if ((m_minSize.x == 0) && (m_minSize.y == 0)) {
1784         return r;
1785     }
1786     lpmmi->ptMinTrackSize.x = m_minSize.x;
1787     lpmmi->ptMinTrackSize.y = m_minSize.y;
1788     return mrConsume;
1789 }
1790 
1791 MsgRouting AwtWindow::WmSizing()
1792 {
1793     if (!AwtToolkit::GetInstance().IsDynamicLayoutActive()) {
1794         return mrDoDefault;
1795     }
1796 
1797     DTRACE_PRINTLN("AwtWindow::WmSizing  fullWindowDragEnabled");
1798 
1799     SendComponentEvent(java_awt_event_ComponentEvent_COMPONENT_RESIZED);
1800 
1801     HWND thisHwnd = GetHWnd();
1802     if (thisHwnd == NULL) {
1803         return mrDoDefault;
1804     }
1805 
1806     // Call WComponentPeer::dynamicallyLayoutContainer()
1807     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1808     jobject peer = GetPeer(env);
1809     JNU_CallMethodByName(env, NULL, peer, "dynamicallyLayoutContainer", "()V");
1810     DASSERT(!safe_ExceptionOccurred(env));
1811 
1812     return mrDoDefault;
1813 }
1814 
1815 MsgRouting AwtWindow::WmEnterSizeMove()
1816 {
1817     m_winSizeMove = TRUE;
1818     return mrDoDefault;
1819 }
1820 
1821 MsgRouting AwtWindow::WmExitSizeMove()
1822 {
1823     m_winSizeMove = FALSE;
1824     CheckWindowDPIChange();
1825     return mrDoDefault;
1826 }
1827 
1828 /*
1829  * Override AwtComponent's size handling to first update the
1830  * java AWT target's dimension fields directly, since Windows
1831  * and below can be resized from outside of java (by user)
1832  */
1833 MsgRouting AwtWindow::WmSize(UINT type, int w, int h)
1834 {
1835     currentWmSizeState = type;
1836 
1837     if (type == SIZE_MINIMIZED) {
1838         UpdateSecurityWarningVisibility();
1839         return mrDoDefault;
1840     }
1841 
1842     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1843     if (env->EnsureLocalCapacity(1) < 0)
1844         return mrDoDefault;
1845     jobject target = GetTarget(env);
1846     // fix 4167248 : ensure the insets are up-to-date before using
1847     BOOL insetsChanged = UpdateInsets(NULL);
1848     int newWidth = w + m_insets.left + m_insets.right;
1849     int newHeight = h + m_insets.top + m_insets.bottom;
1850 
1851     (env)->SetIntField(target, AwtComponent::widthID, ScaleDownX(newWidth));
1852     (env)->SetIntField(target, AwtComponent::heightID, ScaleDownY(newHeight));
1853 
1854     jobject peer = GetPeer(env);
1855     (env)->SetIntField(peer, AwtWindow::sysWID, ScaleDownX(newWidth));
1856     (env)->SetIntField(peer, AwtWindow::sysHID, ScaleDownY(newHeight));
1857 
1858     if (!AwtWindow::IsResizing()) {
1859         WindowResized();
1860     }
1861 
1862     env->DeleteLocalRef(target);
1863     return AwtComponent::WmSize(type, w, h);
1864 }
1865 
1866 MsgRouting AwtWindow::WmPaint(HDC)
1867 {
1868     PaintUpdateRgn(&m_insets);
1869     return mrConsume;
1870 }
1871 
1872 MsgRouting AwtWindow::WmSettingChange(UINT wFlag, LPCTSTR pszSection)
1873 {
1874     if (wFlag == SPI_SETNONCLIENTMETRICS) {
1875     // user changed window metrics in
1876     // Control Panel->Display->Appearance
1877     // which may cause window insets to change
1878         UpdateInsets(NULL);
1879 
1880     // [rray] fix for 4407329 - Changing Active Window Border width in display
1881     //  settings causes problems
1882         WindowResized();
1883         Invalidate(NULL);
1884 
1885         return mrConsume;
1886     }
1887     return mrDoDefault;
1888 }
1889 
1890 MsgRouting AwtWindow::WmNcCalcSize(BOOL fCalcValidRects,
1891                                    LPNCCALCSIZE_PARAMS lpncsp, LRESULT& retVal)
1892 {
1893     MsgRouting mrRetVal = mrDoDefault;
1894 
1895     if (fCalcValidRects == FALSE) {
1896         return mrDoDefault;
1897     }
1898     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1899     if (env->EnsureLocalCapacity(2) < 0) {
1900         return mrConsume;
1901     }
1902     // WM_NCCALCSIZE is usually in response to a resize, but
1903     // also can be triggered by SetWindowPos(SWP_FRAMECHANGED),
1904     // which means the insets will have changed - rnk 4/7/1998
1905     retVal = static_cast<UINT>(DefWindowProc(
1906                 WM_NCCALCSIZE, fCalcValidRects, reinterpret_cast<LPARAM>(lpncsp)));
1907     if (HasValidRect()) {
1908         UpdateInsets(NULL);
1909     }
1910     mrRetVal = mrConsume;
1911     return mrRetVal;
1912 }
1913 
1914 MsgRouting AwtWindow::WmNcHitTest(UINT x, UINT y, LRESULT& retVal)
1915 {
1916     // If this window is blocked by modal dialog, return HTCLIENT for any point of it.
1917     // That prevents it to be moved or resized using the mouse. Disabling these
1918     // actions to be launched from sysmenu is implemented by ignoring WM_SYSCOMMAND
1919     if (::IsWindow(GetModalBlocker(GetHWnd()))) {
1920         retVal = HTCLIENT;
1921     } else {
1922         retVal = DefWindowProc(WM_NCHITTEST, 0, MAKELPARAM(x, y));
1923     }
1924     return mrConsume;
1925 }
1926 
1927 MsgRouting AwtWindow::WmGetIcon(WPARAM iconType, LRESULT& retValue)
1928 {
1929     return mrDoDefault;
1930 }
1931 
1932 LRESULT AwtWindow::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
1933 {
1934     MsgRouting mr = mrDoDefault;
1935     LRESULT retValue = 0L;
1936 
1937     switch(message) {
1938         case WM_GETICON:
1939             mr = WmGetIcon(wParam, retValue);
1940             break;
1941         case WM_SYSCOMMAND:
1942             //Fixed 6355340: Contents of frame are not layed out properly on maximize
1943             if ((wParam & 0xFFF0) == SC_SIZE) {
1944                 AwtWindow::sm_resizing = TRUE;
1945                 mr = WmSysCommand(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
1946                 if (mr != mrConsume) {
1947                     // Perform size-move loop here
1948                     AwtWindow::DefWindowProc(message, wParam, lParam);
1949                 }
1950                 AwtWindow::sm_resizing = FALSE;
1951                 if (!AwtToolkit::GetInstance().IsDynamicLayoutActive()) {
1952                     WindowResized();
1953                 } else {
1954                     /*
1955                      * 8016356: check whether window snapping occurred after
1956                      * resizing, i.e. GetWindowRect() returns the real
1957                      * (snapped) window rectangle, e.g. (179, 0)-(483, 1040),
1958                      * but GetWindowPlacement() returns the rectangle of
1959                      * normal window position, e.g. (179, 189)-(483, 445) and
1960                      * they are different. If so, send ComponentResized event.
1961                      */
1962                     WINDOWPLACEMENT wp;
1963                     ::GetWindowPlacement(GetHWnd(), &wp);
1964                     RECT rc;
1965                     ::GetWindowRect(GetHWnd(), &rc);
1966                     if (!::EqualRect(&rc, &wp.rcNormalPosition)) {
1967                         WindowResized();
1968                     }
1969                 }
1970                 mr = mrConsume;
1971             }
1972             break;
1973     }
1974 
1975     if (mr != mrConsume) {
1976         retValue = AwtCanvas::WindowProc(message, wParam, lParam);
1977     }
1978     return retValue;
1979 }
1980 
1981 /*
1982  * Fix for BugTraq ID 4041703: keyDown not being invoked.
1983  * This method overrides AwtCanvas::HandleEvent() since
1984  * an empty Window always receives the focus on the activation
1985  * so we don't have to modify the behavior.
1986  */
1987 MsgRouting AwtWindow::HandleEvent(MSG *msg, BOOL synthetic)
1988 {
1989     return AwtComponent::HandleEvent(msg, synthetic);
1990 }
1991 
1992 void AwtWindow::WindowResized()
1993 {
1994     SendComponentEvent(java_awt_event_ComponentEvent_COMPONENT_RESIZED);
1995     // Need to replace surfaceData on resize to catch changes to
1996     // various component-related values, such as insets
1997     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1998     env->CallVoidMethod(m_peerObject, AwtComponent::replaceSurfaceDataLaterMID);
1999 }
2000 
2001 BOOL CALLBACK InvalidateChildRect(HWND hWnd, LPARAM)
2002 {
2003     TRY;
2004 
2005     ::InvalidateRect(hWnd, NULL, TRUE);
2006     return TRUE;
2007 
2008     CATCH_BAD_ALLOC_RET(FALSE);
2009 }
2010 
2011 void AwtWindow::Invalidate(RECT* r)
2012 {
2013     ::InvalidateRect(GetHWnd(), NULL, TRUE);
2014     ::EnumChildWindows(GetHWnd(), (WNDENUMPROC)InvalidateChildRect, 0);
2015 }
2016 
2017 BOOL AwtWindow::IsResizable() {
2018     return m_isResizable;
2019 }
2020 
2021 void AwtWindow::SetResizable(BOOL isResizable)
2022 {
2023     m_isResizable = isResizable;
2024     if (IsEmbeddedFrame()) {
2025         return;
2026     }
2027     LONG style = GetStyle();
2028     LONG resizeStyle = WS_MAXIMIZEBOX;
2029 
2030     if (IsUndecorated() == FALSE) {
2031         resizeStyle |= WS_THICKFRAME;
2032     }
2033 
2034     if (isResizable) {
2035         style |= resizeStyle;
2036     } else {
2037         style &= ~resizeStyle;
2038     }
2039     SetStyle(style);
2040     RedrawNonClient();
2041 }
2042 
2043 // SetWindowPos flags to cause frame edge to be recalculated
2044 static const UINT SwpFrameChangeFlags =
2045     SWP_FRAMECHANGED | /* causes WM_NCCALCSIZE to be called */
2046     SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
2047     SWP_NOACTIVATE | SWP_NOCOPYBITS |
2048     SWP_NOREPOSITION | SWP_NOSENDCHANGING;
2049 
2050 //
2051 // Forces WM_NCCALCSIZE to be called to recalculate
2052 // window border (updates insets) without redrawing it
2053 //
2054 void AwtWindow::RecalcNonClient()
2055 {
2056     ::SetWindowPos(GetHWnd(), (HWND) NULL, 0, 0, 0, 0, SwpFrameChangeFlags|SWP_NOREDRAW);
2057 }
2058 
2059 //
2060 // Forces WM_NCCALCSIZE to be called to recalculate
2061 // window border (updates insets) and redraws border to match
2062 //
2063 void AwtWindow::RedrawNonClient()
2064 {
2065     ::SetWindowPos(GetHWnd(), (HWND) NULL, 0, 0, 0, 0, SwpFrameChangeFlags|SWP_ASYNCWINDOWPOS);
2066 }
2067 
2068 int AwtWindow::GetScreenImOn() {
2069     HMONITOR hmon;
2070     int scrnNum;
2071 
2072     hmon = ::MonitorFromWindow(GetHWnd(), MONITOR_DEFAULTTOPRIMARY);
2073     DASSERT(hmon != NULL);
2074 
2075     scrnNum = AwtWin32GraphicsDevice::GetScreenFromHMONITOR(hmon);
2076     DASSERT(scrnNum > -1);
2077 
2078     return scrnNum;
2079 }
2080 
2081 /* Check to see if we've been moved onto another screen.
2082  * If so, update internal data, surfaces, etc.
2083  */
2084 
2085 void AwtWindow::CheckIfOnNewScreen() {
2086     int curScrn = GetScreenImOn();
2087 
2088     if (curScrn != m_screenNum) {  // we've been moved
2089         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2090 
2091         jclass peerCls = env->GetObjectClass(m_peerObject);
2092         DASSERT(peerCls);
2093         CHECK_NULL(peerCls);
2094 
2095         jmethodID draggedID = env->GetMethodID(peerCls, "draggedToNewScreen",
2096                                                "()V");
2097         DASSERT(draggedID);
2098         if (draggedID == NULL) {
2099             env->DeleteLocalRef(peerCls);
2100             return;
2101         }
2102 
2103         env->CallVoidMethod(m_peerObject, draggedID);
2104         m_screenNum = curScrn;
2105 
2106         env->DeleteLocalRef(peerCls);
2107     }
2108 }
2109 
2110 void AwtWindow::CheckWindowDPIChange() {
2111 
2112     if (prevScaleRec.screen != -1 ) {
2113         float prevScaleX = prevScaleRec.scaleX;
2114         float prevScaleY = prevScaleRec.scaleY;
2115 
2116         if (prevScaleX >= 1 && prevScaleY >= 1) {
2117             Devices::InstanceAccess devices;
2118             AwtWin32GraphicsDevice* device = devices->GetDevice(m_screenNum);
2119             if (device) {
2120                 float scaleX = device->GetScaleX();
2121                 float scaleY = device->GetScaleY();
2122                 if (prevScaleX != scaleX || prevScaleY != scaleY) {
2123                     WindowDPIChange(prevScaleRec.screen, prevScaleX, prevScaleY,
2124                                     m_screenNum, scaleX, scaleY);
2125                 }
2126             }
2127         }
2128         prevScaleRec.screen = -1;
2129     }
2130 }
2131 
2132 void AwtWindow::WindowDPIChange(int prevScreen,
2133                                 float prevScaleX, float prevScaleY,
2134                                 int screen, float scaleX,
2135                                 float scaleY)
2136 {
2137     int x;
2138     int y;
2139     int w;
2140     int h;
2141     RECT rect;
2142 
2143     if (prevScaleX == scaleX && prevScaleY == scaleY) {
2144         return;
2145     }
2146 
2147     ::GetWindowRect(GetHWnd(), &rect);
2148     x = rect.left;
2149     y = rect.top;
2150     w = (rect.right - rect.left) * scaleX / prevScaleX;
2151     h = (rect.bottom - rect.top) * scaleY / prevScaleY;
2152 
2153     if (prevScreen != screen) {
2154         Devices::InstanceAccess devices;
2155         AwtWin32GraphicsDevice* device = devices->GetDevice(screen);
2156         if (device) {
2157             RECT bounds;
2158             if (MonitorBounds(device->GetMonitor(), &bounds)) {
2159                 x = x < bounds.left ? bounds.left : x;
2160                 y = y < bounds.top ? bounds.top : y;
2161 
2162                 x = (x + w > bounds.right) ? bounds.right - w : x;
2163                 y = (y + h > bounds.bottom) ? bounds.bottom - h : y;
2164             }
2165         }
2166     }
2167 
2168     ReshapeNoScale(x, y, w, h);
2169 }
2170 
2171 BOOL AwtWindow::IsFocusableWindow() {
2172     /*
2173      * For Window/Frame/Dialog to accept focus it should:
2174      * - be focusable;
2175      * - be not blocked by any modal blocker.
2176      */
2177     BOOL focusable = m_isFocusableWindow && !::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()));
2178     AwtFrame *owner = GetOwningFrameOrDialog(); // NULL for Frame and Dialog
2179 
2180     if (owner != NULL) {
2181         /*
2182          * Also for Window (not Frame/Dialog) to accept focus:
2183          * - its decorated parent should accept focus;
2184          */
2185         focusable = focusable && owner->IsFocusableWindow();
2186     }
2187     return focusable;
2188 }
2189 
2190 void AwtWindow::SetModalBlocker(HWND window, HWND blocker) {
2191     if (!::IsWindow(window)) {
2192         return;
2193     }
2194 
2195     if (::IsWindow(blocker)) {
2196         ::SetProp(window, ModalBlockerProp, reinterpret_cast<HANDLE>(blocker));
2197         ::EnableWindow(window, FALSE);
2198     } else {
2199         ::RemoveProp(window, ModalBlockerProp);
2200          AwtComponent *comp = AwtComponent::GetComponent(window);
2201          // we don't expect to be called with non-java HWNDs
2202          DASSERT(comp && comp->IsTopLevel());
2203          // we should not unblock disabled toplevels
2204          ::EnableWindow(window, comp->isEnabled());
2205     }
2206 }
2207 
2208 void AwtWindow::SetAndActivateModalBlocker(HWND window, HWND blocker) {
2209     if (!::IsWindow(window)) {
2210         return;
2211     }
2212     AwtWindow::SetModalBlocker(window, blocker);
2213     if (::IsWindow(blocker)) {
2214         // We must check for visibility. Otherwise invisible dialog will receive WM_ACTIVATE.
2215         if (::IsWindowVisible(blocker)) {
2216             ::BringWindowToTop(blocker);
2217             ::SetForegroundWindow(blocker);
2218         }
2219     }
2220 }
2221 
2222 HWND AwtWindow::GetTopmostModalBlocker(HWND window)
2223 {
2224     HWND ret, blocker = NULL;
2225 
2226     do {
2227         ret = blocker;
2228         blocker = AwtWindow::GetModalBlocker(window);
2229         window = blocker;
2230     } while (::IsWindow(blocker));
2231 
2232     return ret;
2233 }
2234 
2235 void AwtWindow::FlashWindowEx(HWND hWnd, UINT count, DWORD timeout, DWORD flags) {
2236     FLASHWINFO fi;
2237     fi.cbSize = sizeof(fi);
2238     fi.hwnd = hWnd;
2239     fi.dwFlags = flags;
2240     fi.uCount = count;
2241     fi.dwTimeout = timeout;
2242     ::FlashWindowEx(&fi);
2243 }
2244 
2245 jboolean
2246 AwtWindow::_RequestWindowFocus(void *param)
2247 {
2248     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2249 
2250     RequestWindowFocusStruct *rfs = (RequestWindowFocusStruct *)param;
2251     jobject self = rfs->component;
2252     jboolean isMouseEventCause = rfs->isMouseEventCause;
2253 
2254     jboolean result = JNI_FALSE;
2255     AwtWindow *window = NULL;
2256 
2257     PDATA pData;
2258     JNI_CHECK_NULL_GOTO(self, "peer", ret);
2259     pData = JNI_GET_PDATA(self);
2260     if (pData == NULL) {
2261         // do nothing just return false
2262         goto ret;
2263     }
2264 
2265     window = (AwtWindow *)pData;
2266     if (::IsWindow(window->GetHWnd())) {
2267         result = (jboolean)window->SendMessage(WM_AWT_WINDOW_SETACTIVE, (WPARAM)isMouseEventCause, 0);
2268     }
2269 ret:
2270     env->DeleteGlobalRef(self);
2271 
2272     delete rfs;
2273 
2274     return result;
2275 }
2276 
2277 void AwtWindow::_ToFront(void *param)
2278 {
2279     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2280 
2281     jobject self = (jobject)param;
2282 
2283     AwtWindow *w = NULL;
2284 
2285     PDATA pData;
2286     JNI_CHECK_PEER_GOTO(self, ret);
2287     w = (AwtWindow *)pData;
2288     if (::IsWindow(w->GetHWnd()))
2289     {
2290         UINT flags = SWP_NOMOVE|SWP_NOSIZE;
2291         BOOL focusable = w->IsFocusableWindow();
2292         BOOL autoRequestFocus = w->IsAutoRequestFocus();
2293 
2294         if (!focusable || !autoRequestFocus)
2295         {
2296             flags = flags|SWP_NOACTIVATE;
2297         }
2298         ::SetWindowPos(w->GetHWnd(), HWND_TOP, 0, 0, 0, 0, flags);
2299         if (focusable && autoRequestFocus)
2300         {
2301             ::SetForegroundWindow(w->GetHWnd());
2302         }
2303     }
2304 ret:
2305     env->DeleteGlobalRef(self);
2306 }
2307 
2308 void AwtWindow::_ToBack(void *param)
2309 {
2310     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2311 
2312     jobject self = (jobject)param;
2313 
2314     AwtWindow *w = NULL;
2315 
2316     PDATA pData;
2317     JNI_CHECK_PEER_GOTO(self, ret);
2318     w = (AwtWindow *)pData;
2319     if (::IsWindow(w->GetHWnd()))
2320     {
2321         HWND hwnd = w->GetHWnd();
2322 //        if (AwtComponent::GetComponent(hwnd) == NULL) {
2323 //            // Window was disposed. Don't bother.
2324 //            return;
2325 //        }
2326 
2327         ::SetWindowPos(hwnd, HWND_BOTTOM, 0, 0 ,0, 0,
2328             SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
2329 
2330         // If hwnd is the foreground window or if *any* of its owners are, then
2331         // we have to reset the foreground window. The reason is that when we send
2332         // hwnd to back, all of its owners are sent to back as well. If any one of
2333         // them is the foreground window, then it's possible that we could end up
2334         // with a foreground window behind a window of another application.
2335         HWND foregroundWindow = ::GetForegroundWindow();
2336         BOOL adjustForegroundWindow;
2337         HWND toTest = hwnd;
2338         do
2339         {
2340             adjustForegroundWindow = (toTest == foregroundWindow);
2341             if (adjustForegroundWindow)
2342             {
2343                 break;
2344             }
2345             toTest = ::GetWindow(toTest, GW_OWNER);
2346         }
2347         while (toTest != NULL);
2348 
2349         if (adjustForegroundWindow)
2350         {
2351             HWND foregroundSearch = hwnd, newForegroundWindow = NULL;
2352                 while (1)
2353                 {
2354                 foregroundSearch = ::GetNextWindow(foregroundSearch, GW_HWNDPREV);
2355                 if (foregroundSearch == NULL)
2356                 {
2357                     break;
2358                 }
2359                 LONG style = static_cast<LONG>(::GetWindowLongPtr(foregroundSearch, GWL_STYLE));
2360                 if ((style & WS_CHILD) || !(style & WS_VISIBLE))
2361                 {
2362                     continue;
2363                 }
2364 
2365                 AwtComponent *c = AwtComponent::GetComponent(foregroundSearch);
2366                 if ((c != NULL) && !::IsWindow(AwtWindow::GetModalBlocker(c->GetHWnd())))
2367                 {
2368                     newForegroundWindow = foregroundSearch;
2369                 }
2370             }
2371             if (newForegroundWindow != NULL)
2372             {
2373                 ::SetWindowPos(newForegroundWindow, HWND_TOP, 0, 0, 0, 0,
2374                     SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
2375                 if (((AwtWindow*)AwtComponent::GetComponent(newForegroundWindow))->IsFocusableWindow())
2376                 {
2377                     ::SetForegroundWindow(newForegroundWindow);
2378                 }
2379             }
2380             else
2381             {
2382                 // We *have* to set the active HWND to something new. We simply
2383                 // cannot risk having an active Java HWND which is behind an HWND
2384                 // of a native application. This really violates the Windows user
2385                 // experience.
2386                 //
2387                 // Windows won't allow us to set the foreground window to NULL,
2388                 // so we use the desktop window instead. To the user, it appears
2389                 // that there is no foreground window system-wide.
2390                 ::SetForegroundWindow(::GetDesktopWindow());
2391             }
2392         }
2393     }
2394 ret:
2395     env->DeleteGlobalRef(self);
2396 }
2397 
2398 void AwtWindow::_SetAlwaysOnTop(void *param)
2399 {
2400     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2401 
2402     SetAlwaysOnTopStruct *sas = (SetAlwaysOnTopStruct *)param;
2403     jobject self = sas->window;
2404     jboolean value = sas->value;
2405 
2406     AwtWindow *w = NULL;
2407 
2408     PDATA pData;
2409     JNI_CHECK_PEER_GOTO(self, ret);
2410     w = (AwtWindow *)pData;
2411     if (::IsWindow(w->GetHWnd()))
2412     {
2413         w->SendMessage(WM_AWT_SETALWAYSONTOP, (WPARAM)value, (LPARAM)w);
2414         w->m_alwaysOnTop = (bool)value;
2415     }
2416 ret:
2417     env->DeleteGlobalRef(self);
2418 
2419     delete sas;
2420 }
2421 
2422 void AwtWindow::_SetTitle(void *param)
2423 {
2424     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2425 
2426     SetTitleStruct *sts = (SetTitleStruct *)param;
2427     jobject self = sts->window;
2428     jstring title = sts->title;
2429 
2430     AwtWindow *w = NULL;
2431 
2432     PDATA pData;
2433     JNI_CHECK_PEER_GOTO(self, ret);
2434     JNI_CHECK_NULL_GOTO(title, "null title", ret);
2435 
2436     w = (AwtWindow *)pData;
2437     if (::IsWindow(w->GetHWnd()))
2438     {
2439         int length = env->GetStringLength(title);
2440         TCHAR *buffer = new TCHAR[length + 1];
2441         env->GetStringRegion(title, 0, length, reinterpret_cast<jchar*>(buffer));
2442         buffer[length] = L'\0';
2443         VERIFY(::SetWindowText(w->GetHWnd(), buffer));
2444         delete[] buffer;
2445     }
2446 ret:
2447     env->DeleteGlobalRef(self);
2448     if (title != NULL) {
2449         env->DeleteGlobalRef(title);
2450     }
2451 
2452     delete sts;
2453 }
2454 
2455 void AwtWindow::_SetResizable(void *param)
2456 {
2457     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2458 
2459     SetResizableStruct *srs = (SetResizableStruct *)param;
2460     jobject self = srs->window;
2461     jboolean resizable = srs->resizable;
2462 
2463     AwtWindow *w = NULL;
2464 
2465     PDATA pData;
2466     JNI_CHECK_PEER_GOTO(self, ret);
2467     w = (AwtWindow *)pData;
2468     if (::IsWindow(w->GetHWnd()))
2469     {
2470         DASSERT(!IsBadReadPtr(w, sizeof(AwtWindow)));
2471         w->SetResizable(resizable != 0);
2472     }
2473 ret:
2474     env->DeleteGlobalRef(self);
2475 
2476     delete srs;
2477 }
2478 
2479 void AwtWindow::_UpdateInsets(void *param)
2480 {
2481     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2482 
2483     UpdateInsetsStruct *uis = (UpdateInsetsStruct *)param;
2484     jobject self = uis->window;
2485     jobject insets = uis->insets;
2486 
2487     AwtWindow *w = NULL;
2488 
2489     PDATA pData;
2490     JNI_CHECK_PEER_GOTO(self, ret);
2491     JNI_CHECK_NULL_GOTO(insets, "null insets", ret);
2492     w = (AwtWindow *)pData;
2493     if (::IsWindow(w->GetHWnd()))
2494     {
2495         w->UpdateInsets(insets);
2496     }
2497 ret:
2498     env->DeleteGlobalRef(self);
2499     env->DeleteGlobalRef(insets);
2500 
2501     delete uis;
2502 }
2503 
2504 void AwtWindow::_ReshapeFrame(void *param)
2505 {
2506     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2507 
2508     ReshapeFrameStruct *rfs = (ReshapeFrameStruct *)param;
2509     jobject self = rfs->frame;
2510     jint x = rfs->x;
2511     jint y = rfs->y;
2512     jint w = rfs->w;
2513     jint h = rfs->h;
2514 
2515     if (env->EnsureLocalCapacity(1) < 0)
2516     {
2517         env->DeleteGlobalRef(self);
2518         delete rfs;
2519         return;
2520     }
2521 
2522     AwtFrame *p = NULL;
2523 
2524     PDATA pData;
2525     JNI_CHECK_PEER_GOTO(self, ret);
2526     p = (AwtFrame *)pData;
2527     if (::IsWindow(p->GetHWnd()))
2528     {
2529         jobject target = env->GetObjectField(self, AwtObject::targetID);
2530         if (target != NULL)
2531         {
2532             // enforce tresholds before sending the event
2533             // Fix for 4459064 : do not enforce thresholds for embedded frames
2534             if (!p->IsEmbeddedFrame())
2535             {
2536                 jobject peer = p->GetPeer(env);
2537                 int minWidth = ::GetSystemMetrics(SM_CXMIN);
2538                 int minHeight = ::GetSystemMetrics(SM_CYMIN);
2539                 if (w < minWidth)
2540                 {
2541                     env->SetIntField(target, AwtComponent::widthID,
2542                         w = minWidth);
2543                     env->SetIntField(peer, AwtWindow::sysWID,
2544                         w);
2545                 }
2546                 if (h < minHeight)
2547                 {
2548                     env->SetIntField(target, AwtComponent::heightID,
2549                         h = minHeight);
2550                     env->SetIntField(peer, AwtWindow::sysHID,
2551                         h);
2552                 }
2553             }
2554             env->DeleteLocalRef(target);
2555 
2556             RECT *r = new RECT;
2557             ::SetRect(r, x, y, x + w, y + h);
2558             p->SendMessage(WM_AWT_RESHAPE_COMPONENT, 0, (LPARAM)r);
2559             // r is deleted in message handler
2560 
2561             // After the input method window shown, the dimension & position may not
2562             // be valid until this method is called. So we need to adjust the
2563             // IME candidate window position for the same reason as commented on
2564             // awt_Frame.cpp Show() method.
2565             if (p->isInputMethodWindow() && ::IsWindowVisible(p->GetHWnd())) {
2566               p->AdjustCandidateWindowPos();
2567             }
2568         }
2569         else
2570         {
2571             JNU_ThrowNullPointerException(env, "null target");
2572         }
2573     }
2574 ret:
2575    env->DeleteGlobalRef(self);
2576 
2577    delete rfs;
2578 }
2579 
2580 void AwtWindow::_OverrideHandle(void *param)
2581 {
2582     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2583 
2584     OverrideHandle* oh = (OverrideHandle *) param;
2585     jobject self = oh->frame;
2586     AwtWindow *f = NULL;
2587 
2588     PDATA pData;
2589     JNI_CHECK_PEER_GOTO(self, ret);
2590     f = (AwtWindow *)pData;
2591     f->OverrideHWnd(oh->handle);
2592 ret:
2593     env->DeleteGlobalRef(self);
2594 
2595     delete oh;
2596 }
2597 
2598 /*
2599  * This is AwtWindow-specific function that is not intended for reusing
2600  */
2601 HICON CreateIconFromRaster(JNIEnv* env, jintArray iconRaster, jint w, jint h)
2602 {
2603     HBITMAP mask = NULL;
2604     HBITMAP image = NULL;
2605     HICON icon = NULL;
2606     if (iconRaster != NULL) {
2607         int* iconRasterBuffer = NULL;
2608         try {
2609             iconRasterBuffer = (int *)env->GetPrimitiveArrayCritical(iconRaster, 0);
2610 
2611             JNI_CHECK_NULL_GOTO(iconRasterBuffer, "iconRaster data", done);
2612 
2613             mask = BitmapUtil::CreateTransparencyMaskFromARGB(w, h, iconRasterBuffer);
2614             image = BitmapUtil::CreateV4BitmapFromARGB(w, h, iconRasterBuffer);
2615         } catch (...) {
2616             if (iconRasterBuffer != NULL) {
2617                 env->ReleasePrimitiveArrayCritical(iconRaster, iconRasterBuffer, 0);
2618             }
2619             throw;
2620         }
2621         if (iconRasterBuffer != NULL) {
2622             env->ReleasePrimitiveArrayCritical(iconRaster, iconRasterBuffer, 0);
2623         }
2624     }
2625     if (mask && image) {
2626         ICONINFO icnInfo;
2627         memset(&icnInfo, 0, sizeof(ICONINFO));
2628         icnInfo.hbmMask = mask;
2629         icnInfo.hbmColor = image;
2630         icnInfo.fIcon = TRUE;
2631         icon = ::CreateIconIndirect(&icnInfo);
2632     }
2633     if (image) {
2634         destroy_BMP(image);
2635     }
2636     if (mask) {
2637         destroy_BMP(mask);
2638     }
2639 done:
2640     return icon;
2641 }
2642 
2643 void AwtWindow::SetIconData(JNIEnv* env, jintArray iconRaster, jint w, jint h,
2644                              jintArray smallIconRaster, jint smw, jint smh)
2645 {
2646     HICON hOldIcon = NULL;
2647     HICON hOldIconSm = NULL;
2648     //Destroy previous icon if it isn't inherited
2649     if ((m_hIcon != NULL) && !m_iconInherited) {
2650         hOldIcon = m_hIcon;
2651     }
2652     m_hIcon = NULL;
2653     if ((m_hIconSm != NULL) && !m_iconInherited) {
2654         hOldIconSm = m_hIconSm;
2655     }
2656     m_hIconSm = NULL;
2657     m_hIcon = CreateIconFromRaster(env, iconRaster, w, h);
2658     JNU_CHECK_EXCEPTION(env);
2659     m_hIconSm = CreateIconFromRaster(env, smallIconRaster, smw, smh);
2660 
2661     m_iconInherited = (m_hIcon == NULL);
2662     if (m_iconInherited) {
2663         HWND hOwner = ::GetWindow(GetHWnd(), GW_OWNER);
2664         AwtWindow* owner = (AwtWindow *)AwtComponent::GetComponent(hOwner);
2665         if (owner != NULL) {
2666             m_hIcon = owner->GetHIcon();
2667             m_hIconSm = owner->GetHIconSm();
2668         } else {
2669             m_iconInherited = FALSE;
2670         }
2671     }
2672     DoUpdateIcon();
2673     EnumThreadWindows(AwtToolkit::MainThread(), UpdateOwnedIconCallback, (LPARAM)this);
2674     if (hOldIcon != NULL) {
2675         DestroyIcon(hOldIcon);
2676     }
2677     if (hOldIconSm != NULL) {
2678         DestroyIcon(hOldIconSm);
2679     }
2680 }
2681 
2682 BOOL AwtWindow::UpdateOwnedIconCallback(HWND hWndOwned, LPARAM lParam)
2683 {
2684     HWND hWndOwner = ::GetWindow(hWndOwned, GW_OWNER);
2685     AwtWindow* owner = (AwtWindow*)lParam;
2686     if (hWndOwner == owner->GetHWnd()) {
2687         AwtComponent* comp = AwtComponent::GetComponent(hWndOwned);
2688         if (comp != NULL && comp->IsTopLevel()) {
2689             AwtWindow* owned = (AwtWindow *)comp;
2690             if (owned->m_iconInherited) {
2691                 owned->m_hIcon = owner->m_hIcon;
2692                 owned->m_hIconSm = owner->m_hIconSm;
2693                 owned->DoUpdateIcon();
2694                 EnumThreadWindows(AwtToolkit::MainThread(), UpdateOwnedIconCallback, (LPARAM)owned);
2695             }
2696         }
2697     }
2698     return TRUE;
2699 }
2700 
2701 void AwtWindow::DoUpdateIcon()
2702 {
2703     //Does nothing for windows, is overriden for frames and dialogs
2704 }
2705 
2706 void AwtWindow::RedrawWindow()
2707 {
2708     if (isOpaque()) {
2709         ::RedrawWindow(GetHWnd(), NULL, NULL,
2710                 RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
2711     } else {
2712         ::EnterCriticalSection(&contentBitmapCS);
2713         if (hContentBitmap != NULL) {
2714             UpdateWindowImpl(contentWidth, contentHeight, hContentBitmap);
2715         }
2716         ::LeaveCriticalSection(&contentBitmapCS);
2717     }
2718 }
2719 
2720 // Deletes the hContentBitmap if it is non-null
2721 void AwtWindow::DeleteContentBitmap()
2722 {
2723     ::EnterCriticalSection(&contentBitmapCS);
2724     if (hContentBitmap != NULL) {
2725         ::DeleteObject(hContentBitmap);
2726         hContentBitmap = NULL;
2727     }
2728     ::LeaveCriticalSection(&contentBitmapCS);
2729 }
2730 
2731 // The effects are enabled only upon showing the window.
2732 // See 6780496 for details.
2733 void AwtWindow::EnableTranslucency(BOOL enable)
2734 {
2735     if (enable) {
2736         SetTranslucency(getOpacity(), isOpaque(), FALSE, TRUE);
2737     } else {
2738         SetTranslucency(0xFF, TRUE, FALSE);
2739     }
2740 }
2741 
2742 /**
2743  * Sets the translucency effects.
2744  *
2745  * This method is used to:
2746  *
2747  * 1. Apply the translucency effects upon showing the window
2748  *    (setValues == FALSE, useDefaultForOldValues == TRUE);
2749  * 2. Turn off the effects upon hiding the window
2750  *    (setValues == FALSE, useDefaultForOldValues == FALSE);
2751  * 3. Set the effects per user's request
2752  *    (setValues == TRUE, useDefaultForOldValues == FALSE);
2753  *
2754  * In case #3 the effects may or may not be applied immediately depending on
2755  * the current visibility status of the window.
2756  *
2757  * The setValues argument indicates if we need to preserve the passed values
2758  * in local fields for further use.
2759  * The useDefaultForOldValues argument indicates whether we should consider
2760  * the window as if it has not any effects applied at the moment.
2761  */
2762 void AwtWindow::SetTranslucency(BYTE opacity, BOOL opaque, BOOL setValues,
2763         BOOL useDefaultForOldValues)
2764 {
2765     BYTE old_opacity = useDefaultForOldValues ? 0xFF : getOpacity();
2766     BOOL old_opaque = useDefaultForOldValues ? TRUE : isOpaque();
2767 
2768     if (opacity == old_opacity && opaque == old_opaque) {
2769         return;
2770     }
2771 
2772     if (setValues) {
2773        m_opacity = opacity;
2774        m_opaque = opaque;
2775     }
2776 
2777     // If we're invisible and are storing the values, return
2778     // Otherwise, apply the effects immediately
2779     if (!IsVisible() && setValues) {
2780         return;
2781     }
2782 
2783     HWND hwnd = GetHWnd();
2784 
2785     if (opaque != old_opaque) {
2786         DeleteContentBitmap();
2787     }
2788 
2789     if (opaque && opacity == 0xff) {
2790         // Turn off all the effects
2791         AwtWindow::SetLayered(hwnd, false);
2792 
2793         // Ask the window to repaint itself and all the children
2794         RedrawWindow();
2795     } else {
2796         // We're going to enable some effects
2797         if (!AwtWindow::IsLayered(hwnd)) {
2798             AwtWindow::SetLayered(hwnd, true);
2799         } else {
2800             if ((opaque && opacity < 0xff) ^ (old_opaque && old_opacity < 0xff)) {
2801                 // _One_ of the modes uses the SetLayeredWindowAttributes.
2802                 // Need to reset the style in this case.
2803                 // If both modes are simple (i.e. just changing the opacity level),
2804                 // no need to reset the style.
2805                 AwtWindow::SetLayered(hwnd, false);
2806                 AwtWindow::SetLayered(hwnd, true);
2807             }
2808         }
2809 
2810         if (opaque) {
2811             // Simple opacity mode
2812             ::SetLayeredWindowAttributes(hwnd, RGB(0, 0, 0), opacity, LWA_ALPHA);
2813         }
2814     }
2815 }
2816 
2817 static HBITMAP CreateBitmapFromRaster(JNIEnv* env, jintArray raster, jint w, jint h)
2818 {
2819     HBITMAP image = NULL;
2820     if (raster != NULL) {
2821         int* rasterBuffer = NULL;
2822         try {
2823             rasterBuffer = (int *)env->GetPrimitiveArrayCritical(raster, 0);
2824             JNI_CHECK_NULL_GOTO(rasterBuffer, "raster data", done);
2825             image = BitmapUtil::CreateBitmapFromARGBPre(w, h, w*4, rasterBuffer);
2826         } catch (...) {
2827             if (rasterBuffer != NULL) {
2828                 env->ReleasePrimitiveArrayCritical(raster, rasterBuffer, 0);
2829             }
2830             throw;
2831         }
2832         if (rasterBuffer != NULL) {
2833             env->ReleasePrimitiveArrayCritical(raster, rasterBuffer, 0);
2834         }
2835     }
2836 done:
2837     return image;
2838 }
2839 
2840 void AwtWindow::UpdateWindowImpl(int width, int height, HBITMAP hBitmap)
2841 {
2842     if (isOpaque()) {
2843         return;
2844     }
2845 
2846     HWND hWnd = GetHWnd();
2847     HDC hdcDst = ::GetDC(NULL);
2848     HDC hdcSrc = ::CreateCompatibleDC(NULL);
2849     HBITMAP hOldBitmap = (HBITMAP)::SelectObject(hdcSrc, hBitmap);
2850 
2851     //XXX: this code doesn't paint the children (say, the java.awt.Button)!
2852     //So, if we ever want to support HWs here, we need to repaint them
2853     //in some other way...
2854     //::SendMessage(hWnd, WM_PRINT, (WPARAM)hdcSrc, /*PRF_CHECKVISIBLE |*/
2855     //      PRF_CHILDREN /*| PRF_CLIENT | PRF_NONCLIENT*/);
2856 
2857     POINT ptSrc;
2858     ptSrc.x = ptSrc.y = 0;
2859 
2860     RECT rect;
2861     POINT ptDst;
2862     SIZE size;
2863 
2864     ::GetWindowRect(hWnd, &rect);
2865     ptDst.x = rect.left;
2866     ptDst.y = rect.top;
2867     size.cx = width;
2868     size.cy = height;
2869 
2870     BLENDFUNCTION bf;
2871 
2872     bf.SourceConstantAlpha = getOpacity();
2873     bf.AlphaFormat = AC_SRC_ALPHA;
2874     bf.BlendOp = AC_SRC_OVER;
2875     bf.BlendFlags = 0;
2876 
2877     ::UpdateLayeredWindow(hWnd, hdcDst, &ptDst, &size, hdcSrc, &ptSrc,
2878             RGB(0, 0, 0), &bf, ULW_ALPHA);
2879 
2880     ::ReleaseDC(NULL, hdcDst);
2881     ::SelectObject(hdcSrc, hOldBitmap);
2882     ::DeleteDC(hdcSrc);
2883 }
2884 
2885 void AwtWindow::UpdateWindow(JNIEnv* env, jintArray data, int width, int height,
2886                              HBITMAP hNewBitmap)
2887 {
2888     if (isOpaque()) {
2889         return;
2890     }
2891 
2892     HBITMAP hBitmap;
2893     if (hNewBitmap == NULL) {
2894         if (data == NULL) {
2895             return;
2896         }
2897         hBitmap = CreateBitmapFromRaster(env, data, width, height);
2898         if (hBitmap == NULL) {
2899             return;
2900         }
2901     } else {
2902         hBitmap = hNewBitmap;
2903     }
2904 
2905     ::EnterCriticalSection(&contentBitmapCS);
2906     DeleteContentBitmap();
2907     hContentBitmap = hBitmap;
2908     contentWidth = width;
2909     contentHeight = height;
2910     UpdateWindowImpl(width, height, hBitmap);
2911     ::LeaveCriticalSection(&contentBitmapCS);
2912 }
2913 
2914 /*
2915  * Fixed 6353381: it's improved fix for 4792958
2916  * which was backed-out to avoid 5059656
2917  */
2918 BOOL AwtWindow::HasValidRect()
2919 {
2920     RECT inside;
2921     RECT outside;
2922 
2923     if (::IsIconic(GetHWnd())) {
2924         return FALSE;
2925     }
2926 
2927     ::GetClientRect(GetHWnd(), &inside);
2928     ::GetWindowRect(GetHWnd(), &outside);
2929 
2930     BOOL isZeroClientArea = (inside.right == 0 && inside.bottom == 0);
2931     BOOL isInvalidLocation = ((outside.left == -32000 && outside.top == -32000) || // Win2k && WinXP
2932                               (outside.left == 32000 && outside.top == 32000) || // Win95 && Win98
2933                               (outside.left == 3000 && outside.top == 3000)); // Win95 && Win98
2934 
2935     // the bounds correspond to iconic state
2936     if (isZeroClientArea && isInvalidLocation)
2937     {
2938         return FALSE;
2939     }
2940 
2941     return TRUE;
2942 }
2943 
2944 
2945 void AwtWindow::_SetIconImagesData(void * param)
2946 {
2947     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2948 
2949     SetIconImagesDataStruct* s = (SetIconImagesDataStruct*)param;
2950     jobject self = s->window;
2951 
2952     jintArray iconRaster = s->iconRaster;
2953     jintArray smallIconRaster = s->smallIconRaster;
2954 
2955     AwtWindow *window = NULL;
2956 
2957     PDATA pData;
2958     JNI_CHECK_PEER_GOTO(self, ret);
2959     // ok to pass null raster: default AWT icon
2960 
2961     window = (AwtWindow*)pData;
2962     if (::IsWindow(window->GetHWnd()))
2963     {
2964         window->SetIconData(env, iconRaster, s->w, s->h, smallIconRaster, s->smw, s->smh);
2965 
2966     }
2967 
2968 ret:
2969     env->DeleteGlobalRef(self);
2970     env->DeleteGlobalRef(iconRaster);
2971     env->DeleteGlobalRef(smallIconRaster);
2972     delete s;
2973 }
2974 
2975 void AwtWindow::_SetMinSize(void* param)
2976 {
2977     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2978 
2979     SizeStruct *ss = (SizeStruct *)param;
2980     jobject self = ss->window;
2981     jint w = ss->w;
2982     jint h = ss->h;
2983     //Perform size setting
2984     AwtWindow *window = NULL;
2985 
2986     PDATA pData;
2987     JNI_CHECK_PEER_GOTO(self, ret);
2988     window = (AwtWindow *)pData;
2989     window->m_minSize.x = w;
2990     window->m_minSize.y = h;
2991   ret:
2992     env->DeleteGlobalRef(self);
2993     delete ss;
2994 }
2995 
2996 jint AwtWindow::_GetScreenImOn(void *param)
2997 {
2998     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2999 
3000     jobject self = (jobject)param;
3001 
3002     // It's entirely possible that our native resources have been destroyed
3003     // before our java peer - if we're dispose()d, for instance.
3004     // Alert caller w/ IllegalComponentStateException.
3005     if (self == NULL) {
3006         JNU_ThrowByName(env, "java/awt/IllegalComponentStateException",
3007                         "Peer null in JNI");
3008         return 0;
3009     }
3010     PDATA pData = JNI_GET_PDATA(self);
3011     if (pData == NULL) {
3012         JNU_ThrowByName(env, "java/awt/IllegalComponentStateException",
3013                         "Native resources unavailable");
3014         env->DeleteGlobalRef(self);
3015         return 0;
3016     }
3017 
3018     jint result = 0;
3019     AwtWindow *w = (AwtWindow *)pData;
3020     if (::IsWindow(w->GetHWnd()))
3021     {
3022         result = (jint)w->GetScreenImOn();
3023     }
3024 
3025     env->DeleteGlobalRef(self);
3026 
3027     return result;
3028 }
3029 
3030 void AwtWindow::_SetFocusableWindow(void *param)
3031 {
3032     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3033 
3034     SetFocusableWindowStruct *sfws = (SetFocusableWindowStruct *)param;
3035     jobject self = sfws->window;
3036     jboolean isFocusableWindow = sfws->isFocusableWindow;
3037 
3038     AwtWindow *window = NULL;
3039 
3040     PDATA pData;
3041     JNI_CHECK_PEER_GOTO(self, ret);
3042     window = (AwtWindow *)pData;
3043 
3044     window->m_isFocusableWindow = isFocusableWindow;
3045 
3046     // A simple window is permanently set to WS_EX_NOACTIVATE
3047     if (!window->IsSimpleWindow()) {
3048         if (!window->m_isFocusableWindow) {
3049             LONG isPopup = window->GetStyle() & WS_POPUP;
3050             window->SetStyleEx(window->GetStyleEx() | (isPopup ? 0 : WS_EX_APPWINDOW) | WS_EX_NOACTIVATE);
3051         } else {
3052             window->SetStyleEx(window->GetStyleEx() & ~WS_EX_APPWINDOW & ~WS_EX_NOACTIVATE);
3053         }
3054     }
3055 
3056   ret:
3057     env->DeleteGlobalRef(self);
3058     delete sfws;
3059 }
3060 
3061 void AwtWindow::_ModalDisable(void *param)
3062 {
3063     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3064 
3065     ModalDisableStruct *mds = (ModalDisableStruct *)param;
3066     jobject self = mds->window;
3067     HWND blockerHWnd = (HWND)mds->blockerHWnd;
3068 
3069     AwtWindow *window = NULL;
3070     HWND windowHWnd = 0;
3071 
3072     JNI_CHECK_NULL_GOTO(self, "peer", ret);
3073     PDATA pData = JNI_GET_PDATA(self);
3074     if (pData == NULL) {
3075         env->DeleteGlobalRef(self);
3076         delete mds;
3077         return;
3078     }
3079 
3080     window = (AwtWindow *)pData;
3081     windowHWnd = window->GetHWnd();
3082     if (::IsWindow(windowHWnd)) {
3083         AwtWindow::SetAndActivateModalBlocker(windowHWnd, blockerHWnd);
3084     }
3085 
3086 ret:
3087     env->DeleteGlobalRef(self);
3088 
3089     delete mds;
3090 }
3091 
3092 void AwtWindow::_ModalEnable(void *param)
3093 {
3094     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3095 
3096     jobject self = (jobject)param;
3097 
3098     AwtWindow *window = NULL;
3099     HWND windowHWnd = 0;
3100 
3101     JNI_CHECK_NULL_GOTO(self, "peer", ret);
3102     PDATA pData = JNI_GET_PDATA(self);
3103     if (pData == NULL) {
3104         env->DeleteGlobalRef(self);
3105         return;
3106     }
3107 
3108     window = (AwtWindow *)pData;
3109     windowHWnd = window->GetHWnd();
3110     if (::IsWindow(windowHWnd)) {
3111         AwtWindow::SetModalBlocker(windowHWnd, NULL);
3112     }
3113 
3114   ret:
3115     env->DeleteGlobalRef(self);
3116 }
3117 
3118 void AwtWindow::_SetOpacity(void* param)
3119 {
3120     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3121 
3122     OpacityStruct *os = (OpacityStruct *)param;
3123     jobject self = os->window;
3124     BYTE iOpacity = (BYTE)os->iOpacity;
3125 
3126     PDATA pData;
3127     JNI_CHECK_PEER_GOTO(self, ret);
3128     AwtWindow *window = (AwtWindow *)pData;
3129 
3130     window->SetTranslucency(iOpacity, window->isOpaque());
3131 
3132   ret:
3133     env->DeleteGlobalRef(self);
3134     delete os;
3135 }
3136 
3137 void AwtWindow::_SetOpaque(void* param)
3138 {
3139     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3140 
3141     OpaqueStruct *os = (OpaqueStruct *)param;
3142     jobject self = os->window;
3143     BOOL isOpaque = (BOOL)os->isOpaque;
3144 
3145     PDATA pData;
3146     JNI_CHECK_PEER_GOTO(self, ret);
3147     AwtWindow *window = (AwtWindow *)pData;
3148 
3149     window->SetTranslucency(window->getOpacity(), isOpaque);
3150 
3151   ret:
3152     env->DeleteGlobalRef(self);
3153     delete os;
3154 }
3155 
3156 void AwtWindow::_UpdateWindow(void* param)
3157 {
3158     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3159 
3160     UpdateWindowStruct *uws = (UpdateWindowStruct *)param;
3161     jobject self = uws->window;
3162     jintArray data = uws->data;
3163 
3164     PDATA pData;
3165     JNI_CHECK_PEER_GOTO(self, ret);
3166     AwtWindow *window = (AwtWindow *)pData;
3167 
3168     window->UpdateWindow(env, data, (int)uws->width, (int)uws->height,
3169                          uws->hBitmap);
3170 
3171   ret:
3172     env->DeleteGlobalRef(self);
3173     if (data != NULL) {
3174         env->DeleteGlobalRef(data);
3175     }
3176     delete uws;
3177 }
3178 
3179 void AwtWindow::_SetFullScreenExclusiveModeState(void *param)
3180 {
3181     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3182 
3183     SetFullScreenExclusiveModeStateStruct * data =
3184         (SetFullScreenExclusiveModeStateStruct*)param;
3185     jobject self = data->window;
3186     jboolean state = data->isFSEMState;
3187 
3188     PDATA pData;
3189     JNI_CHECK_PEER_GOTO(self, ret);
3190     AwtWindow *window = (AwtWindow *)pData;
3191 
3192     window->setFullScreenExclusiveModeState(state != 0);
3193 
3194   ret:
3195     env->DeleteGlobalRef(self);
3196     delete data;
3197 }
3198 
3199 void AwtWindow::_GetNativeWindowSize(void* param) {
3200 
3201     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3202 
3203     SizeStruct *ss = (SizeStruct *)param;
3204     jobject self = ss->window;
3205     AwtWindow *window = NULL;
3206     PDATA pData;
3207     JNI_CHECK_PEER_RETURN(self);
3208     window = (AwtWindow *)pData;
3209 
3210     RECT rc;
3211     ::GetWindowRect(window->GetHWnd(), &rc);
3212     ss->w = rc.right - rc.left;
3213     ss->h = rc.bottom - rc.top;
3214 
3215     env->DeleteGlobalRef(self);
3216 }
3217 
3218 void AwtWindow::_WindowDPIChange(void* param)
3219 {
3220     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3221 
3222     ScaleStruct *ss = (ScaleStruct *)param;
3223     jobject self = ss->window;
3224     jint prevScreen = ss->prevScreen;
3225     jfloat prevScaleX = ss->prevScaleX;
3226     jfloat prevScaleY = ss->prevScaleY;
3227     jint screen = ss->screen;
3228     jfloat scaleX = ss->scaleX;
3229     jfloat scaleY = ss->scaleY;
3230 
3231     PDATA pData;
3232     JNI_CHECK_PEER_GOTO(self, ret);
3233     AwtWindow *window = (AwtWindow *)pData;
3234 
3235     if (window->m_winSizeMove) {
3236         if (window->prevScaleRec.screen == -1) {
3237             window->prevScaleRec.screen = prevScreen;
3238             window->prevScaleRec.scaleX = prevScaleX;
3239             window->prevScaleRec.scaleY = prevScaleY;
3240         }
3241     }
3242     else {
3243         window->WindowDPIChange(prevScreen, prevScaleX, prevScaleY,
3244                                 screen, scaleX, scaleY);
3245     }
3246 
3247 ret:
3248     env->DeleteGlobalRef(self);
3249     delete ss;
3250 }
3251 
3252 extern "C" int getSystemMetricValue(int msgType);
3253 extern "C" {
3254 
3255 /*
3256  * Class:     java_awt_Window
3257  * Method:    initIDs
3258  * Signature: ()V
3259  */
3260 JNIEXPORT void JNICALL
3261 Java_java_awt_Window_initIDs(JNIEnv *env, jclass cls)
3262 {
3263     TRY;
3264 
3265     CHECK_NULL(AwtWindow::warningStringID =
3266         env->GetFieldID(cls, "warningString", "Ljava/lang/String;"));
3267     CHECK_NULL(AwtWindow::locationByPlatformID =
3268         env->GetFieldID(cls, "locationByPlatform", "Z"));
3269     CHECK_NULL(AwtWindow::securityWarningWidthID =
3270         env->GetFieldID(cls, "securityWarningWidth", "I"));
3271     CHECK_NULL(AwtWindow::securityWarningHeightID =
3272         env->GetFieldID(cls, "securityWarningHeight", "I"));
3273     CHECK_NULL(AwtWindow::getWarningStringMID =
3274         env->GetMethodID(cls, "getWarningString", "()Ljava/lang/String;"));
3275     CHECK_NULL(AwtWindow::autoRequestFocusID =
3276         env->GetFieldID(cls, "autoRequestFocus", "Z"));
3277     CHECK_NULL(AwtWindow::calculateSecurityWarningPositionMID =
3278         env->GetMethodID(cls, "calculateSecurityWarningPosition", "(DDDD)Ljava/awt/geom/Point2D;"));
3279 
3280     jclass windowTypeClass = env->FindClass("java/awt/Window$Type");
3281     CHECK_NULL(windowTypeClass);
3282     AwtWindow::windowTypeNameMID =
3283         env->GetMethodID(windowTypeClass, "name", "()Ljava/lang/String;");
3284     env->DeleteLocalRef(windowTypeClass);
3285 
3286     CATCH_BAD_ALLOC;
3287 }
3288 
3289 } /* extern "C" */
3290 
3291 
3292 /************************************************************************
3293  * WindowPeer native methods
3294  */
3295 
3296 extern "C" {
3297 
3298 /*
3299  * Class:     sun_awt_windows_WWindowPeer
3300  * Method:    initIDs
3301  * Signature: ()V
3302  */
3303 JNIEXPORT void JNICALL
3304 Java_sun_awt_windows_WWindowPeer_initIDs(JNIEnv *env, jclass cls)
3305 {
3306     TRY;
3307 
3308     CHECK_NULL(AwtWindow::sysXID = env->GetFieldID(cls, "sysX", "I"));
3309     CHECK_NULL(AwtWindow::sysYID = env->GetFieldID(cls, "sysY", "I"));
3310     CHECK_NULL(AwtWindow::sysWID = env->GetFieldID(cls, "sysW", "I"));
3311     CHECK_NULL(AwtWindow::sysHID = env->GetFieldID(cls, "sysH", "I"));
3312 
3313     AwtWindow::windowTypeID = env->GetFieldID(cls, "windowType",
3314             "Ljava/awt/Window$Type;");
3315 
3316     CATCH_BAD_ALLOC;
3317 }
3318 
3319 /*
3320  * Class:     sun_awt_windows_WWindowPeer
3321  * Method:    toFront
3322  * Signature: ()V
3323  */
3324 JNIEXPORT void JNICALL
3325 Java_sun_awt_windows_WWindowPeer__1toFront(JNIEnv *env, jobject self)
3326 {
3327     TRY;
3328 
3329     AwtToolkit::GetInstance().SyncCall(AwtWindow::_ToFront,
3330         env->NewGlobalRef(self));
3331     // global ref is deleted in _ToFront()
3332 
3333     CATCH_BAD_ALLOC;
3334 }
3335 
3336 /*
3337  * Class:     sun_awt_windows_WWindowPeer
3338  * Method:    toBack
3339  * Signature: ()V
3340  */
3341 JNIEXPORT void JNICALL
3342 Java_sun_awt_windows_WWindowPeer_toBack(JNIEnv *env, jobject self)
3343 {
3344     TRY;
3345 
3346     AwtToolkit::GetInstance().SyncCall(AwtWindow::_ToBack,
3347         env->NewGlobalRef(self));
3348     // global ref is deleted in _ToBack()
3349 
3350     CATCH_BAD_ALLOC;
3351 }
3352 
3353 /*
3354  * Class:     sun_awt_windows_WWindowPeer
3355  * Method:    setAlwaysOnTop
3356  * Signature: (Z)V
3357  */
3358 JNIEXPORT void JNICALL
3359 Java_sun_awt_windows_WWindowPeer_setAlwaysOnTopNative(JNIEnv *env, jobject self,
3360                                                 jboolean value)
3361 {
3362     TRY;
3363 
3364     SetAlwaysOnTopStruct *sas = new SetAlwaysOnTopStruct;
3365     sas->window = env->NewGlobalRef(self);
3366     sas->value = value;
3367 
3368     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetAlwaysOnTop, sas);
3369     // global ref and sas are deleted in _SetAlwaysOnTop
3370 
3371     CATCH_BAD_ALLOC;
3372 }
3373 
3374 /*
3375  * Class:     sun_awt_windows_WWindowPeer
3376  * Method:    _setTitle
3377  * Signature: (Ljava/lang/String;)V
3378  */
3379 JNIEXPORT void JNICALL
3380 Java_sun_awt_windows_WWindowPeer__1setTitle(JNIEnv *env, jobject self,
3381                                             jstring title)
3382 {
3383     TRY;
3384 
3385     SetTitleStruct *sts = new SetTitleStruct;
3386     sts->window = env->NewGlobalRef(self);
3387     sts->title = (jstring)env->NewGlobalRef(title);
3388 
3389     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetTitle, sts);
3390     /// global refs and sts are deleted in _SetTitle()
3391 
3392     CATCH_BAD_ALLOC;
3393 }
3394 
3395 /*
3396  * Class:     sun_awt_windows_WWindowPeer
3397  * Method:    _setResizable
3398  * Signature: (Z)V
3399  */
3400 JNIEXPORT void JNICALL
3401 Java_sun_awt_windows_WWindowPeer__1setResizable(JNIEnv *env, jobject self,
3402                                                 jboolean resizable)
3403 {
3404     TRY;
3405 
3406     SetResizableStruct *srs = new SetResizableStruct;
3407     srs->window = env->NewGlobalRef(self);
3408     srs->resizable = resizable;
3409 
3410     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetResizable, srs);
3411     // global ref and srs are deleted in _SetResizable
3412 
3413     CATCH_BAD_ALLOC;
3414 }
3415 
3416 /*
3417  * Class:     sun_awt_windows_WWindowPeer
3418  * Method:    create
3419  * Signature: (Lsun/awt/windows/WComponentPeer;)V
3420  */
3421 JNIEXPORT void JNICALL
3422 Java_sun_awt_windows_WWindowPeer_createAwtWindow(JNIEnv *env, jobject self,
3423                                                  jobject parent)
3424 {
3425     TRY;
3426 
3427     PDATA pData;
3428 //    JNI_CHECK_PEER_RETURN(parent);
3429     AwtToolkit::CreateComponent(self, parent,
3430                                 (AwtToolkit::ComponentFactory)
3431                                 AwtWindow::Create);
3432     JNI_CHECK_PEER_CREATION_RETURN(self);
3433 
3434     CATCH_BAD_ALLOC;
3435 }
3436 
3437 /*
3438  * Class:     sun_awt_windows_WWindowPeer
3439  * Method:    updateInsets
3440  * Signature: (Ljava/awt/Insets;)V
3441  */
3442 JNIEXPORT void JNICALL
3443 Java_sun_awt_windows_WWindowPeer_updateInsets(JNIEnv *env, jobject self,
3444                                               jobject insets)
3445 {
3446     TRY;
3447 
3448     UpdateInsetsStruct *uis = new UpdateInsetsStruct;
3449     uis->window = env->NewGlobalRef(self);
3450     uis->insets = env->NewGlobalRef(insets);
3451 
3452     AwtToolkit::GetInstance().SyncCall(AwtWindow::_UpdateInsets, uis);
3453     // global refs and uis are deleted in _UpdateInsets()
3454 
3455     CATCH_BAD_ALLOC;
3456 }
3457 
3458 /*
3459  * Class:     sun_awt_windows_WWindowPeer
3460  * Method:    reshapeFrame
3461  * Signature: (IIII)V
3462  */
3463 JNIEXPORT void JNICALL
3464 Java_sun_awt_windows_WWindowPeer_reshapeFrame(JNIEnv *env, jobject self,
3465                                         jint x, jint y, jint w, jint h)
3466 {
3467     TRY;
3468 
3469     ReshapeFrameStruct *rfs = new ReshapeFrameStruct;
3470     rfs->frame = env->NewGlobalRef(self);
3471     rfs->x = x;
3472     rfs->y = y;
3473     rfs->w = w;
3474     rfs->h = h;
3475 
3476     AwtToolkit::GetInstance().SyncCall(AwtWindow::_ReshapeFrame, rfs);
3477     // global ref and rfs are deleted in _ReshapeFrame()
3478 
3479     CATCH_BAD_ALLOC;
3480 }
3481 
3482 /*
3483  * Class:     sun_awt_windows_WWindowPeer
3484 * Method:    getNativeWindowSize
3485 * Signature: ()Ljava/awt/Dimension;
3486 */
3487 JNIEXPORT jobject JNICALL Java_sun_awt_windows_WWindowPeer_getNativeWindowSize
3488 (JNIEnv *env, jobject self) {
3489 
3490     jobject res = NULL;
3491     TRY;
3492     SizeStruct *ss = new SizeStruct;
3493     ss->window = env->NewGlobalRef(self);
3494 
3495     AwtToolkit::GetInstance().SyncCall(AwtWindow::_GetNativeWindowSize, ss);
3496 
3497     int w = ss->w;
3498     int h = ss->h;
3499 
3500     delete ss;
3501     // global ref is deleted in _GetNativeWindowSize()
3502 
3503     static jmethodID dimMID = NULL;
3504     static jclass dimClassID = NULL;
3505     if (dimClassID == NULL) {
3506         jclass dimClassIDLocal = env->FindClass("java/awt/Dimension");
3507         CHECK_NULL_RETURN(dimClassIDLocal, NULL);
3508         dimClassID = (jclass)env->NewGlobalRef(dimClassIDLocal);
3509         env->DeleteLocalRef(dimClassIDLocal);
3510     }
3511 
3512     if (dimMID == NULL) {
3513         dimMID = env->GetMethodID(dimClassID, "<init>", "(II)V");
3514         CHECK_NULL_RETURN(dimMID, NULL);
3515     }
3516 
3517     return env->NewObject(dimClassID, dimMID, w, h);
3518 
3519     CATCH_BAD_ALLOC_RET(NULL);
3520 }
3521 
3522 /*
3523  * Class:     sun_awt_windows_WWindowPeer
3524  * Method:    getSysMinWidth
3525  * Signature: ()I
3526  */
3527 JNIEXPORT jint JNICALL
3528 Java_sun_awt_windows_WWindowPeer_getSysMinWidth(JNIEnv *env, jclass self)
3529 {
3530     TRY;
3531 
3532     return ::GetSystemMetrics(SM_CXMIN);
3533 
3534     CATCH_BAD_ALLOC_RET(0);
3535 }
3536 
3537 /*
3538  * Class:     sun_awt_windows_WWindowPeer
3539  * Method:    getSysMinHeight
3540  * Signature: ()I
3541  */
3542 JNIEXPORT jint JNICALL
3543 Java_sun_awt_windows_WWindowPeer_getSysMinHeight(JNIEnv *env, jclass self)
3544 {
3545     TRY;
3546 
3547     return ::GetSystemMetrics(SM_CYMIN);
3548 
3549     CATCH_BAD_ALLOC_RET(0);
3550 }
3551 
3552 /*
3553  * Class:     sun_awt_windows_WWindowPeer
3554  * Method:    getSysIconHeight
3555  * Signature: ()I
3556  */
3557 JNIEXPORT jint JNICALL
3558 Java_sun_awt_windows_WWindowPeer_getSysIconHeight(JNIEnv *env, jclass self)
3559 {
3560     TRY;
3561 
3562     return getSystemMetricValue(SM_CYICON);
3563 
3564     CATCH_BAD_ALLOC_RET(0);
3565 }
3566 
3567 /*
3568  * Class:     sun_awt_windows_WWindowPeer
3569  * Method:    getSysIconWidth
3570  * Signature: ()I
3571  */
3572 JNIEXPORT jint JNICALL
3573 Java_sun_awt_windows_WWindowPeer_getSysIconWidth(JNIEnv *env, jclass self)
3574 {
3575     TRY;
3576 
3577     return getSystemMetricValue(SM_CXICON);
3578 
3579     CATCH_BAD_ALLOC_RET(0);
3580 }
3581 
3582 /*
3583  * Class:     sun_awt_windows_WWindowPeer
3584  * Method:    getSysSmIconHeight
3585  * Signature: ()I
3586  */
3587 JNIEXPORT jint JNICALL
3588 Java_sun_awt_windows_WWindowPeer_getSysSmIconHeight(JNIEnv *env, jclass self)
3589 {
3590     TRY;
3591 
3592     return getSystemMetricValue(SM_CYSMICON);
3593 
3594     CATCH_BAD_ALLOC_RET(0);
3595 }
3596 
3597 /*
3598  * Class:     sun_awt_windows_WWindowPeer
3599  * Method:    getSysSmIconWidth
3600  * Signature: ()I
3601  */
3602 JNIEXPORT jint JNICALL
3603 Java_sun_awt_windows_WWindowPeer_getSysSmIconWidth(JNIEnv *env, jclass self)
3604 {
3605     TRY;
3606 
3607     return getSystemMetricValue(SM_CXSMICON);
3608 
3609     CATCH_BAD_ALLOC_RET(0);
3610 }
3611 
3612 int getSystemMetricValue(int msgType) {
3613     int value = 1;
3614     int logPixels = LOGPIXELSX;
3615     switch (msgType) {
3616         case SM_CXICON:
3617             value = ::GetSystemMetrics(SM_CXICON);
3618             break;
3619         case SM_CYICON:
3620             value = ::GetSystemMetrics(SM_CYICON);
3621             logPixels = LOGPIXELSY;
3622             break;
3623         case SM_CXSMICON:
3624             value = ::GetSystemMetrics(SM_CXSMICON);
3625             break;
3626         case SM_CYSMICON:
3627             value = ::GetSystemMetrics(SM_CYSMICON);
3628             logPixels = LOGPIXELSY;
3629             break;
3630     }
3631     static int dpi = -1;
3632     if (dpi == -1) {
3633         HWND hWnd = ::GetDesktopWindow();
3634         HDC hDC = ::GetDC(hWnd);
3635         dpi = GetDeviceCaps(hDC, logPixels);
3636         ::ReleaseDC(hWnd, hDC);
3637     }
3638     if(dpi != 0 && dpi != 96) {
3639         float invScaleX = 96.0f / dpi;
3640         value = (int) ROUND_TO_INT(value * invScaleX);
3641     }
3642     return value;
3643 }
3644 
3645 /*
3646  * Class:     sun_awt_windows_WWindowPeer
3647  * Method:    setIconImagesData
3648  * Signature: ([I)V
3649  */
3650 JNIEXPORT void JNICALL
3651 Java_sun_awt_windows_WWindowPeer_setIconImagesData(JNIEnv *env, jobject self,
3652     jintArray iconRaster, jint w, jint h,
3653     jintArray smallIconRaster, jint smw, jint smh)
3654 {
3655     TRY;
3656 
3657     SetIconImagesDataStruct *sims = new SetIconImagesDataStruct;
3658 
3659     sims->window = env->NewGlobalRef(self);
3660     sims->iconRaster = (jintArray)env->NewGlobalRef(iconRaster);
3661     sims->w = w;
3662     sims->h = h;
3663     sims->smallIconRaster = (jintArray)env->NewGlobalRef(smallIconRaster);
3664     sims->smw = smw;
3665     sims->smh = smh;
3666 
3667     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetIconImagesData, sims);
3668     // global refs and sims are deleted in _SetIconImagesData()
3669 
3670     CATCH_BAD_ALLOC;
3671 }
3672 
3673 /*
3674  * Class:     sun_awt_windows_WWindowPeer
3675  * Method:    setMinSize
3676  * Signature: (Lsun/awt/windows/WWindowPeer;)V
3677  */
3678 JNIEXPORT void JNICALL
3679 Java_sun_awt_windows_WWindowPeer_setMinSize(JNIEnv *env, jobject self,
3680                                               jint w, jint h)
3681 {
3682     TRY;
3683 
3684     SizeStruct *ss = new SizeStruct;
3685     ss->window = env->NewGlobalRef(self);
3686     ss->w = w;
3687     ss->h = h;
3688 
3689     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetMinSize, ss);
3690     // global refs and mds are deleted in _SetMinSize
3691 
3692     CATCH_BAD_ALLOC;
3693 }
3694 
3695 /*
3696  * Class:     sun_awt_windows_WWindowPeer
3697  * Method:    getScreenImOn
3698  * Signature: ()I
3699  */
3700 JNIEXPORT jint JNICALL
3701 Java_sun_awt_windows_WWindowPeer_getScreenImOn(JNIEnv *env, jobject self)
3702 {
3703     TRY;
3704 
3705     return static_cast<jint>(reinterpret_cast<INT_PTR>(AwtToolkit::GetInstance().SyncCall(
3706         (void *(*)(void *))AwtWindow::_GetScreenImOn,
3707         env->NewGlobalRef(self))));
3708     // global ref is deleted in _GetScreenImOn()
3709 
3710     CATCH_BAD_ALLOC_RET(-1);
3711 }
3712 
3713 /*
3714  * Class:     sun_awt_windows_WWindowPeer
3715  * Method:    setFullScreenExclusiveModeState
3716  * Signature: (Z)V
3717  */
3718 JNIEXPORT void JNICALL
3719 Java_sun_awt_windows_WWindowPeer_setFullScreenExclusiveModeState(JNIEnv *env,
3720         jobject self, jboolean state)
3721 {
3722     TRY;
3723 
3724     SetFullScreenExclusiveModeStateStruct *data =
3725         new SetFullScreenExclusiveModeStateStruct;
3726     data->window = env->NewGlobalRef(self);
3727     data->isFSEMState = state;
3728 
3729     AwtToolkit::GetInstance().SyncCall(
3730             AwtWindow::_SetFullScreenExclusiveModeState, data);
3731     // global ref and data are deleted in the invoked method
3732 
3733     CATCH_BAD_ALLOC;
3734 }
3735 
3736 /*
3737  * Class:     sun_awt_windows_WWindowPeer
3738  * Method:    modalDisable
3739  * Signature: (J)V
3740  */
3741 JNIEXPORT void JNICALL
3742 Java_sun_awt_windows_WWindowPeer_modalDisable(JNIEnv *env, jobject self,
3743                                               jobject blocker, jlong blockerHWnd)
3744 {
3745     TRY;
3746 
3747     ModalDisableStruct *mds = new ModalDisableStruct;
3748     mds->window = env->NewGlobalRef(self);
3749     mds->blockerHWnd = blockerHWnd;
3750 
3751     AwtToolkit::GetInstance().SyncCall(AwtWindow::_ModalDisable, mds);
3752     // global ref and mds are deleted in _ModalDisable
3753 
3754     CATCH_BAD_ALLOC;
3755 }
3756 
3757 /*
3758  * Class:     sun_awt_windows_WWindowPeer
3759  * Method:    modalEnable
3760  * Signature: ()V
3761  */
3762 JNIEXPORT void JNICALL
3763 Java_sun_awt_windows_WWindowPeer_modalEnable(JNIEnv *env, jobject self, jobject blocker)
3764 {
3765     TRY;
3766 
3767     AwtToolkit::GetInstance().SyncCall(AwtWindow::_ModalEnable,
3768         env->NewGlobalRef(self));
3769     // global ref is deleted in _ModalEnable
3770 
3771     CATCH_BAD_ALLOC;
3772 }
3773 
3774 /*
3775  * Class:     sun_awt_windows_WWindowPeer
3776  * Method:    setFocusableWindow
3777  * Signature: (Z)V
3778  */
3779 JNIEXPORT void JNICALL
3780 Java_sun_awt_windows_WWindowPeer_setFocusableWindow(JNIEnv *env, jobject self, jboolean isFocusableWindow)
3781 {
3782     TRY;
3783 
3784     SetFocusableWindowStruct *sfws = new SetFocusableWindowStruct;
3785     sfws->window = env->NewGlobalRef(self);
3786     sfws->isFocusableWindow = isFocusableWindow;
3787 
3788     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetFocusableWindow, sfws);
3789     // global ref and sfws are deleted in _SetFocusableWindow()
3790 
3791     CATCH_BAD_ALLOC;
3792 }
3793 
3794 JNIEXPORT void JNICALL
3795 Java_sun_awt_windows_WWindowPeer_nativeGrab(JNIEnv *env, jobject self)
3796 {
3797     TRY;
3798 
3799     AwtToolkit::GetInstance().SyncCall(AwtWindow::_Grab, env->NewGlobalRef(self));
3800     // global ref is deleted in _Grab()
3801 
3802     CATCH_BAD_ALLOC;
3803 }
3804 
3805 JNIEXPORT void JNICALL
3806 Java_sun_awt_windows_WWindowPeer_nativeUngrab(JNIEnv *env, jobject self)
3807 {
3808     TRY;
3809 
3810     AwtToolkit::GetInstance().SyncCall(AwtWindow::_Ungrab, env->NewGlobalRef(self));
3811     // global ref is deleted in _Ungrab()
3812 
3813     CATCH_BAD_ALLOC;
3814 }
3815 
3816 /*
3817  * Class:     sun_awt_windows_WWindowPeer
3818  * Method:    setOpacity
3819  * Signature: (I)V
3820  */
3821 JNIEXPORT void JNICALL
3822 Java_sun_awt_windows_WWindowPeer_setOpacity(JNIEnv *env, jobject self,
3823                                               jint iOpacity)
3824 {
3825     TRY;
3826 
3827     OpacityStruct *os = new OpacityStruct;
3828     os->window = env->NewGlobalRef(self);
3829     os->iOpacity = iOpacity;
3830 
3831     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetOpacity, os);
3832     // global refs and mds are deleted in _SetMinSize
3833 
3834     CATCH_BAD_ALLOC;
3835 }
3836 
3837 /*
3838  * Class:     sun_awt_windows_WWindowPeer
3839  * Method:    setOpaqueImpl
3840  * Signature: (Z)V
3841  */
3842 JNIEXPORT void JNICALL
3843 Java_sun_awt_windows_WWindowPeer_setOpaqueImpl(JNIEnv *env, jobject self,
3844                                               jboolean isOpaque)
3845 {
3846     TRY;
3847 
3848     OpaqueStruct *os = new OpaqueStruct;
3849     os->window = env->NewGlobalRef(self);
3850     os->isOpaque = isOpaque;
3851 
3852     AwtToolkit::GetInstance().SyncCall(AwtWindow::_SetOpaque, os);
3853     // global refs and mds are deleted in _SetMinSize
3854 
3855     CATCH_BAD_ALLOC;
3856 }
3857 
3858 /*
3859  * Class:     sun_awt_windows_WWindowPeer
3860  * Method:    updateWindowImpl
3861  * Signature: ([III)V
3862  */
3863 JNIEXPORT void JNICALL
3864 Java_sun_awt_windows_WWindowPeer_updateWindowImpl(JNIEnv *env, jobject self,
3865                                                   jintArray data,
3866                                                   jint width, jint height)
3867 {
3868     TRY;
3869 
3870     UpdateWindowStruct *uws = new UpdateWindowStruct;
3871     uws->window = env->NewGlobalRef(self);
3872     uws->data = (jintArray)env->NewGlobalRef(data);
3873     uws->hBitmap = NULL;
3874     uws->width = width;
3875     uws->height = height;
3876 
3877     AwtToolkit::GetInstance().InvokeFunction(AwtWindow::_UpdateWindow, uws);
3878     // global refs and mds are deleted in _UpdateWindow
3879 
3880     CATCH_BAD_ALLOC;
3881 }
3882 
3883 /**
3884  * This method is called from the WGL pipeline when it needs to update
3885  * the layered window WindowPeer's C++ level object.
3886  */
3887 void AwtWindow_UpdateWindow(JNIEnv *env, jobject peer,
3888                             jint width, jint height, HBITMAP hBitmap)
3889 {
3890     TRY;
3891 
3892     UpdateWindowStruct *uws = new UpdateWindowStruct;
3893     uws->window = env->NewGlobalRef(peer);
3894     uws->data = NULL;
3895     uws->hBitmap = hBitmap;
3896     uws->width = width;
3897     uws->height = height;
3898 
3899     AwtToolkit::GetInstance().InvokeFunction(AwtWindow::_UpdateWindow, uws);
3900     // global refs and mds are deleted in _UpdateWindow
3901 
3902     CATCH_BAD_ALLOC;
3903 }
3904 
3905 /*
3906  * Class:     sun_awt_windows_WComponentPeer
3907  * Method:    requestFocus
3908  * Signature: (Z)Z
3909  */
3910 JNIEXPORT jboolean JNICALL Java_sun_awt_windows_WWindowPeer_requestWindowFocus
3911     (JNIEnv *env, jobject self, jboolean isMouseEventCause)
3912 {
3913     TRY;
3914 
3915     jobject selfGlobalRef = env->NewGlobalRef(self);
3916 
3917     RequestWindowFocusStruct *rfs = new RequestWindowFocusStruct;
3918     rfs->component = selfGlobalRef;
3919     rfs->isMouseEventCause = isMouseEventCause;
3920 
3921     return (jboolean)AwtToolkit::GetInstance().SyncCall(
3922         (void*(*)(void*))AwtWindow::_RequestWindowFocus, rfs);
3923     // global refs and rfs are deleted in _RequestWindowFocus
3924 
3925     CATCH_BAD_ALLOC_RET(JNI_FALSE);
3926 }
3927 
3928 /*
3929  * Class:     sun_awt_windows_WWindowPeer
3930  * Method:    repositionSecurityWarning
3931  * Signature: ()V
3932  */
3933 JNIEXPORT void JNICALL
3934 Java_sun_awt_windows_WWindowPeer_repositionSecurityWarning(JNIEnv *env,
3935         jobject self)
3936 {
3937     TRY;
3938 
3939     RepositionSecurityWarningStruct *rsws =
3940         new RepositionSecurityWarningStruct;
3941     rsws->window = env->NewGlobalRef(self);
3942 
3943     AwtToolkit::GetInstance().InvokeFunction(
3944             AwtWindow::_RepositionSecurityWarning, rsws);
3945     // global refs and mds are deleted in _RepositionSecurityWarning
3946 
3947     CATCH_BAD_ALLOC;
3948 }
3949 
3950 /*
3951 * Class:     sun_awt_windows_WWindowPeer
3952 * Method:    windowDPIChange
3953 * Signature: (IFFIFF)V
3954 */
3955 JNIEXPORT void JNICALL
3956 Java_sun_awt_windows_WWindowPeer_windowDPIChange(JNIEnv *env, jobject self,
3957     jint prevScreen, jfloat prevScaleX, jfloat prevScaleY,
3958     jint screen, jfloat scaleX, jfloat scaleY)
3959 {
3960     TRY;
3961 
3962     ScaleStruct *ss = new ScaleStruct;
3963     ss->window = env->NewGlobalRef(self);
3964     ss->prevScreen = prevScreen;
3965     ss->prevScaleX = prevScaleX;
3966     ss->prevScaleY = prevScaleY;
3967     ss->screen = screen;
3968     ss->scaleX = scaleX;
3969     ss->scaleY = scaleY;
3970 
3971     AwtToolkit::GetInstance().InvokeFunction(AwtWindow::_WindowDPIChange, ss);
3972     // global refs and ss are deleted in _WindowDPIChange
3973 
3974     CATCH_BAD_ALLOC;
3975 }
3976 
3977 /*
3978  * Class:     sun_awt_windows_WLightweightFramePeer
3979  * Method:    overrideNativeHandle
3980  * Signature: (J)V
3981  */
3982 JNIEXPORT void JNICALL Java_sun_awt_windows_WLightweightFramePeer_overrideNativeHandle
3983   (JNIEnv *env, jobject self, jlong hwnd)
3984 {
3985     TRY;
3986 
3987     OverrideHandle *oh = new OverrideHandle;
3988     oh->frame = env->NewGlobalRef(self);
3989     oh->handle = (HWND) hwnd;
3990 
3991     AwtToolkit::GetInstance().SyncCall(AwtFrame::_OverrideHandle, oh);
3992     // global ref and oh are deleted in _OverrideHandle()
3993 
3994     CATCH_BAD_ALLOC;
3995 }
3996 
3997 } /* extern "C" */
--- EOF ---