1 /*
2 * Copyright (c) 1996, 2011, 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_Toolkit.h"
27 #include "awt_Frame.h"
28 #include "awt_MenuBar.h"
29 #include "awt_Dialog.h"
30 #include "awt_IconCursor.h"
31 #include "awt_Win32GraphicsDevice.h"
32 #include "ComCtl32Util.h"
33
34 #include <windowsx.h>
35
36 #include <java_lang_Integer.h>
37 #include <sun_awt_EmbeddedFrame.h>
38 #include <sun_awt_windows_WEmbeddedFrame.h>
39 #include <sun_awt_windows_WEmbeddedFramePeer.h>
40
41
42 /* IMPORTANT! Read the README.JNI file for notes on JNI converted AWT code.
43 */
44
45 /***********************************************************************/
46 // Struct for _SetState() method
47 struct SetStateStruct {
48 jobject frame;
49 jint state;
50 };
51 // Struct for _SetMaximizedBounds() method
52 struct SetMaximizedBoundsStruct {
53 jobject frame;
54 jint x, y;
55 jint width, height;
56 };
57 // Struct for _SetMenuBar() method
58 struct SetMenuBarStruct {
59 jobject frame;
60 jobject menubar;
61 };
62
63 // Struct for _SetIMMOption() method
64 struct SetIMMOptionStruct {
65 jobject frame;
66 jstring option;
67 };
68 // Struct for _SynthesizeWmActivate() method
69 struct SynthesizeWmActivateStruct {
70 jobject frame;
71 jboolean doActivate;
72 };
73 // Struct for _NotifyModalBlocked() method
74 struct NotifyModalBlockedStruct {
75 jobject frame;
76 jobject peer;
77 jobject blockerPeer;
78 jboolean blocked;
79 };
80 // Information about thread containing modal blocked embedded frames
81 struct BlockedThreadStruct {
82 int framesCount;
83 HHOOK mouseHook;
84 HHOOK modalHook;
85 };
86 /************************************************************************
87 * AwtFrame fields
88 */
89
90 jfieldID AwtFrame::handleID;
91
92 jfieldID AwtFrame::undecoratedID;
93 jmethodID AwtFrame::getExtendedStateMID;
94 jmethodID AwtFrame::setExtendedStateMID;
95
96 jmethodID AwtFrame::activateEmbeddingTopLevelMID;
97
98 Hashtable AwtFrame::sm_BlockedThreads("AWTBlockedThreads");
99
100 /************************************************************************
101 * AwtFrame methods
102 */
103
104 AwtFrame::AwtFrame() {
105 m_parentWnd = NULL;
106 menuBar = NULL;
107 m_isEmbedded = FALSE;
108 m_ignoreWmSize = FALSE;
109 m_isMenuDropped = FALSE;
110 m_isInputMethodWindow = FALSE;
111 m_isUndecorated = FALSE;
112 m_imeTargetComponent = NULL;
113 m_actualFocusedWindow = NULL;
114 m_iconic = FALSE;
115 m_zoomed = FALSE;
116 m_maxBoundsSet = FALSE;
117 m_forceResetZoomed = FALSE;
118
119 isInManualMoveOrSize = FALSE;
120 grabbedHitTest = 0;
121 }
122
123 AwtFrame::~AwtFrame()
124 {
125 }
126
127 void AwtFrame::Dispose()
128 {
129 AwtWindow::Dispose();
130 }
131
132 LPCTSTR AwtFrame::GetClassName() {
133 return AWT_FRAME_WINDOW_CLASS_NAME;
134 }
135
136 /*
137 * Create a new AwtFrame object and window.
138 */
139 AwtFrame* AwtFrame::Create(jobject self, jobject parent)
140 {
141 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
142 if (env->EnsureLocalCapacity(1) < 0) {
143 return NULL;
144 }
145
146 PDATA pData;
147 HWND hwndParent = NULL;
148 AwtFrame* frame;
149 jclass cls = NULL;
150 jclass inputMethodWindowCls = NULL;
151 jobject target = NULL;
152
153 try {
154 target = env->GetObjectField(self, AwtObject::targetID);
155 JNI_CHECK_NULL_GOTO(target, "target", done);
156
157 if (parent != NULL) {
158 JNI_CHECK_PEER_GOTO(parent, done);
159 {
160 AwtFrame* parent = (AwtFrame *)pData;
161 hwndParent = parent->GetHWnd();
162 }
163 }
164
165 frame = new AwtFrame();
166
167 {
168 /*
169 * A variation on Netscape's hack for embedded frames: the client
170 * area of the browser is a Java Frame for parenting purposes, but
171 * really a Windows child window
172 */
173 cls = env->FindClass("sun/awt/EmbeddedFrame");
174 if (cls == NULL) {
175 return NULL;
176 }
177 INT_PTR handle;
178 jboolean isEmbeddedInstance = env->IsInstanceOf(target, cls);
179 jboolean isEmbedded = FALSE;
180
181 if (isEmbeddedInstance) {
182 handle = static_cast<INT_PTR>(env->GetLongField(target, AwtFrame::handleID));
183 if (handle != 0) {
184 isEmbedded = TRUE;
185 }
186 }
187 frame->m_isEmbedded = isEmbedded;
188
189 if (isEmbedded) {
190 hwndParent = (HWND)handle;
191 RECT rect;
192 ::GetClientRect(hwndParent, &rect);
193 //Fix for 6328675: SWT_AWT.new_Frame doesn't occupy client area under JDK6
194 frame->m_isUndecorated = true;
195 /*
196 * Fix for BugTraq ID 4337754.
197 * Initialize m_peerObject before the first call
198 * to AwtFrame::GetClassName().
199 */
200 frame->m_peerObject = env->NewGlobalRef(self);
201 frame->RegisterClass();
202 DWORD exStyle = WS_EX_NOPARENTNOTIFY;
203
204 if (GetRTL()) {
205 exStyle |= WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR;
206 if (GetRTLReadingOrder())
207 exStyle |= WS_EX_RTLREADING;
208 }
209
210 frame->m_hwnd = ::CreateWindowEx(exStyle,
211 frame->GetClassName(), TEXT(""),
212 WS_CHILD | WS_CLIPCHILDREN,
213 0, 0,
214 rect.right, rect.bottom,
215 hwndParent, NULL,
216 AwtToolkit::GetInstance().GetModuleHandle(),
217 NULL);
218 frame->LinkObjects(env, self);
219 frame->SubclassHWND();
220
221 // Update target's dimensions to reflect this embedded window.
222 ::GetClientRect(frame->m_hwnd, &rect);
223 ::MapWindowPoints(frame->m_hwnd, hwndParent, (LPPOINT)&rect, 2);
224
225 env->SetIntField(target, AwtComponent::xID, rect.left);
226 env->SetIntField(target, AwtComponent::yID, rect.top);
227 env->SetIntField(target, AwtComponent::widthID,
228 rect.right-rect.left);
229 env->SetIntField(target, AwtComponent::heightID,
230 rect.bottom-rect.top);
231 frame->InitPeerGraphicsConfig(env, self);
232 AwtToolkit::GetInstance().RegisterEmbedderProcessId(hwndParent);
233 } else {
234 jint state = env->CallIntMethod(self, AwtFrame::getExtendedStateMID);
235 DWORD exStyle;
236 DWORD style;
237
238 // for input method windows, use minimal decorations
239 inputMethodWindowCls = env->FindClass("sun/awt/im/InputMethodWindow");
240 if ((inputMethodWindowCls != NULL) && env->IsInstanceOf(target, inputMethodWindowCls)) {
241 //for below-the-spot composition window, use no decoration
242 if (env->GetBooleanField(target, AwtFrame::undecoratedID) == JNI_TRUE){
243 exStyle = 0;
244 style = WS_POPUP|WS_CLIPCHILDREN;
245 frame->m_isUndecorated = TRUE;
246 } else {
247 exStyle = WS_EX_PALETTEWINDOW;
248 style = WS_CLIPCHILDREN;
249 }
250 frame->m_isInputMethodWindow = TRUE;
251 } else if (env->GetBooleanField(target, AwtFrame::undecoratedID) == JNI_TRUE) {
252 exStyle = 0;
253 style = WS_POPUP | WS_SYSMENU | WS_CLIPCHILDREN |
254 WS_MAXIMIZEBOX | WS_MINIMIZEBOX;
255 if (state & java_awt_Frame_ICONIFIED) {
256 frame->setIconic(TRUE);
257 }
258 frame->m_isUndecorated = TRUE;
259 } else {
260 exStyle = WS_EX_WINDOWEDGE;
261 style = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
262 if (state & java_awt_Frame_ICONIFIED) {
263 frame->setIconic(TRUE);
264 }
265 }
266
267 if (GetRTL()) {
268 exStyle |= WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR;
269 if (GetRTLReadingOrder())
270 exStyle |= WS_EX_RTLREADING;
271 }
272
273 jint x = env->GetIntField(target, AwtComponent::xID);
274 jint y = env->GetIntField(target, AwtComponent::yID);
275 jint width = env->GetIntField(target, AwtComponent::widthID);
276 jint height = env->GetIntField(target, AwtComponent::heightID);
277
278 frame->CreateHWnd(env, L"",
279 style,
280 exStyle,
281 0, 0, 0, 0,
282 hwndParent,
283 NULL,
284 ::GetSysColor(COLOR_WINDOWTEXT),
285 ::GetSysColor(COLOR_WINDOWFRAME),
286 self);
287 /*
288 * Reshape here instead of during create, so that a
289 * WM_NCCALCSIZE is sent.
290 */
291 frame->Reshape(x, y, width, height);
292 }
293 }
294 } catch (...) {
295 env->DeleteLocalRef(target);
296 env->DeleteLocalRef(cls);
297 env->DeleteLocalRef(inputMethodWindowCls);
298 throw;
299 }
300
301 done:
302 env->DeleteLocalRef(target);
303 env->DeleteLocalRef(cls);
304 env->DeleteLocalRef(inputMethodWindowCls);
305
306 return frame;
307 }
308
309 LRESULT AwtFrame::ProxyWindowProc(UINT message, WPARAM wParam, LPARAM lParam, MsgRouting &mr)
310 {
311 LRESULT retValue = 0L;
312
313 AwtComponent *focusOwner = NULL;
314 AwtComponent *imeTargetComponent = NULL;
315
316 // IME and input language related messages need to be sent to a window
317 // which has the Java input focus
318 switch (message) {
319 case WM_IME_STARTCOMPOSITION:
320 case WM_IME_ENDCOMPOSITION:
321 case WM_IME_COMPOSITION:
322 case WM_IME_CONTROL:
323 case WM_IME_COMPOSITIONFULL:
324 case WM_IME_SELECT:
325 case WM_IME_CHAR:
326 case WM_IME_REQUEST:
327 case WM_IME_KEYDOWN:
328 case WM_IME_KEYUP:
329 case WM_INPUTLANGCHANGEREQUEST:
330 case WM_INPUTLANGCHANGE:
331 if (message == WM_IME_STARTCOMPOSITION) {
332 SetImeTargetComponent(sm_focusOwner);
333 }
334 imeTargetComponent = AwtComponent::GetComponent(GetImeTargetComponent());
335 if (imeTargetComponent != NULL &&
336 imeTargetComponent != this) // avoid recursive calls
337 {
338 retValue = imeTargetComponent->WindowProc(message, wParam, lParam);
339 mr = mrConsume;
340 }
341 if (message == WM_IME_ENDCOMPOSITION) {
342 SetImeTargetComponent(NULL);
343 }
344 break;
345 case WM_SETFOCUS:
346 if (sm_inSynthesizeFocus) break; // pass it up the WindowProc chain
347
348 if (!sm_suppressFocusAndActivation && IsEmbeddedFrame()) {
349 AwtSetActiveWindow();
350 }
351 mr = mrConsume;
352 break;
353 case WM_KILLFOCUS:
354 if (sm_inSynthesizeFocus) break; // pass it up the WindowProc chain
355
356 if (!sm_suppressFocusAndActivation && IsEmbeddedFrame()) {
357 AwtWindow::SynthesizeWmActivate(FALSE, GetHWnd(), NULL);
358
359 } else if (sm_restoreFocusAndActivation) {
360 if (AwtComponent::GetFocusedWindow() != NULL) {
361 AwtWindow *focusedWindow = (AwtWindow*)GetComponent(AwtComponent::GetFocusedWindow());
362 if (focusedWindow != NULL) {
363 // Will just silently restore native focus & activation.
364 focusedWindow->AwtSetActiveWindow();
365 }
366 }
367 }
368 mr = mrConsume;
369 break;
370 case 0x0127: // WM_CHANGEUISTATE
371 case 0x0128: // WM_UPDATEUISTATE
372 mr = mrConsume;
373 break;
374 }
375
376 return retValue;
377 }
378
379 LRESULT AwtFrame::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
380 {
381 MsgRouting mr = mrDoDefault;
382 LRESULT retValue = 0L;
383
384 retValue = ProxyWindowProc(message, wParam, lParam, mr);
385
386 if (mr != mrConsume) {
387 retValue = AwtWindow::WindowProc(message, wParam, lParam);
388 }
389 return retValue;
390 }
391
392 MsgRouting AwtFrame::WmShowWindow(BOOL show, UINT status)
393 {
394 /*
395 * Fix for 6492970.
396 * When a non-focusable toplevel is shown alone the Java process
397 * is not foreground. If one shows another (focusable) toplevel
398 * the native platform not always makes it foreground (see the CR).
399 * Even worse, sometimes it sends the newly shown toplevel WM_ACTIVATE
400 * message. This breaks Java focus. To workaround the problem we
401 * set the toplevel being shown foreground programmatically.
402 * The fix is localized to non-foreground process case only.
403 * (See also: 6599270)
404 */
405 if (!IsEmbeddedFrame() && show == TRUE && status == 0) {
406 HWND fgHWnd = ::GetForegroundWindow();
407 if (fgHWnd != NULL) {
408 DWORD fgProcessID;
409 ::GetWindowThreadProcessId(fgHWnd, &fgProcessID);
410
411 if (fgProcessID != ::GetCurrentProcessId()) {
412 AwtWindow* window = (AwtWindow*)GetComponent(GetHWnd());
413
414 if (window != NULL && window->IsFocusableWindow() && window->IsAutoRequestFocus() &&
415 !::IsWindow(GetModalBlocker(GetHWnd())))
416 {
417 // When the Java process is not allowed to set the foreground window
418 // (see MSDN) the request below will just have no effect.
419 ::SetForegroundWindow(GetHWnd());
420 }
421 }
422 }
423 }
424 return AwtWindow::WmShowWindow(show, status);
425 }
426
427 MsgRouting AwtFrame::WmMouseUp(UINT flags, int x, int y, int button) {
428 if (isInManualMoveOrSize) {
429 isInManualMoveOrSize = FALSE;
430 ::ReleaseCapture();
431 return mrConsume;
432 }
433 return AwtWindow::WmMouseUp(flags, x, y, button);
434 }
435
436 MsgRouting AwtFrame::WmMouseMove(UINT flags, int x, int y) {
437 /**
438 * If this Frame is non-focusable then we should implement move and size operation for it by
439 * ourselfves because we don't dispatch appropriate mouse messages to default window procedure.
440 */
441 if (!IsFocusableWindow() && isInManualMoveOrSize) {
442 DWORD curPos = ::GetMessagePos();
443 x = GET_X_LPARAM(curPos);
444 y = GET_Y_LPARAM(curPos);
445 RECT r;
446 ::GetWindowRect(GetHWnd(), &r);
447 POINT mouseLoc = {x, y};
448 mouseLoc.x -= savedMousePos.x;
449 mouseLoc.y -= savedMousePos.y;
450 savedMousePos.x = x;
451 savedMousePos.y = y;
452 if (grabbedHitTest == HTCAPTION) {
453 ::SetWindowPos(GetHWnd(), NULL, r.left+mouseLoc.x, r.top+mouseLoc.y,
454 r.right-r.left, r.bottom-r.top,
455 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
456 } else {
457 switch (grabbedHitTest) {
458 case HTTOP:
459 r.top += mouseLoc.y;
460 break;
461 case HTBOTTOM:
462 r.bottom += mouseLoc.y;
463 break;
464 case HTRIGHT:
465 r.right += mouseLoc.x;
466 break;
467 case HTLEFT:
468 r.left += mouseLoc.x;
469 break;
470 case HTTOPLEFT:
471 r.left += mouseLoc.x;
472 r.top += mouseLoc.y;
473 break;
474 case HTTOPRIGHT:
475 r.top += mouseLoc.y;
476 r.right += mouseLoc.x;
477 break;
478 case HTBOTTOMLEFT:
479 r.left += mouseLoc.x;
480 r.bottom += mouseLoc.y;
481 break;
482 case HTBOTTOMRIGHT:
483 case HTSIZE:
484 r.right += mouseLoc.x;
485 r.bottom += mouseLoc.y;
486 break;
487 }
488
489 ::SetWindowPos(GetHWnd(), NULL, r.left, r.top,
490 r.right-r.left, r.bottom-r.top,
491 SWP_NOACTIVATE | SWP_NOZORDER |
492 SWP_NOCOPYBITS | SWP_DEFERERASE);
493 }
494 return mrConsume;
495 } else {
496 return AwtWindow::WmMouseMove(flags, x, y);
497 }
498 }
499
500 MsgRouting AwtFrame::WmNcMouseUp(WPARAM hitTest, int x, int y, int button) {
501 if (!IsFocusableWindow() && (button & LEFT_BUTTON)) {
502 /*
503 * Fix for 6399659.
504 * The native system shouldn't activate the next window in z-order
505 * when minimizing non-focusable window.
506 */
507 if (hitTest == HTMINBUTTON) {
508 ::ShowWindow(GetHWnd(), SW_SHOWMINNOACTIVE);
509 return mrConsume;
510 }
511 /**
512 * If this Frame is non-focusable then we should implement move and size operation for it by
513 * ourselfves because we don't dispatch appropriate mouse messages to default window procedure.
514 */
515 if ((button & DBL_CLICK) && hitTest == HTCAPTION) {
516 // Double click on caption - maximize or restore Frame.
517 if (IsResizable()) {
518 if (::IsZoomed(GetHWnd())) {
519 ::ShowWindow(GetHWnd(), SW_SHOWNOACTIVATE);
520 } else {
521 ::ShowWindow(GetHWnd(), SW_MAXIMIZE);
522 }
523 }
524 return mrConsume;
525 }
526 switch (hitTest) {
527 case HTMAXBUTTON:
528 if (IsResizable()) {
529 if (::IsZoomed(GetHWnd())) {
530 ::ShowWindow(GetHWnd(), SW_SHOWNOACTIVATE);
531 } else {
532 ::ShowWindow(GetHWnd(), SW_MAXIMIZE);
533 }
534 }
535 return mrConsume;
536 default:
537 return mrDoDefault;
538 }
539 }
540 return AwtWindow::WmNcMouseUp(hitTest, x, y, button);
541 }
542
543 MsgRouting AwtFrame::WmNcMouseDown(WPARAM hitTest, int x, int y, int button) {
544 // By Swing request, click on the Frame's decorations (even on
545 // grabbed Frame) should generate UngrabEvent
546 if (m_grabbedWindow != NULL/* && !m_grabbedWindow->IsOneOfOwnersOf(this)*/) {
547 m_grabbedWindow->Ungrab();
548 }
549 if (!IsFocusableWindow() && (button & LEFT_BUTTON)) {
550 switch (hitTest) {
551 case HTTOP:
552 case HTBOTTOM:
553 case HTLEFT:
554 case HTRIGHT:
555 case HTTOPLEFT:
556 case HTTOPRIGHT:
557 case HTBOTTOMLEFT:
558 case HTBOTTOMRIGHT:
559 case HTSIZE:
560 // Zoomed or non-resizable unfocusable frames should not be resizable.
561 if (isZoomed() || !IsResizable()) {
562 return mrConsume;
563 }
564 case HTCAPTION:
565 // We are going to perform default mouse action on non-client area of this window
566 // Grab mouse for this purpose and store coordinates for motion vector calculation
567 savedMousePos.x = x;
568 savedMousePos.y = y;
569 ::SetCapture(GetHWnd());
570 isInManualMoveOrSize = TRUE;
571 grabbedHitTest = hitTest;
572 return mrConsume;
573 default:
574 return mrDoDefault;
575 }
576 }
577 return AwtWindow::WmNcMouseDown(hitTest, x, y, button);
578 }
579
580 // Override AwtWindow::Reshape() to handle minimized/maximized
581 // frames (see 6525850, 4065534)
582 void AwtFrame::Reshape(int x, int y, int width, int height)
583 {
584 if (isIconic()) {
585 // normal AwtComponent::Reshape will not work for iconified windows so...
586 WINDOWPLACEMENT wp;
587 POINT ptMinPosition = {x,y};
588 POINT ptMaxPosition = {0,0};
589 RECT rcNormalPosition = {x,y,x+width,y+height};
590 RECT rcWorkspace;
591 HWND hWndDesktop = GetDesktopWindow();
592 HWND hWndSelf = GetHWnd();
593
594 // SetWindowPlacement takes workspace coordinates, but
595 // if taskbar is at top of screen, workspace coords !=
596 // screen coords, so offset by workspace origin
597 VERIFY(::SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&rcWorkspace, 0));
598 ::OffsetRect(&rcNormalPosition, -rcWorkspace.left, -rcWorkspace.top);
599
600 // set the window size for when it is not-iconified
601 wp.length = sizeof(wp);
602 wp.flags = WPF_SETMINPOSITION;
603 wp.showCmd = IsVisible() ? SW_SHOWMINIMIZED : SW_HIDE;
604 wp.ptMinPosition = ptMinPosition;
605 wp.ptMaxPosition = ptMaxPosition;
606 wp.rcNormalPosition = rcNormalPosition;
607
608 // If the call is not guarded with ignoreWmSize,
609 // a regression for bug 4851435 appears.
610 // Having this call guarded also prevents
611 // changing the iconified state of the frame
612 // while calling the Frame.setBounds() method.
613 m_ignoreWmSize = TRUE;
614 ::SetWindowPlacement(hWndSelf, &wp);
615 m_ignoreWmSize = FALSE;
616
617 return;
618 }
619
620 if (isZoomed()) {
621 // setting size of maximized window, we remove the
622 // maximized state bit (matches Motif behaviour)
623 // (calling ShowWindow(SW_RESTORE) would fire an
624 // activation event which we don't want)
625 LONG style = GetStyle();
626 DASSERT(style & WS_MAXIMIZE);
627 style ^= WS_MAXIMIZE;
628 SetStyle(style);
629 }
630
631 AwtWindow::Reshape(x, y, width, height);
632 }
633
634
635 /* Show the frame in it's current state */
636 void
637 AwtFrame::Show()
638 {
639 m_visible = true;
640 HWND hwnd = GetHWnd();
641 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
642
643 DTRACE_PRINTLN3("AwtFrame::Show:%s%s%s",
644 m_iconic ? " iconic" : "",
645 m_zoomed ? " zoomed" : "",
646 m_iconic || m_zoomed ? "" : " normal");
647
648 BOOL locationByPlatform = env->GetBooleanField(GetTarget(env), AwtWindow::locationByPlatformID);
649
650 if (locationByPlatform) {
651 moveToDefaultLocation();
652 }
653 EnableTranslucency(TRUE);
654
655 BOOL autoRequestFocus = IsAutoRequestFocus();
656
657 if (m_iconic) {
658 if (m_zoomed) {
659 // This whole function could probably be rewritten to use
660 // ::SetWindowPlacement but MS docs doesn't tell if
661 // ::SetWindowPlacement is a proper superset of
662 // ::ShowWindow. So let's be conservative and only use it
663 // here, where we really do need it.
664 DTRACE_PRINTLN("AwtFrame::Show(SW_SHOWMINIMIZED, WPF_RESTORETOMAXIMIZED");
665 WINDOWPLACEMENT wp;
666 ::ZeroMemory(&wp, sizeof(WINDOWPLACEMENT));
667 wp.length = sizeof(WINDOWPLACEMENT);
668 ::GetWindowPlacement(hwnd, &wp);
669 if (!IsFocusableWindow() || !autoRequestFocus) {
670 wp.showCmd = SW_SHOWMINNOACTIVE;
671 } else {
672 wp.showCmd = SW_SHOWMINIMIZED;
673 }
674 wp.flags |= WPF_RESTORETOMAXIMIZED;
675 ::SetWindowPlacement(hwnd, &wp);
676 }
677 else {
678 DTRACE_PRINTLN("AwtFrame::Show(SW_SHOWMINIMIZED)");
679 if (!IsFocusableWindow() || !autoRequestFocus) {
680 ::ShowWindow(hwnd, SW_SHOWMINNOACTIVE);
681 } else {
682 ::ShowWindow(hwnd, SW_SHOWMINIMIZED);
683 }
684 }
685 }
686 else if (m_zoomed) {
687 DTRACE_PRINTLN("AwtFrame::Show(SW_SHOWMAXIMIZED)");
688 if (!autoRequestFocus) {
689
690 m_filterFocusAndActivation = TRUE;
691 ::ShowWindow(hwnd, SW_MAXIMIZE);
692 m_filterFocusAndActivation = FALSE;
693
694 } else if (!IsFocusableWindow()) {
695 ::ShowWindow(hwnd, SW_MAXIMIZE);
696 } else {
697 ::ShowWindow(hwnd, SW_SHOWMAXIMIZED);
698 }
699 }
700 else if (m_isInputMethodWindow) {
701 // Don't activate input methow window
702 DTRACE_PRINTLN("AwtFrame::Show(SW_SHOWNA)");
703 ::ShowWindow(hwnd, SW_SHOWNA);
704
705 // After the input method window shown, we have to adjust the
706 // IME candidate window position. Here is why.
707 // Usually, when IMM opens the candidate window, it sends WM_IME_NOTIFY w/
708 // IMN_OPENCANDIDATE message to the awt component window. The
709 // awt component makes a Java call to acquire the text position
710 // in order to show the candidate window just below the input method window.
711 // However, by the time it acquires the position, the input method window
712 // hasn't been displayed yet, the position returned is just below
713 // the composed text and when the input method window is shown, it
714 // will hide part of the candidate list. To fix this, we have to
715 // adjust the candidate window position after the input method window
716 // is shown. See bug 5012944.
717 AdjustCandidateWindowPos();
718 }
719 else {
720 // Nor iconic, nor zoomed (handled above) - so use SW_RESTORE
721 // to show in "normal" state regardless of whatever stale
722 // state might the invisible window still has.
723 DTRACE_PRINTLN("AwtFrame::Show(SW_RESTORE)");
724 if (!IsFocusableWindow() || !autoRequestFocus) {
725 ::ShowWindow(hwnd, SW_SHOWNOACTIVATE);
726 } else {
727 ::ShowWindow(hwnd, SW_RESTORE);
728 }
729 }
730 }
731
732 void
733 AwtFrame::SendWindowStateEvent(int oldState, int newState)
734 {
735 SendWindowEvent(java_awt_event_WindowEvent_WINDOW_STATE_CHANGED,
736 NULL, oldState, newState);
737 }
738
739 void
740 AwtFrame::ClearMaximizedBounds()
741 {
742 m_maxBoundsSet = FALSE;
743 }
744
745 void AwtFrame::AdjustCandidateWindowPos()
746 {
747 // This method should only be called if the current frame
748 // is the input method window frame.
749 if (!m_isInputMethodWindow) {
750 return;
751 }
752
753 RECT inputWinRec, focusWinRec;
754 AwtComponent *comp = AwtComponent::GetComponent(AwtComponent::sm_focusOwner);
755 if (comp == NULL) {
756 return;
757 }
758
759 ::GetWindowRect(GetHWnd(), &inputWinRec);
760 ::GetWindowRect(sm_focusOwner, &focusWinRec);
761
762 LPARAM candType = comp->GetCandidateType();
763 HWND defaultIMEWnd = ::ImmGetDefaultIMEWnd(GetHWnd());
764 if (defaultIMEWnd == NULL) {
765 return;
766 }
767 UINT bits = 1;
768 // adjusts the candidate window position
769 for (int iCandType = 0; iCandType < 32; iCandType++, bits<<=1) {
770 if (candType & bits) {
771 CANDIDATEFORM cf;
772 cf.dwIndex = iCandType;
773 cf.dwStyle = CFS_CANDIDATEPOS;
774 // Since the coordinates are relative to the containing window,
775 // we have to calculate the coordinates as below.
776 cf.ptCurrentPos.x = inputWinRec.left - focusWinRec.left;
777 cf.ptCurrentPos.y = inputWinRec.bottom - focusWinRec.top;
778
779 // sends IMC_SETCANDIDATEPOS to IMM to move the candidate window.
780 ::SendMessage(defaultIMEWnd, WM_IME_CONTROL, IMC_SETCANDIDATEPOS, (LPARAM)&cf);
781 }
782 }
783 }
784
785 void
786 AwtFrame::SetMaximizedBounds(int x, int y, int w, int h)
787 {
788 m_maxPos.x = x;
789 m_maxPos.y = y;
790 m_maxSize.x = w;
791 m_maxSize.y = h;
792 m_maxBoundsSet = TRUE;
793 }
794
795 MsgRouting AwtFrame::WmGetMinMaxInfo(LPMINMAXINFO lpmmi)
796 {
797 //Firstly call AwtWindow's function
798 MsgRouting r = AwtWindow::WmGetMinMaxInfo(lpmmi);
799
800 //Then replace maxPos & maxSize if necessary
801 if (!m_maxBoundsSet) {
802 return r;
803 }
804
805 if (m_maxPos.x != java_lang_Integer_MAX_VALUE)
806 lpmmi->ptMaxPosition.x = m_maxPos.x;
807 if (m_maxPos.y != java_lang_Integer_MAX_VALUE)
808 lpmmi->ptMaxPosition.y = m_maxPos.y;
809 if (m_maxSize.x != java_lang_Integer_MAX_VALUE)
810 lpmmi->ptMaxSize.x = m_maxSize.x;
811 if (m_maxSize.y != java_lang_Integer_MAX_VALUE)
812 lpmmi->ptMaxSize.y = m_maxSize.y;
813 return mrConsume;
814 }
815
816 MsgRouting AwtFrame::WmSize(UINT type, int w, int h)
817 {
818 currentWmSizeState = type;
819 if (currentWmSizeState == SIZE_MINIMIZED) {
820 UpdateSecurityWarningVisibility();
821 }
822
823 if (m_ignoreWmSize) {
824 return mrDoDefault;
825 }
826
827 DTRACE_PRINTLN6("AwtFrame::WmSize: %dx%d,%s visible, state%s%s%s",
828 w, h,
829 ::IsWindowVisible(GetHWnd()) ? "" : " not",
830 m_iconic ? " iconic" : "",
831 m_zoomed ? " zoomed" : "",
832 m_iconic || m_zoomed ? "" : " normal");
833
834 BOOL iconify = type == SIZE_MINIMIZED;
835
836 // Note that zoom may be set to TRUE in several cases:
837 // 1. type == SIZE_MAXIMIZED means that either the user or
838 // the developer (via setExtendedState(MAXIMIZED_BOTH)
839 // maximizes the frame.
840 // 2. type == SIZE_MINIMIZED && isZoomed() means that a maximized
841 // frame is to be minimized. If the user minimizes a maximized
842 // frame, we need to keep the zoomed property TRUE. However,
843 // if the developer calls setExtendedState(ICONIFIED), i.e.
844 // w/o combining the ICONIFIED state with the MAXIMIZED state,
845 // we MUST RESET the zoomed property.
846 // The flag m_forceResetZoomed identifies the latter case.
847 BOOL zoom =
848 (
849 type == SIZE_MAXIMIZED
850 ||
851 (type == SIZE_MINIMIZED && isZoomed())
852 )
853 && !m_forceResetZoomed;
854
855 // Set the new state and send appropriate Java event
856 jint oldState = java_awt_Frame_NORMAL;
857 if (isIconic()) {
858 oldState |= java_awt_Frame_ICONIFIED;
859 }
860 if (isZoomed()) {
861 oldState |= java_awt_Frame_MAXIMIZED_BOTH;
862 }
863
864 jint newState = java_awt_Frame_NORMAL;
865 if (iconify) {
866 newState |= java_awt_Frame_ICONIFIED;
867 }
868 if (zoom) {
869 newState |= java_awt_Frame_MAXIMIZED_BOTH;
870 }
871
872 setIconic(iconify);
873 setZoomed(zoom);
874
875 jint changed = oldState ^ newState;
876 if (changed != 0) {
877 DTRACE_PRINTLN2("AwtFrame::WmSize: reporting state change %x -> %x",
878 oldState, newState);
879
880 // sync target with peer
881 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
882 env->CallVoidMethod(GetPeer(env), AwtFrame::setExtendedStateMID, newState);
883
884 // report (de)iconification to old clients
885 if (changed & java_awt_Frame_ICONIFIED) {
886 if (newState & java_awt_Frame_ICONIFIED) {
887 SendWindowEvent(java_awt_event_WindowEvent_WINDOW_ICONIFIED);
888 } else {
889 SendWindowEvent(java_awt_event_WindowEvent_WINDOW_DEICONIFIED);
890 }
891 }
892
893 // New (since 1.4) state change event
894 SendWindowStateEvent(oldState, newState);
895 }
896
897 // If window is in iconic state, do not send COMPONENT_RESIZED event
898 if (isIconic()) {
899 return mrDoDefault;
900 }
901
902 return AwtWindow::WmSize(type, w, h);
903 }
904
905 MsgRouting AwtFrame::WmActivate(UINT nState, BOOL fMinimized, HWND opposite)
906 {
907 jint type;
908
909 if (nState != WA_INACTIVE) {
910 if (::IsWindow(AwtWindow::GetModalBlocker(GetHWnd())) ||
911 CheckActivateActualFocusedWindow(opposite))
912 {
913 return mrConsume;
914 }
915 type = java_awt_event_WindowEvent_WINDOW_GAINED_FOCUS;
916 AwtComponent::SetFocusedWindow(GetHWnd());
917
918 } else {
919 if (!::IsWindow(AwtWindow::GetModalBlocker(opposite))) {
920 // If deactivation happens because of press on grabbing
921 // window - this is nonsense, since grabbing window is
922 // assumed to have focus and watch for deactivation. But
923 // this can happen - if grabbing window is proxied Window,
924 // with Frame keeping real focus for it.
925 if (m_grabbedWindow != NULL) {
926 if (m_grabbedWindow->GetHWnd() == opposite) {
927 // Do nothing
928 } else {
929 // Normally, we would rather check that this ==
930 // grabbed window, and focus is leaving it -
931 // ungrab. But since we know about proxied
932 // windows, we simply assume this is one of the
933 // known cases.
934 if (!m_grabbedWindow->IsOneOfOwnersOf((AwtWindow*)AwtComponent::GetComponent(opposite))) {
935 m_grabbedWindow->Ungrab();
936 }
937 }
938 }
939 CheckRetainActualFocusedWindow(opposite);
940
941 type = java_awt_event_WindowEvent_WINDOW_LOST_FOCUS;
942 AwtComponent::SetFocusedWindow(NULL);
943 sm_focusOwner = NULL;
944 }
945 }
946
947 SendWindowEvent(type, opposite);
948 return mrConsume;
949 }
950
951 BOOL AwtFrame::CheckActivateActualFocusedWindow(HWND deactivatedOpositeHWnd)
952 {
953 if (m_actualFocusedWindow != NULL) {
954 HWND hwnd = m_actualFocusedWindow->GetHWnd();
955 if (hwnd != NULL && ::IsWindowVisible(hwnd)) {
956 SynthesizeWmActivate(TRUE, hwnd, deactivatedOpositeHWnd);
957 return TRUE;
958 }
959 m_actualFocusedWindow = NULL;
960 }
961 return FALSE;
962 }
963
964 void AwtFrame::CheckRetainActualFocusedWindow(HWND activatedOpositeHWnd)
965 {
966 // If actual focused window is not this Frame
967 if (AwtComponent::GetFocusedWindow() != GetHWnd()) {
968 // Make sure the actual focused window is an owned window of this frame
969 AwtWindow *focusedWindow = (AwtWindow *)AwtComponent::GetComponent(AwtComponent::GetFocusedWindow());
970 if (focusedWindow != NULL && focusedWindow->GetOwningFrameOrDialog() == this) {
971
972 // Check that the opposite window is not this frame, nor an owned window of this frame
973 if (activatedOpositeHWnd != NULL) {
974 AwtWindow *oppositeWindow = (AwtWindow *)AwtComponent::GetComponent(activatedOpositeHWnd);
975 if (oppositeWindow && oppositeWindow != this &&
976 oppositeWindow->GetOwningFrameOrDialog() != this)
977 {
978 m_actualFocusedWindow = focusedWindow;
979 }
980 } else {
981 m_actualFocusedWindow = focusedWindow;
982 }
983 }
984 }
985 }
986
987 BOOL AwtFrame::AwtSetActiveWindow(BOOL isMouseEventCause, UINT hittest)
988 {
989 if (hittest == HTCLIENT) {
990 // Don't let the actualFocusedWindow to steal focus if:
991 // a) the frame is clicked in its client area;
992 // b) focus is requested to some of the frame's child.
993 m_actualFocusedWindow = NULL;
994 }
995 return AwtWindow::AwtSetActiveWindow(isMouseEventCause);
996 }
997
998 MsgRouting AwtFrame::WmEnterMenuLoop(BOOL isTrackPopupMenu)
999 {
1000 if ( !isTrackPopupMenu ) {
1001 m_isMenuDropped = TRUE;
1002 }
1003 return mrDoDefault;
1004 }
1005
1006 MsgRouting AwtFrame::WmExitMenuLoop(BOOL isTrackPopupMenu)
1007 {
1008 if ( !isTrackPopupMenu ) {
1009 m_isMenuDropped = FALSE;
1010 }
1011 return mrDoDefault;
1012 }
1013
1014 AwtMenuBar* AwtFrame::GetMenuBar()
1015 {
1016 return menuBar;
1017 }
1018
1019 void AwtFrame::SetMenuBar(AwtMenuBar* mb)
1020 {
1021 menuBar = mb;
1022 if (mb == NULL) {
1023 // Remove existing menu bar, if any.
1024 ::SetMenu(GetHWnd(), NULL);
1025 } else {
1026 if (menuBar->GetHMenu() != NULL) {
1027 ::SetMenu(GetHWnd(), menuBar->GetHMenu());
1028 }
1029 }
1030 }
1031
1032 MsgRouting AwtFrame::WmDrawItem(UINT ctrlId, DRAWITEMSTRUCT& drawInfo)
1033 {
1034 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1035
1036 // if the item to be redrawn is the menu bar, then do it
1037 AwtMenuBar* awtMenubar = GetMenuBar();
1038 if (drawInfo.CtlType == ODT_MENU && (awtMenubar != NULL) &&
1039 (::GetMenu( GetHWnd() ) == (HMENU)drawInfo.hwndItem) )
1040 {
1041 awtMenubar->DrawItem(drawInfo);
1042 return mrConsume;
1043 }
1044
1045 return AwtComponent::WmDrawItem(ctrlId, drawInfo);
1046 }
1047
1048 MsgRouting AwtFrame::WmMeasureItem(UINT ctrlId, MEASUREITEMSTRUCT& measureInfo)
1049 {
1050 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1051 AwtMenuBar* awtMenubar = GetMenuBar();
1052 if ((measureInfo.CtlType == ODT_MENU) && (awtMenubar != NULL))
1053 {
1054 // AwtMenu instance is stored in itemData. Use it to check if this
1055 // menu is the menu bar.
1056 AwtMenu * pMenu = (AwtMenu *) measureInfo.itemData;
1057 DASSERT(pMenu != NULL);
1058 if ( pMenu == awtMenubar )
1059 {
1060 HWND hWnd = GetHWnd();
1061 HDC hDC = ::GetDC(hWnd);
1062 DASSERT(hDC != NULL);
1063 awtMenubar->MeasureItem(hDC, measureInfo);
1064 VERIFY(::ReleaseDC(hWnd, hDC));
1065 return mrConsume;
1066 }
1067 }
1068
1069 return AwtComponent::WmMeasureItem(ctrlId, measureInfo);
1070 }
1071
1072 MsgRouting AwtFrame::WmGetIcon(WPARAM iconType, LRESULT& retVal)
1073 {
1074 //Workaround windows bug:
1075 //when reseting from specific icon to class icon
1076 //taskbar is not updated
1077 if (iconType <= 2 /*ICON_SMALL2*/) {
1078 retVal = (LRESULT)GetEffectiveIcon(iconType);
1079 return mrConsume;
1080 } else {
1081 return mrDoDefault;
1082 }
1083 }
1084
1085 void AwtFrame::DoUpdateIcon()
1086 {
1087 //Workaround windows bug:
1088 //when reseting from specific icon to class icon
1089 //taskbar is not updated
1090 HICON hIcon = GetEffectiveIcon(ICON_BIG);
1091 HICON hIconSm = GetEffectiveIcon(ICON_SMALL);
1092 SendMessage(WM_SETICON, ICON_BIG, (LPARAM)hIcon);
1093 SendMessage(WM_SETICON, ICON_SMALL, (LPARAM)hIconSm);
1094 }
1095
1096 HICON AwtFrame::GetEffectiveIcon(int iconType)
1097 {
1098 BOOL smallIcon = ((iconType == ICON_SMALL) || (iconType == 2/*ICON_SMALL2*/));
1099 HICON hIcon = (smallIcon) ? GetHIconSm() : GetHIcon();
1100 if (hIcon == NULL) {
1101 hIcon = (smallIcon) ? AwtToolkit::GetInstance().GetAwtIconSm() :
1102 AwtToolkit::GetInstance().GetAwtIcon();
1103 }
1104 return hIcon;
1105 }
1106
1107 static BOOL keepOnMinimize(jobject peer) {
1108 static BOOL checked = FALSE;
1109 static BOOL keep = FALSE;
1110 if (!checked) {
1111 keep = (JNU_GetStaticFieldByName(AwtToolkit::GetEnv(), NULL,
1112 "sun/awt/windows/WFramePeer", "keepOnMinimize", "Z").z) == JNI_TRUE;
1113 checked = TRUE;
1114 }
1115 return keep;
1116 }
1117
1118 MsgRouting AwtFrame::WmSysCommand(UINT uCmdType, int xPos, int yPos)
1119 {
1120 // ignore any WM_SYSCOMMAND if this window is blocked by modal dialog
1121 if (::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()))) {
1122 return mrConsume;
1123 }
1124
1125 if (uCmdType == (SYSCOMMAND_IMM & 0xFFF0)){
1126 JNIEnv* env = AwtToolkit::GetEnv();
1127 JNU_CallMethodByName(env, NULL, m_peerObject,
1128 "notifyIMMOptionChange", "()V");
1129 DASSERT(!safe_ExceptionOccurred(env));
1130 return mrConsume;
1131 }
1132 if ((uCmdType == SC_MINIMIZE) && keepOnMinimize(m_peerObject)) {
1133 ::ShowWindow(GetHWnd(),SW_SHOWMINIMIZED);
1134 return mrConsume;
1135 }
1136 return AwtWindow::WmSysCommand(uCmdType, xPos, yPos);
1137 }
1138
1139 LRESULT AwtFrame::WinThreadExecProc(ExecuteArgs * args)
1140 {
1141 switch( args->cmdId ) {
1142 case FRAME_SETMENUBAR:
1143 {
1144 jobject mbPeer = (jobject)args->param1;
1145
1146 // cancel any currently dropped down menus
1147 if (m_isMenuDropped) {
1148 SendMessage(WM_CANCELMODE);
1149 }
1150
1151 if (mbPeer == NULL) {
1152 // Remove existing menu bar, if any
1153 SetMenuBar(NULL);
1154 } else {
1155 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1156 AwtMenuBar* menuBar = (AwtMenuBar *)JNI_GET_PDATA(mbPeer);
1157 SetMenuBar(menuBar);
1158 }
1159 DrawMenuBar();
1160 break;
1161 }
1162
1163 default:
1164 AwtWindow::WinThreadExecProc(args);
1165 break;
1166 }
1167
1168 return 0L;
1169 }
1170
1171 void AwtFrame::_SynthesizeWmActivate(void *param)
1172 {
1173 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1174
1175 SynthesizeWmActivateStruct *sas = (SynthesizeWmActivateStruct *)param;
1176 jobject self = sas->frame;
1177 jboolean doActivate = sas->doActivate;
1178
1179 AwtFrame *frame = NULL;
1180
1181 PDATA pData;
1182 JNI_CHECK_PEER_GOTO(self, ret);
1183 frame = (AwtFrame *)pData;
1184
1185 SynthesizeWmActivate(doActivate, frame->GetHWnd(), NULL);
1186 ret:
1187 env->DeleteGlobalRef(self);
1188
1189 delete sas;
1190 }
1191
1192 jobject AwtFrame::_GetBoundsPrivate(void *param)
1193 {
1194 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1195
1196 jobject self = (jobject)param;
1197
1198 jobject result = NULL;
1199 AwtFrame *f = NULL;
1200
1201 PDATA pData;
1202 JNI_CHECK_PEER_GOTO(self, ret);
1203 f = (AwtFrame *)pData;
1204 if (::IsWindow(f->GetHWnd()))
1205 {
1206 RECT rect;
1207 ::GetWindowRect(f->GetHWnd(), &rect);
1208 HWND parent = ::GetParent(f->GetHWnd());
1209 if (::IsWindow(parent))
1210 {
1211 POINT zero;
1212 zero.x = 0;
1213 zero.y = 0;
1214 ::ClientToScreen(parent, &zero);
1215 ::OffsetRect(&rect, -zero.x, -zero.y);
1216 }
1217
1218 result = JNU_NewObjectByName(env, "java/awt/Rectangle", "(IIII)V",
1219 rect.left, rect.top, rect.bottom-rect.top, rect.right-rect.left);
1220 }
1221 ret:
1222 env->DeleteGlobalRef(self);
1223
1224 if (result != NULL)
1225 {
1226 jobject resultGlobalRef = env->NewGlobalRef(result);
1227 env->DeleteLocalRef(result);
1228 return resultGlobalRef;
1229 }
1230 else
1231 {
1232 return NULL;
1233 }
1234 }
1235
1236 void AwtFrame::_SetState(void *param)
1237 {
1238 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1239
1240 SetStateStruct *sss = (SetStateStruct *)param;
1241 jobject self = sss->frame;
1242 jint state = sss->state;
1243
1244 AwtFrame *f = NULL;
1245
1246 PDATA pData;
1247 JNI_CHECK_PEER_GOTO(self, ret);
1248 f = (AwtFrame *)pData;
1249 HWND hwnd = f->GetHWnd();
1250 if (::IsWindow(hwnd))
1251 {
1252 DASSERT(!IsBadReadPtr(f, sizeof(AwtFrame)));
1253
1254 BOOL iconify = (state & java_awt_Frame_ICONIFIED) != 0;
1255 BOOL zoom = (state & java_awt_Frame_MAXIMIZED_BOTH)
1256 == java_awt_Frame_MAXIMIZED_BOTH;
1257
1258 DTRACE_PRINTLN4("WFramePeer.setState:%s%s ->%s%s",
1259 f->isIconic() ? " iconic" : "",
1260 f->isZoomed() ? " zoomed" : "",
1261 iconify ? " iconic" : "",
1262 zoom ? " zoomed" : "");
1263
1264 if (::IsWindowVisible(hwnd)) {
1265 BOOL focusable = f->IsFocusableWindow();
1266
1267 WINDOWPLACEMENT wp;
1268 ::ZeroMemory(&wp, sizeof(wp));
1269 wp.length = sizeof(wp);
1270 ::GetWindowPlacement(hwnd, &wp);
1271
1272 // Iconify first.
1273 // If both iconify & zoom are TRUE, handle this case
1274 // with wp.flags field below.
1275 if (iconify) {
1276 wp.showCmd = focusable ? SW_MINIMIZE : SW_SHOWMINNOACTIVE;
1277 } else if (zoom) {
1278 wp.showCmd = focusable ? SW_SHOWMAXIMIZED : SW_MAXIMIZE;
1279 } else { // zoom == iconify == FALSE
1280 wp.showCmd = focusable ? SW_RESTORE : SW_SHOWNOACTIVATE;
1281 }
1282
1283 if (zoom && iconify) {
1284 wp.flags |= WPF_RESTORETOMAXIMIZED;
1285 } else {
1286 wp.flags &= ~WPF_RESTORETOMAXIMIZED;
1287 }
1288
1289 if (!zoom) {
1290 f->m_forceResetZoomed = TRUE;
1291 }
1292
1293 // The SetWindowPlacement() causes the WmSize() invocation
1294 // which, in turn, actually updates the m_iconic & m_zoomed flags
1295 // as well as sends Java event (WINDOW_STATE_CHANGED.)
1296 ::SetWindowPlacement(hwnd, &wp);
1297
1298 f->m_forceResetZoomed = FALSE;
1299 } else {
1300 DTRACE_PRINTLN(" not visible, just recording the requested state");
1301
1302 f->setIconic(iconify);
1303 f->setZoomed(zoom);
1304 }
1305 }
1306 ret:
1307 env->DeleteGlobalRef(self);
1308
1309 delete sss;
1310 }
1311
1312 jint AwtFrame::_GetState(void *param)
1313 {
1314 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1315
1316 jobject self = (jobject)param;
1317
1318 jint result = java_awt_Frame_NORMAL;
1319 AwtFrame *f = NULL;
1320
1321 PDATA pData;
1322 JNI_CHECK_PEER_GOTO(self, ret);
1323 f = (AwtFrame *)pData;
1324 if (::IsWindow(f->GetHWnd()))
1325 {
1326 DASSERT(!::IsBadReadPtr(f, sizeof(AwtFrame)));
1327 if (f->isIconic()) {
1328 result |= java_awt_Frame_ICONIFIED;
1329 }
1330 if (f->isZoomed()) {
1331 result |= java_awt_Frame_MAXIMIZED_BOTH;
1332 }
1333
1334 DTRACE_PRINTLN2("WFramePeer.getState:%s%s",
1335 f->isIconic() ? " iconic" : "",
1336 f->isZoomed() ? " zoomed" : "");
1337 }
1338 ret:
1339 env->DeleteGlobalRef(self);
1340
1341 return result;
1342 }
1343
1344 void AwtFrame::_SetMaximizedBounds(void *param)
1345 {
1346 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1347
1348 SetMaximizedBoundsStruct *smbs = (SetMaximizedBoundsStruct *)param;
1349 jobject self = smbs->frame;
1350 int x = smbs->x;
1351 int y = smbs->y;
1352 int width = smbs->width;
1353 int height = smbs->height;
1354
1355 AwtFrame *f = NULL;
1356
1357 PDATA pData;
1358 JNI_CHECK_PEER_GOTO(self, ret);
1359 f = (AwtFrame *)pData;
1360 if (::IsWindow(f->GetHWnd()))
1361 {
1362 DASSERT(!::IsBadReadPtr(f, sizeof(AwtFrame)));
1363 f->SetMaximizedBounds(x, y, width, height);
1364 }
1365 ret:
1366 env->DeleteGlobalRef(self);
1367
1368 delete smbs;
1369 }
1370
1371 void AwtFrame::_ClearMaximizedBounds(void *param)
1372 {
1373 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1374
1375 jobject self = (jobject)param;
1376
1377 AwtFrame *f = NULL;
1378
1379 PDATA pData;
1380 JNI_CHECK_PEER_GOTO(self, ret);
1381 f = (AwtFrame *)pData;
1382 if (::IsWindow(f->GetHWnd()))
1383 {
1384 DASSERT(!::IsBadReadPtr(f, sizeof(AwtFrame)));
1385 f->ClearMaximizedBounds();
1386 }
1387 ret:
1388 env->DeleteGlobalRef(self);
1389 }
1390
1391 void AwtFrame::_SetMenuBar(void *param)
1392 {
1393 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1394
1395 SetMenuBarStruct *smbs = (SetMenuBarStruct *)param;
1396 jobject self = smbs->frame;
1397 jobject menubar = smbs->menubar;
1398
1399 AwtFrame *f = NULL;
1400
1401 PDATA pData;
1402 JNI_CHECK_PEER_GOTO(self, ret);
1403 f = (AwtFrame *)pData;
1404 if (::IsWindow(f->GetHWnd()))
1405 {
1406 ExecuteArgs args;
1407 args.cmdId = FRAME_SETMENUBAR;
1408 args.param1 = (LPARAM)menubar;
1409 f->WinThreadExecProc(&args);
1410 }
1411 ret:
1412 env->DeleteGlobalRef(self);
1413 env->DeleteGlobalRef(menubar);
1414
1415 delete smbs;
1416 }
1417
1418 void AwtFrame::_SetIMMOption(void *param)
1419 {
1420 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1421
1422 SetIMMOptionStruct *sios = (SetIMMOptionStruct *)param;
1423 jobject self = sios->frame;
1424 jstring option = sios->option;
1425
1426 int badAlloc = 0;
1427 LPCTSTR coption;
1428 LPCTSTR empty = TEXT("InputMethod");
1429 AwtFrame *f = NULL;
1430
1431 PDATA pData;
1432 JNI_CHECK_PEER_GOTO(self, ret);
1433 JNI_CHECK_NULL_GOTO(option, "IMMOption argument", ret);
1434
1435 f = (AwtFrame *)pData;
1436 if (::IsWindow(f->GetHWnd()))
1437 {
1438 coption = JNU_GetStringPlatformChars(env, option, NULL);
1439 if (coption == NULL)
1440 {
1441 badAlloc = 1;
1442 }
1443 if (!badAlloc)
1444 {
1445 HMENU hSysMenu = ::GetSystemMenu(f->GetHWnd(), FALSE);
1446 ::AppendMenu(hSysMenu, MF_STRING, SYSCOMMAND_IMM, coption);
1447
1448 if (coption != empty)
1449 {
1450 JNU_ReleaseStringPlatformChars(env, option, coption);
1451 }
1452 }
1453 }
1454 ret:
1455 env->DeleteGlobalRef(self);
1456 env->DeleteGlobalRef(option);
1457
1458 delete sios;
1459
1460 if (badAlloc)
1461 {
1462 throw std::bad_alloc();
1463 }
1464 }
1465
1466 void AwtFrame::_NotifyModalBlocked(void *param)
1467 {
1468 JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1469
1470 NotifyModalBlockedStruct *nmbs = (NotifyModalBlockedStruct *)param;
1471 jobject self = nmbs->frame;
1472 jobject peer = nmbs->peer;
1473 jobject blockerPeer = nmbs->blockerPeer;
1474 jboolean blocked = nmbs->blocked;
1475
1476 PDATA pData;
1477
1478 pData = JNI_GET_PDATA(peer);
1479 AwtFrame *f = (AwtFrame *)pData;
1480
1481 // dialog here may be NULL, for example, if the blocker is a native dialog
1482 // however, we need to install/unistall modal hooks anyway
1483 pData = JNI_GET_PDATA(blockerPeer);
1484 AwtDialog *d = (AwtDialog *)pData;
1485
1486 if ((f != NULL) && ::IsWindow(f->GetHWnd()))
1487 {
1488 // get an HWND of the toplevel window this embedded frame is within
1489 HWND fHWnd = f->GetHWnd();
1490 while (::GetParent(fHWnd) != NULL) {
1491 fHWnd = ::GetParent(fHWnd);
1492 }
1493 // we must get a toplevel hwnd here, however due to some strange
1494 // behaviour of Java Plugin (a bug?) when running in IE at
1495 // this moment the embedded frame hasn't been placed into the
1496 // browser yet and fHWnd is not a toplevel, so we shouldn't install
1497 // the hook here
1498 if ((::GetWindowLong(fHWnd, GWL_STYLE) & WS_CHILD) == 0) {
1499 // if this toplevel is created in another thread, we should install
1500 // the modal hook into it to track window activation and mouse events
1501 DWORD fThread = ::GetWindowThreadProcessId(fHWnd, NULL);
1502 if (fThread != AwtToolkit::GetInstance().MainThread()) {
1503 // check if this thread has been already blocked
1504 BlockedThreadStruct *blockedThread = (BlockedThreadStruct *)sm_BlockedThreads.get((void *)fThread);
1505 if (blocked) {
1506 if (blockedThread == NULL) {
1507 blockedThread = new BlockedThreadStruct;
1508 blockedThread->framesCount = 1;
1509 blockedThread->modalHook = ::SetWindowsHookEx(WH_CBT, (HOOKPROC)AwtDialog::ModalFilterProc,
1510 0, fThread);
1511 blockedThread->mouseHook = ::SetWindowsHookEx(WH_MOUSE, (HOOKPROC)AwtDialog::MouseHookProc_NonTT,
1512 0, fThread);
1513 sm_BlockedThreads.put((void *)fThread, blockedThread);
1514 } else {
1515 blockedThread->framesCount++;
1516 }
1517 } else {
1518 // see the comment above: if Java Plugin behaviour when running in IE
1519 // was right, blockedThread would be always not NULL here
1520 if (blockedThread != NULL) {
1521 DASSERT(blockedThread->framesCount > 0);
1522 if ((blockedThread->framesCount) == 1) {
1523 ::UnhookWindowsHookEx(blockedThread->modalHook);
1524 ::UnhookWindowsHookEx(blockedThread->mouseHook);
1525 sm_BlockedThreads.remove((void *)fThread);
1526 delete blockedThread;
1527 } else {
1528 blockedThread->framesCount--;
1529 }
1530 }
1531 }
1532 }
1533 }
1534 }
1535
1536 env->DeleteGlobalRef(self);
1537 env->DeleteGlobalRef(peer);
1538 env->DeleteGlobalRef(blockerPeer);
1539
1540 delete nmbs;
1541 }
1542
1543 /************************************************************************
1544 * WFramePeer native methods
1545 */
1546
1547 extern "C" {
1548
1549 /*
1550 * Class: java_awt_Frame
1551 * Method: initIDs
1552 * Signature: ()V
1553 */
1554 JNIEXPORT void JNICALL
1555 Java_java_awt_Frame_initIDs(JNIEnv *env, jclass cls)
1556 {
1557 TRY;
1558
1559 AwtFrame::undecoratedID = env->GetFieldID(cls,"undecorated","Z");
1560 DASSERT(AwtFrame::undecoratedID != NULL);
1561
1562 CATCH_BAD_ALLOC;
1563 }
1564
1565 /*
1566 * Class: sun_awt_windows_WFramePeer
1567 * Method: initIDs
1568 * Signature: ()V
1569 */
1570 JNIEXPORT void JNICALL
1571 Java_sun_awt_windows_WFramePeer_initIDs(JNIEnv *env, jclass cls)
1572 {
1573 TRY;
1574
1575 AwtFrame::setExtendedStateMID = env->GetMethodID(cls, "setExtendedState", "(I)V");
1576 AwtFrame::getExtendedStateMID = env->GetMethodID(cls, "getExtendedState", "()I");
1577
1578 DASSERT(AwtFrame::setExtendedStateMID);
1579 DASSERT(AwtFrame::getExtendedStateMID);
1580
1581 CATCH_BAD_ALLOC;
1582 }
1583
1584 /*
1585 * Class: sun_awt_windows_WFramePeer
1586 * Method: setState
1587 * Signature: (I)V
1588 */
1589 JNIEXPORT void JNICALL
1590 Java_sun_awt_windows_WFramePeer_setState(JNIEnv *env, jobject self,
1591 jint state)
1592 {
1593 TRY;
1594
1595 SetStateStruct *sss = new SetStateStruct;
1596 sss->frame = env->NewGlobalRef(self);
1597 sss->state = state;
1598
1599 AwtToolkit::GetInstance().SyncCall(AwtFrame::_SetState, sss);
1600 // global ref and sss are deleted in _SetState()
1601
1602 CATCH_BAD_ALLOC;
1603 }
1604
1605 /*
1606 * Class: sun_awt_windows_WFramePeer
1607 * Method: getState
1608 * Signature: ()I
1609 */
1610 JNIEXPORT jint JNICALL
1611 Java_sun_awt_windows_WFramePeer_getState(JNIEnv *env, jobject self)
1612 {
1613 TRY;
1614
1615 jobject selfGlobalRef = env->NewGlobalRef(self);
1616
1617 return static_cast<jint>(reinterpret_cast<INT_PTR>(AwtToolkit::GetInstance().SyncCall(
1618 (void*(*)(void*))AwtFrame::_GetState,
1619 (void *)selfGlobalRef)));
1620 // selfGlobalRef is deleted in _GetState()
1621
1622 CATCH_BAD_ALLOC_RET(java_awt_Frame_NORMAL);
1623 }
1624
1625
1626 /*
1627 * Class: sun_awt_windows_WFramePeer
1628 * Method: setMaximizedBounds
1629 * Signature: (IIII)V
1630 */
1631 JNIEXPORT void JNICALL
1632 Java_sun_awt_windows_WFramePeer_setMaximizedBounds(JNIEnv *env, jobject self,
1633 jint x, jint y, jint width, jint height)
1634 {
1635 TRY;
1636
1637 SetMaximizedBoundsStruct *smbs = new SetMaximizedBoundsStruct;
1638 smbs->frame = env->NewGlobalRef(self);
1639 smbs->x = x;
1640 smbs->y = y;
1641 smbs->width = width;
1642 smbs->height = height;
1643
1644 AwtToolkit::GetInstance().SyncCall(AwtFrame::_SetMaximizedBounds, smbs);
1645 // global ref and smbs are deleted in _SetMaximizedBounds()
1646
1647 CATCH_BAD_ALLOC;
1648 }
1649
1650
1651 /*
1652 * Class: sun_awt_windows_WFramePeer
1653 * Method: clearMaximizedBounds
1654 * Signature: ()V
1655 */
1656 JNIEXPORT void JNICALL
1657 Java_sun_awt_windows_WFramePeer_clearMaximizedBounds(JNIEnv *env, jobject self)
1658 {
1659 TRY;
1660
1661 jobject selfGlobalRef = env->NewGlobalRef(self);
1662
1663 AwtToolkit::GetInstance().SyncCall(AwtFrame::_ClearMaximizedBounds,
1664 (void *)selfGlobalRef);
1665 // selfGlobalRef is deleted in _ClearMaximizedBounds()
1666
1667 CATCH_BAD_ALLOC;
1668 }
1669
1670
1671 /*
1672 * Class: sun_awt_windows_WFramePeer
1673 * Method: setMenuBar0
1674 * Signature: (Lsun/awt/windows/WMenuBarPeer;)V
1675 */
1676 JNIEXPORT void JNICALL
1677 Java_sun_awt_windows_WFramePeer_setMenuBar0(JNIEnv *env, jobject self,
1678 jobject mbPeer)
1679 {
1680 TRY;
1681
1682 SetMenuBarStruct *smbs = new SetMenuBarStruct;
1683 smbs->frame = env->NewGlobalRef(self);
1684 smbs->menubar = env->NewGlobalRef(mbPeer);
1685
1686 AwtToolkit::GetInstance().SyncCall(AwtFrame::_SetMenuBar, smbs);
1687 // global refs ans smbs are deleted in _SetMenuBar()
1688
1689 CATCH_BAD_ALLOC;
1690 }
1691
1692 /*
1693 * Class: sun_awt_windows_WFramePeer
1694 * Method: create
1695 * Signature: (Lsun/awt/windows/WComponentPeer;)V
1696 */
1697 JNIEXPORT void JNICALL
1698 Java_sun_awt_windows_WFramePeer_createAwtFrame(JNIEnv *env, jobject self,
1699 jobject parent)
1700 {
1701 TRY;
1702
1703 AwtToolkit::CreateComponent(self, parent,
1704 (AwtToolkit::ComponentFactory)
1705 AwtFrame::Create);
1706 PDATA pData;
1707 JNI_CHECK_PEER_CREATION_RETURN(self);
1708
1709 CATCH_BAD_ALLOC;
1710 }
1711
1712 /*
1713 * Class: sun_awt_windows_WFramePeer
1714 * Method: getSysMenuHeight
1715 * Signature: ()I
1716 */
1717 JNIEXPORT jint JNICALL
1718 Java_sun_awt_windows_WFramePeer_getSysMenuHeight(JNIEnv *env, jclass self)
1719 {
1720 TRY;
1721
1722 return ::GetSystemMetrics(SM_CYMENUSIZE);
1723
1724 CATCH_BAD_ALLOC_RET(0);
1725 }
1726
1727 /*
1728 * Class: sun_awt_windows_WFramePeer
1729 * Method: pSetIMMOption
1730 * Signature: (Ljava/lang/String;)V
1731 */
1732 JNIEXPORT void JNICALL
1733 Java_sun_awt_windows_WFramePeer_pSetIMMOption(JNIEnv *env, jobject self,
1734 jstring option)
1735 {
1736 TRY;
1737
1738 SetIMMOptionStruct *sios = new SetIMMOptionStruct;
1739 sios->frame = env->NewGlobalRef(self);
1740 sios->option = (jstring)env->NewGlobalRef(option);
1741
1742 AwtToolkit::GetInstance().SyncCall(AwtFrame::_SetIMMOption, sios);
1743 // global refs and sios are deleted in _SetIMMOption()
1744
1745 CATCH_BAD_ALLOC;
1746 }
1747
1748 } /* extern "C" */
1749
1750
1751 /************************************************************************
1752 * EmbeddedFrame native methods
1753 */
1754
1755 extern "C" {
1756
1757 /*
1758 * Class: sun_awt_EmbeddedFrame
1759 * Method: setPeer
1760 * Signature: (Ljava/awt/peer/ComponentPeer;)V
1761 */
1762 JNIEXPORT void JNICALL
1763 Java_sun_awt_EmbeddedFrame_setPeer(JNIEnv *env, jobject self, jobject lpeer)
1764 {
1765 TRY;
1766
1767 jclass cls;
1768 jfieldID fid;
1769
1770 cls = env->GetObjectClass(self);
1771 fid = env->GetFieldID(cls, "peer", "Ljava/awt/peer/ComponentPeer;");
1772 env->SetObjectField(self, fid, lpeer);
1773
1774 CATCH_BAD_ALLOC;
1775 }
1776
1777 } /* extern "C" */
1778
1779
1780 /************************************************************************
1781 * WEmbeddedFrame native methods
1782 */
1783
1784 extern "C" {
1785
1786 /*
1787 * Class: sun_awt_windows_WFramePeer
1788 * Method: initIDs
1789 * Signature: (Lsun/awt/windows/WMenuBarPeer;)V
1790 */
1791 JNIEXPORT void JNICALL
1792 Java_sun_awt_windows_WEmbeddedFrame_initIDs(JNIEnv *env, jclass cls)
1793 {
1794 TRY;
1795
1796 AwtFrame::handleID = env->GetFieldID(cls, "handle", "J");
1797 DASSERT(AwtFrame::handleID != NULL);
1798
1799 AwtFrame::activateEmbeddingTopLevelMID = env->GetMethodID(cls, "activateEmbeddingTopLevel", "()V");
1800 DASSERT(AwtFrame::activateEmbeddingTopLevelMID != NULL);
1801
1802 CATCH_BAD_ALLOC;
1803 }
1804
1805 JNIEXPORT void JNICALL
1806 Java_sun_awt_windows_WEmbeddedFrame_notifyModalBlockedImpl(JNIEnv *env,
1807 jobject self,
1808 jobject peer,
1809 jobject blockerPeer,
1810 jboolean blocked)
1811 {
1812 TRY;
1813
1814 NotifyModalBlockedStruct *nmbs = new NotifyModalBlockedStruct;
1815 nmbs->frame = env->NewGlobalRef(self);
1816 nmbs->peer = env->NewGlobalRef(peer);
1817 nmbs->blockerPeer = env->NewGlobalRef(blockerPeer);
1818 nmbs->blocked = blocked;
1819
1820 AwtToolkit::GetInstance().SyncCall(AwtFrame::_NotifyModalBlocked, nmbs);
1821 // global refs and nmbs are deleted in _NotifyModalBlocked()
1822
1823 CATCH_BAD_ALLOC;
1824 }
1825
1826 } /* extern "C" */
1827
1828
1829 /************************************************************************
1830 * WEmbeddedFramePeer native methods
1831 */
1832
1833 extern "C" {
1834
1835 JNIEXPORT void JNICALL
1836 Java_sun_awt_windows_WEmbeddedFramePeer_create(JNIEnv *env, jobject self,
1837 jobject parent)
1838 {
1839 TRY;
1840
1841 JNI_CHECK_NULL_RETURN(self, "peer");
1842 AwtToolkit::CreateComponent(self, parent,
1843 (AwtToolkit::ComponentFactory)
1844 AwtFrame::Create);
1845 PDATA pData;
1846 JNI_CHECK_PEER_CREATION_RETURN(self);
1847
1848 CATCH_BAD_ALLOC;
1849 }
1850
1851 JNIEXPORT jobject JNICALL
1852 Java_sun_awt_windows_WEmbeddedFramePeer_getBoundsPrivate(JNIEnv *env, jobject self)
1853 {
1854 TRY;
1855
1856 jobject result = (jobject)AwtToolkit::GetInstance().SyncCall(
1857 (void *(*)(void *))AwtFrame::_GetBoundsPrivate,
1858 env->NewGlobalRef(self));
1859 // global ref is deleted in _GetBoundsPrivate
1860
1861 if (result != NULL)
1862 {
1863 jobject resultLocalRef = env->NewLocalRef(result);
1864 env->DeleteGlobalRef(result);
1865 return resultLocalRef;
1866 }
1867 else
1868 {
1869 return NULL;
1870 }
1871
1872 CATCH_BAD_ALLOC_RET(NULL);
1873 }
1874
1875 JNIEXPORT void JNICALL
1876 Java_sun_awt_windows_WEmbeddedFramePeer_synthesizeWmActivate(JNIEnv *env, jobject self, jboolean doActivate)
1877 {
1878 TRY;
1879
1880 SynthesizeWmActivateStruct *sas = new SynthesizeWmActivateStruct;
1881 sas->frame = env->NewGlobalRef(self);
1882 sas->doActivate = doActivate;
1883
1884 /*
1885 * WARNING: invoking this function without synchronization by m_Sync CriticalSection.
1886 * Taking this lock results in a deadlock.
1887 */
1888 AwtToolkit::GetInstance().InvokeFunction(AwtFrame::_SynthesizeWmActivate, sas);
1889 // global ref and sas are deleted in _SynthesizeWmActivate()
1890
1891 CATCH_BAD_ALLOC;
1892 }
1893
1894 } /* extern "C" */