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