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" */