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