       1 /*
       2  * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
       3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       4  *
       5  * This code is free software; you can redistribute it and/or modify it
       6  * under the terms of the GNU General Public License version 2 only, as
       7  * published by the Free Software Foundation.  Oracle designates this
       8  * particular file as subject to the "Classpath" exception as provided
       9  * by Oracle in the LICENSE file that accompanied this code.
      10  *
      11  * This code is distributed in the hope that it will be useful, but WITHOUT
      12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14  * version 2 for more details (a copy is included in the LICENSE file that
      15  * accompanied this code).
      16  *
      17  * You should have received a copy of the GNU General Public License version
      18  * 2 along with this work; if not, write to the Free Software Foundation,
      19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
      20  *
      21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
      22  * or visit www.oracle.com if you need additional information or have any
      23  * questions.
      24  */
      25
      26 #include "awt.h"
      27
      28 #include <windowsx.h>
      29 #include <zmouse.h>
      30
      31 #include "jlong.h"
      32 #include "awt_AWTEvent.h"
      33 #include "awt_BitmapUtil.h"
      34 #include "awt_Component.h"
      35 #include "awt_Cursor.h"
      36 #include "awt_Dimension.h"
      37 #include "awt_Frame.h"
      38 #include "awt_InputEvent.h"
      39 #include "awt_InputTextInfor.h"
      40 #include "awt_Insets.h"
      41 #include "awt_KeyEvent.h"
      42 #include "awt_MenuItem.h"
      43 #include "awt_MouseEvent.h"
      44 #include "awt_Palette.h"
      45 #include "awt_Toolkit.h"
      46 #include "awt_Window.h"
      47 #include "awt_Win32GraphicsDevice.h"
      48 #include "Hashtable.h"
      49 #include "ComCtl32Util.h"
      50
      51 #include <Region.h>
      52
      53 #include <jawt.h>
      54
      55 #include <java_awt_Toolkit.h>
      56 #include <java_awt_FontMetrics.h>
      57 #include <java_awt_Color.h>
      58 #include <java_awt_Event.h>
      59 #include <java_awt_event_KeyEvent.h>
      60 #include <java_awt_Insets.h>
      61 #include <sun_awt_windows_WPanelPeer.h>
      62 #include <java_awt_event_InputEvent.h>
      63 #include <java_awt_event_ActionEvent.h>
      64 #include <java_awt_event_InputMethodEvent.h>
      65 #include <sun_awt_windows_WInputMethod.h>
      66 #include <java_awt_event_MouseEvent.h>
      67 #include <java_awt_event_MouseWheelEvent.h>
      68
      69 // Begin -- Win32 SDK include files
      70 #include <imm.h>
      71 #include <ime.h>
      72 // End -- Win32 SDK include files
      73
      74 #include <awt_DnDDT.h>
      75
      76 LPCTSTR szAwtComponentClassName = TEXT("SunAwtComponent");
      77 // register a message that no other window in the process (even in a plugin
      78 // scenario) will be using
      79 const UINT AwtComponent::WmAwtIsComponent =
      80     ::RegisterWindowMessage(szAwtComponentClassName);
      81
      82 static HWND g_hwndDown = NULL;
      83 static DCList activeDCList;
      84 static DCList passiveDCList;
      85
      86 extern void CheckFontSmoothingSettings(HWND);
      87
      88 extern "C" {
      89     // Remember the input language has changed by some user's action
      90     // (Alt+Shift or through the language icon on the Taskbar) to control the
      91     // race condition between the toolkit thread and the AWT event thread.
      92     // This flag remains TRUE until the next WInputMethod.getNativeLocale() is
      93     // issued.
      94     BOOL g_bUserHasChangedInputLang = FALSE;
      95 }
      96
      97 BOOL AwtComponent::sm_suppressFocusAndActivation = FALSE;
      98 BOOL AwtComponent::sm_restoreFocusAndActivation = FALSE;
      99 HWND AwtComponent::sm_focusOwner = NULL;
     100 HWND AwtComponent::sm_focusedWindow = NULL;
     101 BOOL AwtComponent::sm_bMenuLoop = FALSE;
     102 BOOL AwtComponent::sm_inSynthesizeFocus = FALSE;
     103
     104 /************************************************************************/
     105 // Struct for _Reshape() and ReshapeNoCheck() methods
     106 struct ReshapeStruct {
     107     jobject component;
     108     jint x, y;
     109     jint w, h;
     110 };
     111 // Struct for _NativeHandleEvent() method
     112 struct NativeHandleEventStruct {
     113     jobject component;
     114     jobject event;
     115 };
     116 // Struct for _SetForeground() and _SetBackground() methods
     117 struct SetColorStruct {
     118     jobject component;
     119     jint rgb;
     120 };
     121 // Struct for _SetFont() method
     122 struct SetFontStruct {
     123     jobject component;
     124     jobject font;
     125 };
     126 // Struct for _CreatePrintedPixels() method
     127 struct CreatePrintedPixelsStruct {
     128     jobject component;
     129     int srcx, srcy;
     130     int srcw, srch;
     131     jint alpha;
     132 };
     133 // Struct for _SetRectangularShape() method
     134 struct SetRectangularShapeStruct {
     135     jobject component;
     136     jint x1, x2, y1, y2;
     137     jobject region;
     138 };
     139 // Struct for _GetInsets function
     140 struct GetInsetsStruct {
     141     jobject window;
     142     RECT *insets;
     143 };
     144 // Struct for _SetZOrder function
     145 struct SetZOrderStruct {
     146     jobject component;
     147     jlong above;
     148 };
     149 // Struct for _SetFocus function
     150 struct SetFocusStruct {
     151     jobject component;
     152     jboolean doSetFocus;
     153 };
     154 // Struct for _SetParent function
     155 struct SetParentStruct {
     156     jobject component;
     157     jobject parentComp;
     158 };
     159 /************************************************************************/
     160
     161 //////////////////////////////////////////////////////////////////////////
     162
     163 /*************************************************************************
     164  * AwtComponent fields
     165  */
     166
     167
     168 jfieldID AwtComponent::peerID;
     169 jfieldID AwtComponent::xID;
     170 jfieldID AwtComponent::yID;
     171 jfieldID AwtComponent::widthID;
     172 jfieldID AwtComponent::heightID;
     173 jfieldID AwtComponent::visibleID;
     174 jfieldID AwtComponent::backgroundID;
     175 jfieldID AwtComponent::foregroundID;
     176 jfieldID AwtComponent::enabledID;
     177 jfieldID AwtComponent::parentID;
     178 jfieldID AwtComponent::graphicsConfigID;
     179 jfieldID AwtComponent::peerGCID;
     180 jfieldID AwtComponent::focusableID;
     181 jfieldID AwtComponent::appContextID;
     182 jfieldID AwtComponent::cursorID;
     183 jfieldID AwtComponent::hwndID;
     184
     185 jmethodID AwtComponent::getFontMID;
     186 jmethodID AwtComponent::getToolkitMID;
     187 jmethodID AwtComponent::isEnabledMID;
     188 jmethodID AwtComponent::getLocationOnScreenMID;
     189 jmethodID AwtComponent::replaceSurfaceDataMID;
     190 jmethodID AwtComponent::replaceSurfaceDataLaterMID;
     191 jmethodID AwtComponent::disposeLaterMID;
     192
     193 HKL    AwtComponent::m_hkl = ::GetKeyboardLayout(0);
     194 LANGID AwtComponent::m_idLang = LOWORD(::GetKeyboardLayout(0));
     195 UINT   AwtComponent::m_CodePage
     196                        = AwtComponent::LangToCodePage(m_idLang);
     197
     198 jint *AwtComponent::masks;
     199
     200 static BOOL bLeftShiftIsDown = false;
     201 static BOOL bRightShiftIsDown = false;
     202 static UINT lastShiftKeyPressed = 0; // init to safe value
     203
     204 // Added by waleed to initialize the RTL Flags
     205 BOOL AwtComponent::sm_rtl = PRIMARYLANGID(GetInputLanguage()) == LANG_ARABIC ||
     206                             PRIMARYLANGID(GetInputLanguage()) == LANG_HEBREW;
     207 BOOL AwtComponent::sm_rtlReadingOrder =
     208     PRIMARYLANGID(GetInputLanguage()) == LANG_ARABIC;
     209
     210 BOOL AwtComponent::sm_PrimaryDynamicTableBuilt = FALSE;
     211
     212 HWND AwtComponent::sm_cursorOn;
     213 BOOL AwtComponent::m_QueryNewPaletteCalled = FALSE;
     214
     215 CriticalSection windowMoveLock;
     216 BOOL windowMoveLockHeld = FALSE;
     217
     218 /************************************************************************
     219  * AwtComponent methods
     220  */
     221
     222 AwtComponent::AwtComponent()
     223 {
     224     m_mouseButtonClickAllowed = 0;
     225     m_touchDownOccurred = FALSE;
     226     m_touchUpOccurred = FALSE;
     227     m_touchDownPoint.x = m_touchDownPoint.y = 0;
     228     m_touchUpPoint.x = m_touchUpPoint.y = 0;
     229     m_callbacksEnabled = FALSE;
     230     m_hwnd = NULL;
     231
     232     m_colorForeground = 0;
     233     m_colorBackground = 0;
     234     m_backgroundColorSet = FALSE;
     235     m_penForeground = NULL;
     236     m_brushBackground = NULL;
     237     m_DefWindowProc = NULL;
     238     m_nextControlID = 1;
     239     m_childList = NULL;
     240     m_myControlID = 0;
     241     m_hdwp = NULL;
     242     m_validationNestCount = 0;
     243
     244     m_dropTarget = NULL;
     245
     246     m_InputMethod = NULL;
     247     m_useNativeCompWindow = TRUE;
     248     m_PendingLeadByte = 0;
     249     m_bitsCandType = 0;
     250
     251     windowMoveLockPosX = 0;
     252     windowMoveLockPosY = 0;
     253     windowMoveLockPosCX = 0;
     254     windowMoveLockPosCY = 0;
     255
     256     m_hCursorCache = NULL;
     257
     258     m_bSubclassed = FALSE;
     259     m_bPauseDestroy = FALSE;
     260
     261     m_MessagesProcessing = 0;
     262     m_wheelRotationAmountX = 0;
     263     m_wheelRotationAmountY = 0;
     264     if (!sm_PrimaryDynamicTableBuilt) {
     265         // do it once.
     266         AwtComponent::BuildPrimaryDynamicTable();
     267         sm_PrimaryDynamicTableBuilt = TRUE;
     268     }
     269
     270     deadKeyActive = FALSE;
     271 }
     272
     273 AwtComponent::~AwtComponent()
     274 {
     275     DASSERT(AwtToolkit::IsMainThread());
     276
     277     /*
     278      * All the messages for this component are processed, native
     279      * resources are freed, and Java object is not connected to
     280      * the native one anymore. So we can safely destroy component's
     281      * handle.
     282      */
     283     DestroyHWnd();
     284 }
     285
     286 void AwtComponent::Dispose()
     287 {
     288     DASSERT(AwtToolkit::IsMainThread());
     289
     290     // NOTE: in case the component/toplevel was focused, Java should
     291     // have already taken care of proper transferring it or clearing.
     292
     293     if (m_hdwp != NULL) {
     294     // end any deferred window positioning, regardless
     295     // of m_validationNestCount
     296         ::EndDeferWindowPos(m_hdwp);
     297     }
     298
     299     // Send final message to release all DCs associated with this component
     300     SendMessage(WM_AWT_RELEASE_ALL_DCS);
     301
     302     /* Stop message filtering. */
     303     UnsubclassHWND();
     304
     305     /* Release global ref to input method */
     306     SetInputMethod(NULL, TRUE);
     307
     308     if (m_childList != NULL) {
     309         delete m_childList;
     310         m_childList = NULL;
     311     }
     312
     313     DestroyDropTarget();
     314     ReleaseDragCapture(0);
     315
     316     if (m_myControlID != 0) {
     317         AwtComponent* parent = GetParent();
     318         if (parent != NULL)
     319             parent->RemoveChild(m_myControlID);
     320     }
     321
     322     ::RemoveProp(GetHWnd(), DrawingStateProp);
     323
     324     /* Release any allocated resources. */
     325     if (m_penForeground != NULL) {
     326         m_penForeground->Release();
     327         m_penForeground = NULL;
     328     }
     329     if (m_brushBackground != NULL) {
     330         m_brushBackground->Release();
     331         m_brushBackground = NULL;
     332     }
     333
     334     /* Disconnect all links. */
     335     UnlinkObjects();
     336
     337     if (m_bPauseDestroy) {
     338         // AwtComponent::WmNcDestroy could be released now
     339         m_bPauseDestroy = FALSE;
     340         m_hwnd = NULL;
     341     }
     342
     343     // The component instance is deleted using AwtObject::Dispose() method
     344     AwtObject::Dispose();
     345 }
     346
     347 /* store component pointer in window extra bytes */
     348 void AwtComponent::SetComponentInHWND() {
     349     DASSERT(::GetWindowLongPtr(GetHWnd(), GWLP_USERDATA) == NULL);
     350     ::SetWindowLongPtr(GetHWnd(), GWLP_USERDATA, (LONG_PTR)this);
     351 }
     352
     353 /*
     354  * static function to get AwtComponent pointer from hWnd --
     355  * you don't want to call this from inside a wndproc to avoid
     356  * infinite recursion
     357  */
     358 AwtComponent* AwtComponent::GetComponent(HWND hWnd) {
     359     // Requests for Toolkit hwnd resolution happen pretty often. Check first.
     360     if (hWnd == AwtToolkit::GetInstance().GetHWnd()) {
     361         return NULL;
     362     }
     363
     364     // check that it's an AWT component from the same toolkit as the caller
     365     if (::IsWindow(hWnd) &&
     366         AwtToolkit::MainThread() == ::GetWindowThreadProcessId(hWnd, NULL))
     367     {
     368         DASSERT(WmAwtIsComponent != 0);
     369         if (::SendMessage(hWnd, WmAwtIsComponent, 0, 0L)) {
     370             return GetComponentImpl(hWnd);
     371         }
     372     }
     373     return NULL;
     374 }
     375
     376 /*
     377  * static function to get AwtComponent pointer from hWnd--
     378  * different from GetComponent because caller knows the
     379  * hwnd is an AWT component hwnd
     380  */
     381 AwtComponent* AwtComponent::GetComponentImpl(HWND hWnd) {
     382     AwtComponent *component =
     383         (AwtComponent *)::GetWindowLongPtr(hWnd, GWLP_USERDATA);
     384     DASSERT(!component || !IsBadReadPtr(component, sizeof(AwtComponent)) );
     385     DASSERT(!component || component->GetHWnd() == hWnd );
     386     return component;
     387 }
     388
     389 /*
     390  * Single window proc for all the components. Delegates real work to
     391  * the component's WindowProc() member function.
     392  */
     393 LRESULT CALLBACK AwtComponent::WndProc(HWND hWnd, UINT message,
     394                                        WPARAM wParam, LPARAM lParam)
     395 {
     396     TRY;
     397
     398     AwtComponent * self = AwtComponent::GetComponentImpl(hWnd);
     399     if (self == NULL || self->GetHWnd() != hWnd ||
     400         message == WM_UNDOCUMENTED_CLIENTSHUTDOWN) // handle log-off gracefully
     401     {
     402         return ComCtl32Util::GetInstance().DefWindowProc(NULL, hWnd, message, wParam, lParam);
     403     } else {
     404         return self->WindowProc(message, wParam, lParam);
     405     }
     406
     407     CATCH_BAD_ALLOC_RET(0);
     408 }
     409
     410 BOOL AwtComponent::IsFocusable() {
     411     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
     412     jobject peer = GetPeer(env);
     413     jobject target = env->GetObjectField(peer, AwtObject::targetID);
     414     BOOL res = env->GetBooleanField(target, focusableID);
     415     AwtWindow *pCont = GetContainer();
     416     if (pCont) {
     417         res &= pCont->IsFocusableWindow();
     418     }
     419     env->DeleteLocalRef(target);
     420     return res;
     421 }
     422
     423 /************************************************************************
     424  * AwtComponent dynamic methods
     425  *
     426  * Window class registration routines
     427  */
     428
     429 /*
     430  * Fix for 4964237: Win XP: Changing theme changes java dialogs title icon
     431  */
     432 void AwtComponent::FillClassInfo(WNDCLASSEX *lpwc)
     433 {
     434     lpwc->cbSize        = sizeof(WNDCLASSEX);
     435     lpwc->style         = 0L;//CS_OWNDC;
     436     lpwc->lpfnWndProc   = (WNDPROC)::DefWindowProc;
     437     lpwc->cbClsExtra    = 0;
     438     lpwc->cbWndExtra    = 0;
     439     lpwc->hInstance     = AwtToolkit::GetInstance().GetModuleHandle(),
     440     lpwc->hIcon         = AwtToolkit::GetInstance().GetAwtIcon();
     441     lpwc->hCursor       = NULL;
     442     lpwc->hbrBackground = NULL;
     443     lpwc->lpszMenuName  = NULL;
     444     lpwc->lpszClassName = GetClassName();
     445     //Fixed 6233560: PIT: Java Cup Logo on the title bar of top-level windows look blurred, Win32
     446     lpwc->hIconSm       = AwtToolkit::GetInstance().GetAwtIconSm();
     447 }
     448
     449 void AwtComponent::RegisterClass()
     450 {
     451     WNDCLASSEX wc;
     452     if (!::GetClassInfoEx(AwtToolkit::GetInstance().GetModuleHandle(), GetClassName(), &wc)) {
     453         FillClassInfo(&wc);
     454         ATOM ret = ::RegisterClassEx(&wc);
     455         DASSERT(ret != 0);
     456     }
     457 }
     458
     459 void AwtComponent::UnregisterClass()
     460 {
     461     ::UnregisterClass(GetClassName(), AwtToolkit::GetInstance().GetModuleHandle());
     462 }
     463
     464 /*
     465  * Copy the graphicsConfig reference from Component into WComponentPeer
     466  */
     467 void AwtComponent::InitPeerGraphicsConfig(JNIEnv *env, jobject peer)
     468 {
     469     jobject target = env->GetObjectField(peer, AwtObject::targetID);
     470     //Get graphicsConfig object ref from Component
     471     jobject compGC = env->GetObjectField(target,
     472                       AwtComponent::graphicsConfigID);
     473
     474     //Set peer's graphicsConfig to Component's graphicsConfig
     475     if (compGC != NULL) {
     476         jclass win32GCCls = env->FindClass("sun/awt/Win32GraphicsConfig");
     477         DASSERT(win32GCCls != NULL);
     478         DASSERT(env->IsInstanceOf(compGC, win32GCCls));
     479         if (win32GCCls == NULL) {
     480             throw std::bad_alloc();
     481         }
     482         env->SetObjectField(peer, AwtComponent::peerGCID, compGC);
     483     }
     484 }
     485
     486 void
     487 AwtComponent::CreateHWnd(JNIEnv *env, LPCWSTR title,
     488                          DWORD windowStyle,
     489                          DWORD windowExStyle,
     490                          int x, int y, int w, int h,
     491                          HWND hWndParent, HMENU hMenu,
     492                          COLORREF colorForeground,
     493                          COLORREF colorBackground,
     494                          jobject peer)
     495 {
     496     if (env->EnsureLocalCapacity(2) < 0) {
     497         return;
     498     }
     499
     500     /*
     501      * The window class of multifont label must be "BUTTON" because
     502      * "STATIC" class can't get WM_DRAWITEM message, and m_peerObject
     503      * member is referred in the GetClassName method of AwtLabel class.
     504      * So m_peerObject member must be set here.
     505      */
     506     if (m_peerObject == NULL) {
     507         m_peerObject = env->NewGlobalRef(peer);
     508     } else {
     509         assert(env->IsSameObject(m_peerObject, peer));
     510     }
     511
     512     RegisterClass();
     513
     514     jobject target = env->GetObjectField(peer, AwtObject::targetID);
     515     jboolean visible = env->GetBooleanField(target, AwtComponent::visibleID);
     516     m_visible = visible;
     517
     518     if (visible) {
     519         windowStyle |= WS_VISIBLE;
     520     } else {
     521         windowStyle &= ~WS_VISIBLE;
     522     }
     523
     524     InitPeerGraphicsConfig(env, peer);
     525
     526     SetLastError(0);
     527     HWND hwnd = ::CreateWindowEx(windowExStyle,
     528                                  GetClassName(),
     529                                  title,
     530                                  windowStyle,
     531                                  x, y, w, h,
     532                                  hWndParent,
     533                                  hMenu,
     534                                  AwtToolkit::GetInstance().GetModuleHandle(),
     535                                  NULL);
     536
     537     // fix for 5088782
     538     // check if CreateWindowsEx() returns not null value and if it does -
     539     //   create an InternalError or OutOfMemoryError based on GetLastError().
     540     //   This error is set to createError field of WObjectPeer and then
     541     //   checked and thrown in WComponentPeer constructor. We can't throw an
     542     //   error here because this code is invoked on Toolkit thread
     543     if (hwnd == NULL)
     544     {
     545         DWORD dw = ::GetLastError();
     546         jobject createError = NULL;
     547         if (dw == ERROR_OUTOFMEMORY)
     548         {
     549             jstring errorMsg = JNU_NewStringPlatform(env, L"too many window handles");
     550             if (errorMsg == NULL || env->ExceptionCheck()) {
     551                 env->ExceptionClear();
     552                 createError = JNU_NewObjectByName(env, "java/lang/OutOfMemoryError", "()V");
     553             } else {
     554                 createError = JNU_NewObjectByName(env, "java/lang/OutOfMemoryError",
     555                                                       "(Ljava/lang/String;)V",
     556                                                       errorMsg);
     557                 env->DeleteLocalRef(errorMsg);
     558             }
     559         }
     560         else
     561         {
     562             TCHAR *buf;
     563             FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
     564                 NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
     565                 (LPTSTR)&buf, 0, NULL);
     566             jstring s = JNU_NewStringPlatform(env, buf);
     567             if (s == NULL || env->ExceptionCheck()) {
     568                 env->ExceptionClear();
     569                 createError = JNU_NewObjectByName(env, "java/lang/InternalError", "()V");
     570             } else {
     571                 createError = JNU_NewObjectByName(env, "java/lang/InternalError",
     572                                                                   "(Ljava/lang/String;)V", s);
     573                 env->DeleteLocalRef(s);
     574             }
     575             LocalFree(buf);
     576         }
     577         if (createError != NULL) {
     578             env->SetObjectField(peer, AwtObject::createErrorID, createError);
     579             env->DeleteLocalRef(createError);
     580         }
     581         env->DeleteLocalRef(target);
     582         return;
     583     }
     584
     585     m_hwnd = hwnd;
     586
     587     ::ImmAssociateContext(m_hwnd, NULL);
     588
     589     SetDrawState((jint)JAWT_LOCK_SURFACE_CHANGED |
     590         (jint)JAWT_LOCK_BOUNDS_CHANGED |
     591         (jint)JAWT_LOCK_CLIP_CHANGED);
     592
     593     LinkObjects(env, peer);
     594
     595     /* Subclass the window now so that we can snoop on its messages */
     596     SubclassHWND();
     597
     598     AwtToolkit& tk = AwtToolkit::GetInstance();
     599     if (tk.IsWin8OrLater() && tk.IsTouchKeyboardAutoShowEnabled()) {
     600         tk.TIRegisterTouchWindow(GetHWnd(), TWF_WANTPALM);
     601     }
     602
     603     /*
     604       * Fix for 4046446.
     605       */
     606     SetWindowPos(GetHWnd(), 0, x, y, w, h, SWP_NOZORDER | SWP_NOCOPYBITS | SWP_NOACTIVATE);
     607
     608     /* Set default colors. */
     609     m_colorForeground = colorForeground;
     610     m_colorBackground = colorBackground;
     611
     612     /*
     613      * Only set background color if the color is actually set on the
     614      * target -- this avoids inheriting a parent's color unnecessarily,
     615      * and has to be done here because there isn't an API to get the
     616      * real background color from outside the AWT package.
     617      */
     618     jobject bkgrd = env->GetObjectField(target, AwtComponent::backgroundID) ;
     619     if (bkgrd != NULL) {
     620         JNU_CallMethodByName(env, NULL, peer, "setBackground",
     621                              "(Ljava/awt/Color;)V", bkgrd);
     622         DASSERT(!safe_ExceptionOccurred(env));
     623     }
     624     env->DeleteLocalRef(target);
     625     env->DeleteLocalRef(bkgrd);
     626 }
     627
     628 /*
     629  * Destroy this window's HWND
     630  */
     631 void AwtComponent::DestroyHWnd() {
     632     if (m_hwnd != NULL) {
     633         AwtToolkit::DestroyComponentHWND(m_hwnd);
     634         //AwtToolkit::DestroyComponent(this);
     635         m_hwnd = NULL;
     636     }
     637 }
     638
     639 /*
     640  * Returns hwnd for target on non Toolkit thread
     641  */
     642 HWND
     643 AwtComponent::GetHWnd(JNIEnv* env, jobject target) {
     644     if (JNU_IsNull(env, target)) {
     645         return 0;
     646     }
     647     jobject peer = env->GetObjectField(target, AwtComponent::peerID);
     648     if (JNU_IsNull(env, peer)) {
     649         return 0;
     650     }
     651     HWND hwnd = reinterpret_cast<HWND>(static_cast<LONG_PTR> (
     652         env->GetLongField(peer, AwtComponent::hwndID)));
     653     env->DeleteLocalRef(peer);
     654     return hwnd;
     655 }
     656 //
     657 // Propagate the background color to synchronize Java field and peer's field.
     658 // This is needed to fix 4148334
     659 //
     660 void AwtComponent::UpdateBackground(JNIEnv *env, jobject target)
     661 {
     662     if (env->EnsureLocalCapacity(1) < 0) {
     663         return;
     664     }
     665
     666     jobject bkgrnd = env->GetObjectField(target, AwtComponent::backgroundID);
     667
     668     if (bkgrnd == NULL) {
     669         bkgrnd = JNU_NewObjectByName(env, "java/awt/Color", "(III)V",
     670                                      GetRValue(m_colorBackground),
     671                                      GetGValue(m_colorBackground),
     672                                      GetBValue(m_colorBackground));
     673         if (bkgrnd != NULL) {
     674             env->SetObjectField(target, AwtComponent::backgroundID, bkgrnd);
     675         }
     676     }
     677     env->DeleteLocalRef(bkgrnd);
     678 }
     679
     680 /*
     681  * Install our window proc as the proc for our HWND, and save off the
     682  * previous proc as the default
     683  */
     684 void AwtComponent::SubclassHWND()
     685 {
     686     if (m_bSubclassed) {
     687         return;
     688     }
     689     const WNDPROC wndproc = WndProc; // let compiler type check WndProc
     690     m_DefWindowProc = ComCtl32Util::GetInstance().SubclassHWND(GetHWnd(), wndproc);
     691     m_bSubclassed = TRUE;
     692 }
     693
     694 /*
     695  * Reinstall the original window proc as the proc for our HWND
     696  */
     697 void AwtComponent::UnsubclassHWND()
     698 {
     699     if (!m_bSubclassed) {
     700         return;
     701     }
     702     ComCtl32Util::GetInstance().UnsubclassHWND(GetHWnd(), WndProc, m_DefWindowProc);
     703     m_bSubclassed = FALSE;
     704 }
     705
     706 /////////////////////////////////////
     707 // (static method)
     708 // Determines the top-level ancestor for a given window. If the given
     709 // window is a top-level window, return itself.
     710 //
     711 // 'Top-level' includes dialogs as well.
     712 //
     713 HWND AwtComponent::GetTopLevelParentForWindow(HWND hwndDescendant) {
     714     if (hwndDescendant == NULL) {
     715         return NULL;
     716     }
     717
     718     DASSERT(IsWindow(hwndDescendant));
     719     HWND hwnd = hwndDescendant;
     720     for(;;) {
     721         DWORD style = ::GetWindowLong(hwnd, GWL_STYLE);
     722         // a) found a non-child window so terminate
     723         // b) found real toplevel window (e.g. EmbeddedFrame
     724         //    that is child though)
     725         if ( (style & WS_CHILD) == 0 ||
     726              AwtComponent::IsTopLevelHWnd(hwnd) )
     727         {
     728             break;
     729         }
     730         hwnd = ::GetParent(hwnd);
     731     }
     732
     733     return hwnd;
     734 }
     735 ////////////////////
     736
     737 jobject AwtComponent::FindHeavyweightUnderCursor(BOOL useCache) {
     738     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
     739     if (env->EnsureLocalCapacity(1) < 0) {
     740         return NULL;
     741     }
     742
     743     HWND hit = NULL;
     744     POINT p = { 0, 0 };
     745     AwtComponent *comp = NULL;
     746
     747     if (useCache) {
     748         if (sm_cursorOn == NULL) {
     749             return NULL;
     750         }
     751
     752
     753         DASSERT(::IsWindow(sm_cursorOn));
     754         VERIFY(::GetCursorPos(&p));
     755         /*
     756          * Fix for BugTraq ID 4304024.
     757          * Allow a non-default cursor only for the client area.
     758          */
     759         comp = AwtComponent::GetComponent(sm_cursorOn);
     760         if (comp != NULL &&
     761             ::SendMessage(sm_cursorOn, WM_NCHITTEST, 0,
     762                           MAKELPARAM(p.x, p.y)) == HTCLIENT) {
     763             goto found;
     764         }
     765     }
     766
     767     ::GetCursorPos(&p);
     768     hit = ::WindowFromPoint(p);
     769     while (hit != NULL) {
     770         comp = AwtComponent::GetComponent(hit);
     771
     772         if (comp != NULL) {
     773             INT nHittest = (INT)::SendMessage(hit, WM_NCHITTEST,
     774                                           0, MAKELPARAM(p.x, p.y));
     775             /*
     776              * Fix for BugTraq ID 4304024.
     777              * Allow a non-default cursor only for the client area.
     778              */
     779             if (nHittest != HTCLIENT) {
     780                 /*
     781                  * When over the non-client area, send WM_SETCURSOR
     782                  * to revert the cursor to an arrow.
     783                  */
     784                 ::SendMessage(hit, WM_SETCURSOR, (WPARAM)hit,
     785                               MAKELPARAM(nHittest, WM_MOUSEMOVE));
     786                 return NULL;
     787             } else {
     788               sm_cursorOn = hit;
     789               goto found;
     790             }
     791         }
     792
     793         if ((::GetWindowLong(hit, GWL_STYLE) & WS_CHILD) == 0) {
     794             return NULL;
     795         }
     796         hit = ::GetParent(hit);
     797     }
     798
     799     return NULL;
     800
     801 found:
     802     jobject localRef = comp->GetTarget(env);
     803     jobject globalRef = env->NewGlobalRef(localRef);
     804     env->DeleteLocalRef(localRef);
     805     return globalRef;
     806 }
     807
     808 void AwtComponent::SetColor(COLORREF c)
     809 {
     810     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
     811     int grayscale = AwtWin32GraphicsDevice::GetGrayness(screen);
     812     if (grayscale != GS_NOTGRAY) {
     813         int g;
     814
     815         g = (int) (.299 * (c & 0xFF) + .587 * ((c >> 8) & 0xFF) +
     816             .114 * ((c >> 16) & 0xFF) + 0.5);
     817         // c = g | (g << 8) | (g << 16);
     818         c = PALETTERGB(g, g, g);
     819     }
     820
     821     if (m_colorForeground == c) {
     822         return;
     823     }
     824
     825     m_colorForeground = c;
     826     if (m_penForeground != NULL) {
     827         m_penForeground->Release();
     828         m_penForeground = NULL;
     829     }
     830     VERIFY(::InvalidateRect(GetHWnd(), NULL, FALSE));
     831 }
     832
     833 void AwtComponent::SetBackgroundColor(COLORREF c)
     834 {
     835     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
     836     int grayscale = AwtWin32GraphicsDevice::GetGrayness(screen);
     837     if (grayscale != GS_NOTGRAY) {
     838         int g;
     839
     840         g = (int) (.299 * (c & 0xFF) + .587 * ((c >> 8) & 0xFF) +
     841             .114 * ((c >> 16) & 0xFF) + 0.5);
     842         // c = g | (g << 8) | (g << 16);
     843         c = PALETTERGB(g, g, g);
     844     }
     845
     846     if (m_colorBackground == c) {
     847         return;
     848     }
     849     m_colorBackground = c;
     850     m_backgroundColorSet = TRUE;
     851     if (m_brushBackground != NULL) {
     852         m_brushBackground->Release();
     853         m_brushBackground = NULL;
     854     }
     855     VERIFY(::InvalidateRect(GetHWnd(), NULL, TRUE));
     856 }
     857
     858 HPEN AwtComponent::GetForegroundPen()
     859 {
     860     if (m_penForeground == NULL) {
     861         m_penForeground = AwtPen::Get(m_colorForeground);
     862     }
     863     return (HPEN)m_penForeground->GetHandle();
     864 }
     865
     866 COLORREF AwtComponent::GetBackgroundColor()
     867 {
     868     if (m_backgroundColorSet == FALSE) {
     869         AwtComponent* c = this;
     870         while ((c = c->GetParent()) != NULL) {
     871             if (c->IsBackgroundColorSet()) {
     872                 return c->GetBackgroundColor();
     873             }
     874         }
     875     }
     876     return m_colorBackground;
     877 }
     878
     879 HBRUSH AwtComponent::GetBackgroundBrush()
     880 {
     881     if (m_backgroundColorSet == FALSE) {
     882         if (m_brushBackground != NULL) {
     883             m_brushBackground->Release();
     884             m_brushBackground = NULL;
     885         }
     886           AwtComponent* c = this;
     887           while ((c = c->GetParent()) != NULL) {
     888               if (c->IsBackgroundColorSet()) {
     889                   m_brushBackground =
     890                       AwtBrush::Get(c->GetBackgroundColor());
     891                   break;
     892               }
     893           }
     894     }
     895     if (m_brushBackground == NULL) {
     896         m_brushBackground = AwtBrush::Get(m_colorBackground);
     897     }
     898     return (HBRUSH)m_brushBackground->GetHandle();
     899 }
     900
     901 void AwtComponent::SetFont(AwtFont* font)
     902 {
     903     DASSERT(font != NULL);
     904     if (font->GetAscent() < 0) {
     905         AwtFont::SetupAscent(font);
     906     }
     907     SendMessage(WM_SETFONT, (WPARAM)font->GetHFont(), MAKELPARAM(FALSE, 0));
     908     VERIFY(::InvalidateRect(GetHWnd(), NULL, TRUE));
     909 }
     910
     911 AwtComponent* AwtComponent::GetParent()
     912 {
     913     HWND hwnd = ::GetParent(GetHWnd());
     914     if (hwnd == NULL) {
     915         return NULL;
     916     }
     917     return GetComponent(hwnd);
     918 }
     919
     920 AwtWindow* AwtComponent::GetContainer()
     921 {
     922     AwtComponent* comp = this;
     923     while (comp != NULL) {
     924         if (comp->IsContainer()) {
     925             return (AwtWindow*)comp;
     926         }
     927         comp = comp->GetParent();
     928     }
     929     return NULL;
     930 }
     931
     932 void AwtComponent::Show()
     933 {
     934     m_visible = true;
     935     ::ShowWindow(GetHWnd(), SW_SHOWNA);
     936 }
     937
     938 void AwtComponent::Hide()
     939 {
     940     m_visible = false;
     941     ::ShowWindow(GetHWnd(), SW_HIDE);
     942 }
     943
     944 BOOL
     945 AwtComponent::SetWindowPos(HWND wnd, HWND after,
     946                            int x, int y, int w, int h, UINT flags)
     947 {
     948     // Conditions we shouldn't handle:
     949     // z-order changes, correct window dimensions
     950     if (after != NULL || (w < 32767 && h < 32767)
     951         || ((::GetWindowLong(wnd, GWL_STYLE) & WS_CHILD) == 0))
     952     {
     953         return ::SetWindowPos(wnd, after, x, y, w, h, flags);
     954     }
     955     WINDOWPLACEMENT wp;
     956     ::ZeroMemory(&wp, sizeof(wp));
     957
     958     wp.length = sizeof(wp);
     959     ::GetWindowPlacement(wnd, &wp);
     960     wp.rcNormalPosition.left = x;
     961     wp.rcNormalPosition.top = y;
     962     wp.rcNormalPosition.right = x + w;
     963     wp.rcNormalPosition.bottom = y + h;
     964     if ( flags & SWP_NOACTIVATE ) {
     965         wp.showCmd = SW_SHOWNOACTIVATE;
     966     }
     967     ::SetWindowPlacement(wnd, &wp);
     968     return 1;
     969 }
     970
     971 void AwtComponent::Reshape(int x, int y, int w, int h) {
     972     ReshapeNoScale(ScaleUpX(x), ScaleUpY(y), ScaleUpX(w), ScaleUpY(h));
     973 }
     974
     975 void AwtComponent::ReshapeNoScale(int x, int y, int w, int h)
     976 {
     977 #if defined(DEBUG)
     978     RECT        rc;
     979     ::GetWindowRect(GetHWnd(), &rc);
     980     ::MapWindowPoints(HWND_DESKTOP, ::GetParent(GetHWnd()), (LPPOINT)&rc, 2);
     981     DTRACE_PRINTLN4("AwtComponent::Reshape from %d, %d, %d, %d", rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top);
     982 #endif
     983
     984     AwtWindow* container = GetContainer();
     985     AwtComponent* parent = GetParent();
     986     if (container != NULL && container == parent) {
     987         container->SubtractInsetPoint(x, y);
     988     }
     989     DTRACE_PRINTLN4("AwtComponent::Reshape to %d, %d, %d, %d", x, y, w, h);
     990     UINT flags = SWP_NOACTIVATE | SWP_NOZORDER;
     991
     992     RECT        r;
     993
     994     ::GetWindowRect(GetHWnd(), &r);
     995     // if the component size is changing , don't copy window bits
     996     if (r.right - r.left != w || r.bottom - r.top != h) {
     997         flags |= SWP_NOCOPYBITS;
     998     }
     999
    1000     if (parent && _tcscmp(parent->GetClassName(), TEXT("SunAwtScrollPane")) == 0) {
    1001         if (x > 0) {
    1002             x = 0;
    1003         }
    1004         if (y > 0) {
    1005             y = 0;
    1006         }
    1007     }
    1008     if (m_hdwp != NULL) {
    1009         m_hdwp = ::DeferWindowPos(m_hdwp, GetHWnd(), 0, x, y, w, h, flags);
    1010         DASSERT(m_hdwp != NULL);
    1011     } else {
    1012         /*
    1013          * Fox for 4046446
    1014          * If window has dimensions above the short int limit, ::SetWindowPos doesn't work.
    1015          * We should use SetWindowPlacement instead.
    1016          */
    1017         SetWindowPos(GetHWnd(), 0, x, y, w, h, flags);
    1018     }
    1019 }
    1020
    1021 void AwtComponent::SetScrollValues(UINT bar, int min, int value, int max)
    1022 {
    1023     int minTmp, maxTmp;
    1024
    1025     ::GetScrollRange(GetHWnd(), bar, &minTmp, &maxTmp);
    1026     if (min == INT_MAX) {
    1027         min = minTmp;
    1028     }
    1029     if (value == INT_MAX) {
    1030         value = ::GetScrollPos(GetHWnd(), bar);
    1031     }
    1032     if (max == INT_MAX) {
    1033         max = maxTmp;
    1034     }
    1035     if (min == max) {
    1036         max++;
    1037     }
    1038     ::SetScrollRange(GetHWnd(), bar, min, max, FALSE);
    1039     ::SetScrollPos(GetHWnd(), bar, value, TRUE);
    1040 }
    1041
    1042 /*
    1043  * Save Global Reference of sun.awt.windows.WInputMethod object
    1044  */
    1045 void AwtComponent::SetInputMethod(jobject im, BOOL useNativeCompWindow)
    1046 {
    1047     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    1048
    1049     if (m_InputMethod!=NULL)
    1050         env->DeleteGlobalRef(m_InputMethod);
    1051
    1052     if (im!=NULL){
    1053         m_InputMethod = env->NewGlobalRef(im);
    1054         m_useNativeCompWindow = useNativeCompWindow;
    1055     } else {
    1056         m_InputMethod = NULL;
    1057         m_useNativeCompWindow = TRUE;
    1058     }
    1059
    1060 }
    1061
    1062 /*
    1063  * Opportunity to process and/or eat a message before it is dispatched
    1064  */
    1065 MsgRouting AwtComponent::PreProcessMsg(MSG& msg)
    1066 {
    1067     return mrPassAlong;
    1068 }
    1069
    1070 static UINT lastMessage = WM_NULL;
    1071
    1072 #ifndef SPY_MESSAGES
    1073 #define SpyWinMessage(hwin,msg,str)
    1074 #else
    1075
    1076 #define FMT_MSG(x,y) case x: _stprintf(szBuf, \
    1077     "0x%8.8x(%s):%s\n", hwnd, szComment, y); break;
    1078 #define WIN_MSG(x) FMT_MSG(x,#x)
    1079
    1080 void SpyWinMessage(HWND hwnd, UINT message, LPCTSTR szComment) {
    1081
    1082     TCHAR szBuf[256];
    1083
    1084     switch (message) {
    1085         WIN_MSG(WM_NULL)
    1086         WIN_MSG(WM_CREATE)
    1087         WIN_MSG(WM_DESTROY)
    1088         WIN_MSG(WM_MOVE)
    1089         WIN_MSG(WM_SIZE)
    1090         WIN_MSG(WM_ACTIVATE)
    1091         WIN_MSG(WM_SETFOCUS)
    1092         WIN_MSG(WM_KILLFOCUS)
    1093         WIN_MSG(WM_ENABLE)
    1094         WIN_MSG(WM_SETREDRAW)
    1095         WIN_MSG(WM_SETTEXT)
    1096         WIN_MSG(WM_GETTEXT)
    1097         WIN_MSG(WM_GETTEXTLENGTH)
    1098         WIN_MSG(WM_PAINT)
    1099         WIN_MSG(WM_CLOSE)
    1100         WIN_MSG(WM_QUERYENDSESSION)
    1101         WIN_MSG(WM_QUIT)
    1102         WIN_MSG(WM_QUERYOPEN)
    1103         WIN_MSG(WM_ERASEBKGND)
    1104         WIN_MSG(WM_SYSCOLORCHANGE)
    1105         WIN_MSG(WM_ENDSESSION)
    1106         WIN_MSG(WM_SHOWWINDOW)
    1107         FMT_MSG(WM_WININICHANGE,"WM_WININICHANGE/WM_SETTINGCHANGE")
    1108         WIN_MSG(WM_DEVMODECHANGE)
    1109         WIN_MSG(WM_ACTIVATEAPP)
    1110         WIN_MSG(WM_FONTCHANGE)
    1111         WIN_MSG(WM_TIMECHANGE)
    1112         WIN_MSG(WM_CANCELMODE)
    1113         WIN_MSG(WM_SETCURSOR)
    1114         WIN_MSG(WM_MOUSEACTIVATE)
    1115         WIN_MSG(WM_CHILDACTIVATE)
    1116         WIN_MSG(WM_QUEUESYNC)
    1117         WIN_MSG(WM_GETMINMAXINFO)
    1118         WIN_MSG(WM_PAINTICON)
    1119         WIN_MSG(WM_ICONERASEBKGND)
    1120         WIN_MSG(WM_NEXTDLGCTL)
    1121         WIN_MSG(WM_SPOOLERSTATUS)
    1122         WIN_MSG(WM_DRAWITEM)
    1123         WIN_MSG(WM_MEASUREITEM)
    1124         WIN_MSG(WM_DELETEITEM)
    1125         WIN_MSG(WM_VKEYTOITEM)
    1126         WIN_MSG(WM_CHARTOITEM)
    1127         WIN_MSG(WM_SETFONT)
    1128         WIN_MSG(WM_GETFONT)
    1129         WIN_MSG(WM_SETHOTKEY)
    1130         WIN_MSG(WM_GETHOTKEY)
    1131         WIN_MSG(WM_QUERYDRAGICON)
    1132         WIN_MSG(WM_COMPAREITEM)
    1133         FMT_MSG(0x003D, "WM_GETOBJECT")
    1134         WIN_MSG(WM_COMPACTING)
    1135         WIN_MSG(WM_COMMNOTIFY)
    1136         WIN_MSG(WM_WINDOWPOSCHANGING)
    1137         WIN_MSG(WM_WINDOWPOSCHANGED)
    1138         WIN_MSG(WM_POWER)
    1139         WIN_MSG(WM_COPYDATA)
    1140         WIN_MSG(WM_CANCELJOURNAL)
    1141         WIN_MSG(WM_NOTIFY)
    1142         WIN_MSG(WM_INPUTLANGCHANGEREQUEST)
    1143         WIN_MSG(WM_INPUTLANGCHANGE)
    1144         WIN_MSG(WM_TCARD)
    1145         WIN_MSG(WM_HELP)
    1146         WIN_MSG(WM_USERCHANGED)
    1147         WIN_MSG(WM_NOTIFYFORMAT)
    1148         WIN_MSG(WM_CONTEXTMENU)
    1149         WIN_MSG(WM_STYLECHANGING)
    1150         WIN_MSG(WM_STYLECHANGED)
    1151         WIN_MSG(WM_DISPLAYCHANGE)
    1152         WIN_MSG(WM_GETICON)
    1153         WIN_MSG(WM_SETICON)
    1154         WIN_MSG(WM_NCCREATE)
    1155         WIN_MSG(WM_NCDESTROY)
    1156         WIN_MSG(WM_NCCALCSIZE)
    1157         WIN_MSG(WM_NCHITTEST)
    1158         WIN_MSG(WM_NCPAINT)
    1159         WIN_MSG(WM_NCACTIVATE)
    1160         WIN_MSG(WM_GETDLGCODE)
    1161         WIN_MSG(WM_SYNCPAINT)
    1162         WIN_MSG(WM_NCMOUSEMOVE)
    1163         WIN_MSG(WM_NCLBUTTONDOWN)
    1164         WIN_MSG(WM_NCLBUTTONUP)
    1165         WIN_MSG(WM_NCLBUTTONDBLCLK)
    1166         WIN_MSG(WM_NCRBUTTONDOWN)
    1167         WIN_MSG(WM_NCRBUTTONUP)
    1168         WIN_MSG(WM_NCRBUTTONDBLCLK)
    1169         WIN_MSG(WM_NCMBUTTONDOWN)
    1170         WIN_MSG(WM_NCMBUTTONUP)
    1171         WIN_MSG(WM_NCMBUTTONDBLCLK)
    1172         WIN_MSG(WM_KEYDOWN)
    1173         WIN_MSG(WM_KEYUP)
    1174         WIN_MSG(WM_CHAR)
    1175         WIN_MSG(WM_DEADCHAR)
    1176         WIN_MSG(WM_SYSKEYDOWN)
    1177         WIN_MSG(WM_SYSKEYUP)
    1178         WIN_MSG(WM_SYSCHAR)
    1179         WIN_MSG(WM_SYSDEADCHAR)
    1180         WIN_MSG(WM_IME_STARTCOMPOSITION)
    1181         WIN_MSG(WM_IME_ENDCOMPOSITION)
    1182         WIN_MSG(WM_IME_COMPOSITION)
    1183         WIN_MSG(WM_INITDIALOG)
    1184         WIN_MSG(WM_COMMAND)
    1185         WIN_MSG(WM_SYSCOMMAND)
    1186         WIN_MSG(WM_TIMER)
    1187         WIN_MSG(WM_HSCROLL)
    1188         WIN_MSG(WM_VSCROLL)
    1189         WIN_MSG(WM_INITMENU)
    1190         WIN_MSG(WM_INITMENUPOPUP)
    1191         WIN_MSG(WM_MENUSELECT)
    1192         WIN_MSG(WM_MENUCHAR)
    1193         WIN_MSG(WM_ENTERIDLE)
    1194         FMT_MSG(0x0122, "WM_MENURBUTTONUP")
    1195         FMT_MSG(0x0123, "WM_MENUDRAG")
    1196         FMT_MSG(0x0124, "WM_MENUGETOBJECT")
    1197         FMT_MSG(0x0125, "WM_UNINITMENUPOPUP")
    1198         FMT_MSG(0x0126, "WM_MENUCOMMAND")
    1199         WIN_MSG(WM_CTLCOLORMSGBOX)
    1200         WIN_MSG(WM_CTLCOLOREDIT)
    1201         WIN_MSG(WM_CTLCOLORLISTBOX)
    1202         WIN_MSG(WM_CTLCOLORBTN)
    1203         WIN_MSG(WM_CTLCOLORDLG)
    1204         WIN_MSG(WM_CTLCOLORSCROLLBAR)
    1205         WIN_MSG(WM_CTLCOLORSTATIC)
    1206         WIN_MSG(WM_MOUSEMOVE)
    1207         WIN_MSG(WM_LBUTTONDOWN)
    1208         WIN_MSG(WM_LBUTTONUP)
    1209         WIN_MSG(WM_LBUTTONDBLCLK)
    1210         WIN_MSG(WM_RBUTTONDOWN)
    1211         WIN_MSG(WM_RBUTTONUP)
    1212         WIN_MSG(WM_RBUTTONDBLCLK)
    1213         WIN_MSG(WM_MBUTTONDOWN)
    1214         WIN_MSG(WM_MBUTTONUP)
    1215         WIN_MSG(WM_MBUTTONDBLCLK)
    1216         WIN_MSG(WM_XBUTTONDBLCLK)
    1217         WIN_MSG(WM_XBUTTONDOWN)
    1218         WIN_MSG(WM_XBUTTONUP)
    1219         WIN_MSG(WM_MOUSEWHEEL)
    1220         WIN_MSG(WM_MOUSEHWHEEL)
    1221         WIN_MSG(WM_PARENTNOTIFY)
    1222         WIN_MSG(WM_ENTERMENULOOP)
    1223         WIN_MSG(WM_EXITMENULOOP)
    1224         WIN_MSG(WM_NEXTMENU)
    1225         WIN_MSG(WM_SIZING)
    1226         WIN_MSG(WM_CAPTURECHANGED)
    1227         WIN_MSG(WM_MOVING)
    1228         WIN_MSG(WM_POWERBROADCAST)
    1229         WIN_MSG(WM_DEVICECHANGE)
    1230         WIN_MSG(WM_MDICREATE)
    1231         WIN_MSG(WM_MDIDESTROY)
    1232         WIN_MSG(WM_MDIACTIVATE)
    1233         WIN_MSG(WM_MDIRESTORE)
    1234         WIN_MSG(WM_MDINEXT)
    1235         WIN_MSG(WM_MDIMAXIMIZE)
    1236         WIN_MSG(WM_MDITILE)
    1237         WIN_MSG(WM_MDICASCADE)
    1238         WIN_MSG(WM_MDIICONARRANGE)
    1239         WIN_MSG(WM_MDIGETACTIVE)
    1240         WIN_MSG(WM_MDISETMENU)
    1241         WIN_MSG(WM_ENTERSIZEMOVE)
    1242         WIN_MSG(WM_EXITSIZEMOVE)
    1243         WIN_MSG(WM_DROPFILES)
    1244         WIN_MSG(WM_MDIREFRESHMENU)
    1245         WIN_MSG(WM_IME_SETCONTEXT)
    1246         WIN_MSG(WM_IME_NOTIFY)
    1247         WIN_MSG(WM_IME_CONTROL)
    1248         WIN_MSG(WM_IME_COMPOSITIONFULL)
    1249         WIN_MSG(WM_IME_SELECT)
    1250         WIN_MSG(WM_IME_CHAR)
    1251         FMT_MSG(WM_IME_REQUEST)
    1252         WIN_MSG(WM_IME_KEYDOWN)
    1253         WIN_MSG(WM_IME_KEYUP)
    1254         FMT_MSG(0x02A1, "WM_MOUSEHOVER")
    1255         FMT_MSG(0x02A3, "WM_MOUSELEAVE")
    1256         WIN_MSG(WM_CUT)
    1257         WIN_MSG(WM_COPY)
    1258         WIN_MSG(WM_PASTE)
    1259         WIN_MSG(WM_CLEAR)
    1260         WIN_MSG(WM_UNDO)
    1261         WIN_MSG(WM_RENDERFORMAT)
    1262         WIN_MSG(WM_RENDERALLFORMATS)
    1263         WIN_MSG(WM_DESTROYCLIPBOARD)
    1264         WIN_MSG(WM_DRAWCLIPBOARD)
    1265         WIN_MSG(WM_PAINTCLIPBOARD)
    1266         WIN_MSG(WM_VSCROLLCLIPBOARD)
    1267         WIN_MSG(WM_SIZECLIPBOARD)
    1268         WIN_MSG(WM_ASKCBFORMATNAME)
    1269         WIN_MSG(WM_CHANGECBCHAIN)
    1270         WIN_MSG(WM_HSCROLLCLIPBOARD)
    1271         WIN_MSG(WM_QUERYNEWPALETTE)
    1272         WIN_MSG(WM_PALETTEISCHANGING)
    1273         WIN_MSG(WM_PALETTECHANGED)
    1274         WIN_MSG(WM_HOTKEY)
    1275         WIN_MSG(WM_PRINT)
    1276         WIN_MSG(WM_PRINTCLIENT)
    1277         WIN_MSG(WM_HANDHELDFIRST)
    1278         WIN_MSG(WM_HANDHELDLAST)
    1279         WIN_MSG(WM_AFXFIRST)
    1280         WIN_MSG(WM_AFXLAST)
    1281         WIN_MSG(WM_PENWINFIRST)
    1282         WIN_MSG(WM_PENWINLAST)
    1283         WIN_MSG(WM_AWT_COMPONENT_CREATE)
    1284         WIN_MSG(WM_AWT_DESTROY_WINDOW)
    1285         WIN_MSG(WM_AWT_MOUSEENTER)
    1286         WIN_MSG(WM_AWT_MOUSEEXIT)
    1287         WIN_MSG(WM_AWT_COMPONENT_SHOW)
    1288         WIN_MSG(WM_AWT_COMPONENT_HIDE)
    1289         WIN_MSG(WM_AWT_COMPONENT_SETFOCUS)
    1290         WIN_MSG(WM_AWT_WINDOW_SETACTIVE)
    1291         WIN_MSG(WM_AWT_LIST_SETMULTISELECT)
    1292         WIN_MSG(WM_AWT_HANDLE_EVENT)
    1293         WIN_MSG(WM_AWT_PRINT_COMPONENT)
    1294         WIN_MSG(WM_AWT_RESHAPE_COMPONENT)
    1295         WIN_MSG(WM_AWT_SETALWAYSONTOP)
    1296         WIN_MSG(WM_AWT_BEGIN_VALIDATE)
    1297         WIN_MSG(WM_AWT_END_VALIDATE)
    1298         WIN_MSG(WM_AWT_FORWARD_CHAR)
    1299         WIN_MSG(WM_AWT_FORWARD_BYTE)
    1300         WIN_MSG(WM_AWT_SET_SCROLL_INFO)
    1301         WIN_MSG(WM_AWT_CREATECONTEXT)
    1302         WIN_MSG(WM_AWT_DESTROYCONTEXT)
    1303         WIN_MSG(WM_AWT_ASSOCIATECONTEXT)
    1304         WIN_MSG(WM_AWT_GET_DEFAULT_IME_HANDLER)
    1305         WIN_MSG(WM_AWT_HANDLE_NATIVE_IME_EVENT)
    1306         WIN_MSG(WM_AWT_PRE_KEYDOWN)
    1307         WIN_MSG(WM_AWT_PRE_KEYUP)
    1308         WIN_MSG(WM_AWT_PRE_SYSKEYDOWN)
    1309         WIN_MSG(WM_AWT_PRE_SYSKEYUP)
    1310         WIN_MSG(WM_AWT_ENDCOMPOSITION,)
    1311         WIN_MSG(WM_AWT_DISPOSE,)
    1312         WIN_MSG(WM_AWT_DELETEOBJECT,)
    1313         WIN_MSG(WM_AWT_SETCONVERSIONSTATUS,)
    1314         WIN_MSG(WM_AWT_GETCONVERSIONSTATUS,)
    1315         WIN_MSG(WM_AWT_SETOPENSTATUS,)
    1316         WIN_MSG(WM_AWT_GETOPENSTATUS)
    1317         WIN_MSG(WM_AWT_ACTIVATEKEYBOARDLAYOUT)
    1318         WIN_MSG(WM_AWT_OPENCANDIDATEWINDOW)
    1319         WIN_MSG(WM_AWT_DLG_SHOWMODAL,)
    1320         WIN_MSG(WM_AWT_DLG_ENDMODAL,)
    1321         WIN_MSG(WM_AWT_SETCURSOR,)
    1322         WIN_MSG(WM_AWT_WAIT_FOR_SINGLE_OBJECT,)
    1323         WIN_MSG(WM_AWT_INVOKE_METHOD,)
    1324         WIN_MSG(WM_AWT_INVOKE_VOID_METHOD,)
    1325         WIN_MSG(WM_AWT_EXECUTE_SYNC,)
    1326         WIN_MSG(WM_AWT_CURSOR_SYNC)
    1327         WIN_MSG(WM_AWT_GETDC)
    1328         WIN_MSG(WM_AWT_RELEASEDC)
    1329         WIN_MSG(WM_AWT_RELEASE_ALL_DCS)
    1330         WIN_MSG(WM_AWT_SHOWCURSOR)
    1331         WIN_MSG(WM_AWT_HIDECURSOR)
    1332         WIN_MSG(WM_AWT_CREATE_PRINTED_PIXELS)
    1333         WIN_MSG(WM_AWT_OBJECTLISTCLEANUP)
    1334         default:
    1335             sprintf(szBuf, "0x%8.8x(%s):Unknown message 0x%8.8x\n",
    1336                 hwnd, szComment, message);
    1337             break;
    1338     }
    1339     printf(szBuf);
    1340 }
    1341
    1342 #endif /* SPY_MESSAGES */
    1343
    1344 /*
    1345  * Dispatch messages for this window class--general component
    1346  */
    1347 LRESULT AwtComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    1348 {
    1349     CounterHelper ch(&m_MessagesProcessing);
    1350
    1351     JNILocalFrame lframe(AwtToolkit::GetEnv(), 10);
    1352     SpyWinMessage(GetHWnd(), message,
    1353         (message == WM_AWT_RELEASE_ALL_DCS) ? TEXT("Disposed Component") : GetClassName());
    1354
    1355     LRESULT retValue = 0;
    1356     MsgRouting mr = mrDoDefault;
    1357     AwtToolkit::GetInstance().eventNumber++;
    1358
    1359     static BOOL ignoreNextLBTNUP = FALSE; //Ignore next LBUTTONUP msg?
    1360
    1361     lastMessage = message;
    1362
    1363     if (message == WmAwtIsComponent) {
    1364     // special message to identify AWT HWND's without using
    1365     // resource hogging ::SetProp
    1366         return (LRESULT)TRUE;
    1367     }
    1368
    1369     DWORD curPos = 0;
    1370
    1371     UINT switchMessage = message;
    1372     switch (switchMessage) {
    1373       case WM_AWT_GETDC:
    1374       {
    1375             HDC hDC;
    1376             // First, release the DCs scheduled for deletion
    1377             ReleaseDCList(GetHWnd(), passiveDCList);
    1378
    1379             GetDCReturnStruct *returnStruct = new GetDCReturnStruct;
    1380             returnStruct->gdiLimitReached = FALSE;
    1381             if (AwtGDIObject::IncrementIfAvailable()) {
    1382                 hDC = ::GetDCEx(GetHWnd(), NULL,
    1383                                 DCX_CACHE | DCX_CLIPCHILDREN |
    1384                                 DCX_CLIPSIBLINGS);
    1385                 if (hDC != NULL) {
    1386                     // Add new DC to list of DC's associated with this Component
    1387                     activeDCList.AddDC(hDC, GetHWnd());
    1388                 } else {
    1389                     // Creation failed; decrement counter in AwtGDIObject
    1390                     AwtGDIObject::Decrement();
    1391                 }
    1392             } else {
    1393                 hDC = NULL;
    1394                 returnStruct->gdiLimitReached = TRUE;
    1395             }
    1396             returnStruct->hDC = hDC;
    1397             retValue = (LRESULT)returnStruct;
    1398             mr = mrConsume;
    1399             break;
    1400       }
    1401       case WM_AWT_RELEASEDC:
    1402       {
    1403             HDC hDC = (HDC)wParam;
    1404             MoveDCToPassiveList(hDC, GetHWnd());
    1405             ReleaseDCList(GetHWnd(), passiveDCList);
    1406             mr = mrConsume;
    1407             break;
    1408       }
    1409       case WM_AWT_RELEASE_ALL_DCS:
    1410       {
    1411             // Called during Component destruction.  Gets current list of
    1412             // DC's associated with Component and releases each DC.
    1413             ReleaseDCList(GetHWnd(), activeDCList);
    1414             ReleaseDCList(GetHWnd(), passiveDCList);
    1415             mr = mrConsume;
    1416             break;
    1417       }
    1418       case WM_AWT_SHOWCURSOR:
    1419           ::ShowCursor(TRUE);
    1420           break;
    1421       case WM_AWT_HIDECURSOR:
    1422           ::ShowCursor(FALSE);
    1423           break;
    1424       case WM_CREATE: mr = WmCreate(); break;
    1425       case WM_CLOSE:      mr = WmClose(); break;
    1426       case WM_DESTROY:    mr = WmDestroy(); break;
    1427       case WM_NCDESTROY:  mr = WmNcDestroy(); break;
    1428
    1429       case WM_ERASEBKGND:
    1430           mr = WmEraseBkgnd((HDC)wParam, *(BOOL*)&retValue); break;
    1431       case WM_PAINT:
    1432           CheckFontSmoothingSettings(GetHWnd());
    1433           /* Set draw state */
    1434           SetDrawState(GetDrawState() | JAWT_LOCK_CLIP_CHANGED);
    1435           mr = WmPaint((HDC)wParam);
    1436           break;
    1437
    1438       case WM_GETMINMAXINFO:
    1439           mr = WmGetMinMaxInfo((LPMINMAXINFO)lParam);
    1440           break;
    1441
    1442       case WM_WINDOWPOSCHANGING:
    1443       {
    1444           // We process this message so that we can synchronize access to
    1445           // a moving window.  The Scale/Blt functions in Win32BlitLoops
    1446           // take the same windowMoveLock to ensure that a window is not
    1447           // moving while we are trying to copy pixels into it.
    1448           WINDOWPOS *lpPosInfo = (WINDOWPOS *)lParam;
    1449           if ((lpPosInfo->flags & (SWP_NOMOVE | SWP_NOSIZE)) !=
    1450               (SWP_NOMOVE | SWP_NOSIZE))
    1451           {
    1452               // Move or Size command.
    1453               // Windows tends to send erroneous events that the window
    1454               // is about to move when the coordinates are exactly the
    1455               // same as the last time.  This can cause problems with
    1456               // our windowMoveLock CriticalSection because we enter it
    1457               // here and never get to WM_WINDOWPOSCHANGED to release it.
    1458               // So make sure this is a real move/size event before bothering
    1459               // to grab the critical section.
    1460               BOOL takeLock = FALSE;
    1461               if (!(lpPosInfo->flags & SWP_NOMOVE) &&
    1462                   ((windowMoveLockPosX != lpPosInfo->x) ||
    1463                    (windowMoveLockPosY != lpPosInfo->y)))
    1464               {
    1465                   // Real move event
    1466                   takeLock = TRUE;
    1467                   windowMoveLockPosX = lpPosInfo->x;
    1468                   windowMoveLockPosY = lpPosInfo->y;
    1469               }
    1470               if (!(lpPosInfo->flags & SWP_NOSIZE) &&
    1471                   ((windowMoveLockPosCX != lpPosInfo->cx) ||
    1472                    (windowMoveLockPosCY != lpPosInfo->cy)))
    1473               {
    1474                   // Real size event
    1475                   takeLock = TRUE;
    1476                   windowMoveLockPosCX = lpPosInfo->cx;
    1477                   windowMoveLockPosCY = lpPosInfo->cy;
    1478               }
    1479               if (takeLock) {
    1480                   if (!windowMoveLockHeld) {
    1481                       windowMoveLock.Enter();
    1482                       windowMoveLockHeld = TRUE;
    1483                   }
    1484               }
    1485           }
    1486           mr = WmWindowPosChanging(lParam);
    1487           break;
    1488       }
    1489       case WM_WINDOWPOSCHANGED:
    1490       {
    1491           // Release lock grabbed in the POSCHANGING message
    1492           if (windowMoveLockHeld) {
    1493               windowMoveLockHeld = FALSE;
    1494               windowMoveLock.Leave();
    1495           }
    1496           mr = WmWindowPosChanged(lParam);
    1497           break;
    1498       }
    1499       case WM_MOVE: {
    1500           RECT r;
    1501           ::GetWindowRect(GetHWnd(), &r);
    1502           mr = WmMove(r.left, r.top);
    1503           break;
    1504       }
    1505       case WM_SIZE:
    1506       {
    1507           RECT r;
    1508           // fix 4128317 : use GetClientRect for full 32-bit int precision and
    1509           // to avoid negative client area dimensions overflowing 16-bit params - robi
    1510           ::GetClientRect( GetHWnd(), &r );
    1511           mr = WmSize(static_cast<UINT>(wParam), r.right - r.left, r.bottom - r.top);
    1512           //mr = WmSize(wParam, LOWORD(lParam), HIWORD(lParam));
    1513           SetCompositionWindow(r);
    1514           break;
    1515       }
    1516       case WM_SIZING:
    1517           mr = WmSizing();
    1518           break;
    1519       case WM_SHOWWINDOW:
    1520           mr = WmShowWindow(static_cast<BOOL>(wParam),
    1521                             static_cast<UINT>(lParam)); break;
    1522       case WM_SYSCOMMAND:
    1523           mr = WmSysCommand(static_cast<UINT>(wParam & 0xFFF0),
    1524                             GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
    1525           break;
    1526       case WM_ENTERSIZEMOVE:
    1527           mr = WmEnterSizeMove();
    1528           break;
    1529       case WM_EXITSIZEMOVE:
    1530           mr = WmExitSizeMove();
    1531           break;
    1532       // Bug #4039858 (Selecting menu item causes bogus mouse click event)
    1533       case WM_ENTERMENULOOP:
    1534           mr = WmEnterMenuLoop((BOOL)wParam);
    1535           sm_bMenuLoop = TRUE;
    1536           // we need to release grab if menu is shown
    1537           if (AwtWindow::GetGrabbedWindow() != NULL) {
    1538               AwtWindow::GetGrabbedWindow()->Ungrab();
    1539           }
    1540           break;
    1541       case WM_EXITMENULOOP:
    1542           mr = WmExitMenuLoop((BOOL)wParam);
    1543           sm_bMenuLoop = FALSE;
    1544           break;
    1545
    1546       // We don't expect any focus messages on non-proxy component,
    1547       // except those that came from Java.
    1548       case WM_SETFOCUS:
    1549           if (sm_inSynthesizeFocus) {
    1550               mr = WmSetFocus((HWND)wParam);
    1551           } else {
    1552               mr = mrConsume;
    1553           }
    1554           break;
    1555       case WM_KILLFOCUS:
    1556           if (sm_inSynthesizeFocus) {
    1557               mr = WmKillFocus((HWND)wParam);
    1558           } else {
    1559               mr = mrConsume;
    1560           }
    1561           break;
    1562       case WM_ACTIVATE: {
    1563           UINT nState = LOWORD(wParam);
    1564           BOOL fMinimized = (BOOL)HIWORD(wParam);
    1565           mr = mrConsume;
    1566
    1567           if (!sm_suppressFocusAndActivation &&
    1568               (!fMinimized || (nState == WA_INACTIVE)))
    1569           {
    1570               mr = WmActivate(nState, fMinimized, (HWND)lParam);
    1571
    1572               // When the window is deactivated, send WM_IME_ENDCOMPOSITION
    1573               // message to deactivate the composition window so that
    1574               // it won't receive keyboard input focus.
    1575               HIMC hIMC;
    1576               HWND hwnd = ImmGetHWnd();
    1577               if ((hIMC = ImmGetContext(hwnd)) != NULL) {
    1578                   ImmReleaseContext(hwnd, hIMC);
    1579                   DefWindowProc(WM_IME_ENDCOMPOSITION, 0, 0);
    1580               }
    1581           }
    1582           break;
    1583       }
    1584       case WM_MOUSEACTIVATE: {
    1585           AwtWindow *window = GetContainer();
    1586           if (window && window->IsFocusableWindow()) {
    1587               // AWT/Swing will later request focus to a proper component
    1588               // on handling the Java mouse event. Anyway, we have to
    1589               // activate the window here as it works both for AWT & Swing.
    1590               // Do it in our own fassion,
    1591               window->AwtSetActiveWindow(TRUE, LOWORD(lParam)/*hittest*/);
    1592           }
    1593           mr = mrConsume;
    1594           retValue = MA_NOACTIVATE;
    1595           break;
    1596       }
    1597       case WM_CTLCOLORMSGBOX:
    1598       case WM_CTLCOLOREDIT:
    1599       case WM_CTLCOLORLISTBOX:
    1600       case WM_CTLCOLORBTN:
    1601       case WM_CTLCOLORDLG:
    1602       case WM_CTLCOLORSCROLLBAR:
    1603       case WM_CTLCOLORSTATIC:
    1604           mr = WmCtlColor((HDC)wParam, (HWND)lParam,
    1605                           message-WM_CTLCOLORMSGBOX+CTLCOLOR_MSGBOX,
    1606                           *(HBRUSH*)&retValue);
    1607           break;
    1608       case WM_HSCROLL:
    1609           mr = WmHScroll(LOWORD(wParam), HIWORD(wParam), (HWND)lParam);
    1610           break;
    1611       case WM_VSCROLL:
    1612           mr = WmVScroll(LOWORD(wParam), HIWORD(wParam), (HWND)lParam);
    1613           break;
    1614       // 4664415: We're seeing a WM_LBUTTONUP when the user releases the
    1615       // mouse button after a WM_NCLBUTTONDBLCLK.  We want to ignore this
    1616       // WM_LBUTTONUP, so we set a flag in WM_NCLBUTTONDBLCLK and look for the
    1617       // flag on a WM_LBUTTONUP.  -bchristi
    1618       case WM_NCLBUTTONDBLCLK:
    1619           mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON | DBL_CLICK);
    1620           if (mr == mrDoDefault) {
    1621               ignoreNextLBTNUP = TRUE;
    1622           }
    1623           break;
    1624       case WM_NCLBUTTONDOWN:
    1625           mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON);
    1626           ignoreNextLBTNUP = FALSE;
    1627           break;
    1628       case WM_NCLBUTTONUP:
    1629           mr = WmNcMouseUp(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON);
    1630           break;
    1631       case WM_NCRBUTTONDOWN:
    1632            mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), RIGHT_BUTTON);
    1633            break;
    1634       case WM_LBUTTONUP:
    1635           if (ignoreNextLBTNUP) {
    1636               ignoreNextLBTNUP = FALSE;
    1637               return mrDoDefault;
    1638           }
    1639           //fall-through
    1640       case WM_LBUTTONDOWN:
    1641           ignoreNextLBTNUP = FALSE;
    1642           //fall-through
    1643       case WM_LBUTTONDBLCLK:
    1644       case WM_RBUTTONDOWN:
    1645       case WM_RBUTTONDBLCLK:
    1646       case WM_RBUTTONUP:
    1647       case WM_MBUTTONDOWN:
    1648       case WM_MBUTTONDBLCLK:
    1649       case WM_MBUTTONUP:
    1650       case WM_XBUTTONDBLCLK:
    1651       case WM_XBUTTONDOWN:
    1652       case WM_XBUTTONUP:
    1653       case WM_MOUSEMOVE:
    1654       case WM_MOUSEWHEEL:
    1655       case WM_MOUSEHWHEEL:
    1656       case WM_AWT_MOUSEENTER:
    1657       case WM_AWT_MOUSEEXIT:
    1658           curPos = ::GetMessagePos();
    1659           POINT myPos;
    1660           myPos.x = GET_X_LPARAM(curPos);
    1661           myPos.y = GET_Y_LPARAM(curPos);
    1662           ::ScreenToClient(GetHWnd(), &myPos);
    1663           switch(switchMessage) {
    1664           case WM_AWT_MOUSEENTER:
    1665               mr = WmMouseEnter(static_cast<UINT>(wParam), myPos.x, myPos.y);
    1666               break;
    1667           case WM_LBUTTONDOWN:
    1668           case WM_LBUTTONDBLCLK:
    1669               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1670                                LEFT_BUTTON);
    1671               break;
    1672           case WM_LBUTTONUP:
    1673               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1674                              LEFT_BUTTON);
    1675               break;
    1676           case WM_MOUSEMOVE:
    1677               mr = WmMouseMove(static_cast<UINT>(wParam), myPos.x, myPos.y);
    1678               break;
    1679           case WM_MBUTTONDOWN:
    1680           case WM_MBUTTONDBLCLK:
    1681               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1682                                MIDDLE_BUTTON);
    1683               break;
    1684           case WM_XBUTTONDOWN:
    1685           case WM_XBUTTONDBLCLK:
    1686               if (AwtToolkit::GetInstance().areExtraMouseButtonsEnabled()) {
    1687                   if (HIWORD(wParam) == 1) {
    1688                       mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1689                                        X1_BUTTON);
    1690                   }
    1691                   if (HIWORD(wParam) == 2) {
    1692                       mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1693                                        X2_BUTTON);
    1694                   }
    1695               }
    1696               break;
    1697           case WM_XBUTTONUP:
    1698               if (AwtToolkit::GetInstance().areExtraMouseButtonsEnabled()) {
    1699                   if (HIWORD(wParam) == 1) {
    1700                       mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1701                                      X1_BUTTON);
    1702                   }
    1703                   if (HIWORD(wParam) == 2) {
    1704                       mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1705                                      X2_BUTTON);
    1706                   }
    1707               }
    1708               break;
    1709           case WM_RBUTTONDOWN:
    1710           case WM_RBUTTONDBLCLK:
    1711               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1712                                RIGHT_BUTTON);
    1713               break;
    1714           case WM_RBUTTONUP:
    1715               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1716                              RIGHT_BUTTON);
    1717               break;
    1718           case WM_MBUTTONUP:
    1719               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
    1720                              MIDDLE_BUTTON);
    1721               break;
    1722           case WM_AWT_MOUSEEXIT:
    1723               mr = WmMouseExit(static_cast<UINT>(wParam), myPos.x, myPos.y);
    1724               break;
    1725           case WM_MOUSEWHEEL:
    1726           case WM_MOUSEHWHEEL:
    1727               mr = WmMouseWheel(GET_KEYSTATE_WPARAM(wParam),
    1728                                 GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
    1729                                 GET_WHEEL_DELTA_WPARAM(wParam),
    1730                                 switchMessage == WM_MOUSEHWHEEL);
    1731               break;
    1732           }
    1733           break;
    1734       case WM_TOUCH:
    1735           WmTouch(wParam, lParam);
    1736           break;
    1737       case WM_SETCURSOR:
    1738           mr = mrDoDefault;
    1739           if (LOWORD(lParam) == HTCLIENT) {
    1740               if (AwtComponent* comp =
    1741                                     AwtComponent::GetComponent((HWND)wParam)) {
    1742                   AwtCursor::UpdateCursor(comp);
    1743                   mr = mrConsume;
    1744               }
    1745           }
    1746           break;
    1747
    1748       case WM_KEYDOWN:
    1749           mr = WmKeyDown(static_cast<UINT>(wParam),
    1750                          LOWORD(lParam), HIWORD(lParam), FALSE);
    1751           break;
    1752       case WM_KEYUP:
    1753           mr = WmKeyUp(static_cast<UINT>(wParam),
    1754                        LOWORD(lParam), HIWORD(lParam), FALSE);
    1755           break;
    1756       case WM_SYSKEYDOWN:
    1757           mr = WmKeyDown(static_cast<UINT>(wParam),
    1758                          LOWORD(lParam), HIWORD(lParam), TRUE);
    1759           break;
    1760       case WM_SYSKEYUP:
    1761           mr = WmKeyUp(static_cast<UINT>(wParam),
    1762                        LOWORD(lParam), HIWORD(lParam), TRUE);
    1763           break;
    1764       case WM_IME_SETCONTEXT:
    1765           // lParam is passed as pointer and it can be modified.
    1766           mr = WmImeSetContext(static_cast<BOOL>(wParam), &lParam);
    1767           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1768           break;
    1769       case WM_IME_NOTIFY:
    1770           mr = WmImeNotify(wParam, lParam);
    1771           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1772           break;
    1773       case WM_IME_STARTCOMPOSITION:
    1774           mr = WmImeStartComposition();
    1775           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1776           break;
    1777       case WM_IME_ENDCOMPOSITION:
    1778           mr = WmImeEndComposition();
    1779           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1780           break;
    1781       case WM_IME_COMPOSITION: {
    1782           WORD dbcschar = static_cast<WORD>(wParam);
    1783           mr = WmImeComposition(dbcschar, lParam);
    1784           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1785           break;
    1786       }
    1787       case WM_IME_CONTROL:
    1788       case WM_IME_COMPOSITIONFULL:
    1789       case WM_IME_SELECT:
    1790       case WM_IME_KEYUP:
    1791       case WM_IME_KEYDOWN:
    1792       case WM_IME_REQUEST:
    1793           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1794           break;
    1795       case WM_CHAR:
    1796           mr = WmChar(static_cast<UINT>(wParam),
    1797                       LOWORD(lParam), HIWORD(lParam), FALSE);
    1798           break;
    1799       case WM_SYSCHAR:
    1800           mr = WmChar(static_cast<UINT>(wParam),
    1801                       LOWORD(lParam), HIWORD(lParam), TRUE);
    1802           break;
    1803       case WM_IME_CHAR:
    1804           mr = WmIMEChar(static_cast<UINT>(wParam),
    1805                          LOWORD(lParam), HIWORD(lParam), FALSE);
    1806           break;
    1807
    1808       case WM_INPUTLANGCHANGEREQUEST: {
    1809           DTRACE_PRINTLN4("WM_INPUTLANGCHANGEREQUEST: hwnd = 0x%X (%s);"//
    1810                           "0x%08X -> 0x%08X",
    1811                           GetHWnd(), GetClassName(),
    1812                           (UINT_PTR)GetKeyboardLayout(), (UINT_PTR)lParam);
    1813           // 4267428: make sure keyboard layout is turned undead.
    1814           static BYTE keyboardState[AwtToolkit::KB_STATE_SIZE];
    1815           AwtToolkit::GetKeyboardState(keyboardState);
    1816           WORD ignored;
    1817           ::ToAsciiEx(VK_SPACE, ::MapVirtualKey(VK_SPACE, 0),
    1818                       keyboardState, &ignored, 0, GetKeyboardLayout());
    1819
    1820           // Set this flag to block ActivateKeyboardLayout from
    1821           // WInputMethod.activate()
    1822           g_bUserHasChangedInputLang = TRUE;
    1823           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1824           break;
    1825       }
    1826       case WM_INPUTLANGCHANGE:
    1827           DTRACE_PRINTLN3("WM_INPUTLANGCHANGE: hwnd = 0x%X (%s);"//
    1828                           "new = 0x%08X",
    1829                           GetHWnd(), GetClassName(), (UINT)lParam);
    1830           mr = WmInputLangChange(static_cast<UINT>(wParam), reinterpret_cast<HKL>(lParam));
    1831           g_bUserHasChangedInputLang = TRUE;
    1832           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
    1833           // should return non-zero if we process this message
    1834           retValue = 1;
    1835           break;
    1836
    1837       case WM_AWT_FORWARD_CHAR:
    1838           mr = WmForwardChar(LOWORD(wParam), lParam, HIWORD(wParam));
    1839           break;
    1840
    1841       case WM_AWT_FORWARD_BYTE:
    1842           mr = HandleEvent( (MSG *) lParam, (BOOL) wParam);
    1843           break;
    1844
    1845       case WM_PASTE:
    1846           mr = WmPaste();
    1847           break;
    1848       case WM_TIMER:
    1849           mr = WmTimer(wParam);
    1850           break;
    1851
    1852       case WM_COMMAND:
    1853           mr = WmCommand(LOWORD(wParam), (HWND)lParam, HIWORD(wParam));
    1854           break;
    1855       case WM_COMPAREITEM:
    1856           mr = WmCompareItem(static_cast<UINT>(wParam),
    1857                              *(COMPAREITEMSTRUCT*)lParam, retValue);
    1858           break;
    1859       case WM_DELETEITEM:
    1860           mr = WmDeleteItem(static_cast<UINT>(wParam),
    1861                             *(DELETEITEMSTRUCT*)lParam);
    1862           break;
    1863       case WM_DRAWITEM:
    1864           mr = WmDrawItem(static_cast<UINT>(wParam),
    1865                           *(DRAWITEMSTRUCT*)lParam);
    1866           break;
    1867       case WM_MEASUREITEM:
    1868           mr = WmMeasureItem(static_cast<UINT>(wParam),
    1869                              *(MEASUREITEMSTRUCT*)lParam);
    1870           break;
    1871
    1872       case WM_AWT_HANDLE_EVENT:
    1873           mr = HandleEvent( (MSG *) lParam, (BOOL) wParam);
    1874           break;
    1875
    1876       case WM_PRINT:
    1877           mr = WmPrint((HDC)wParam, lParam);
    1878           break;
    1879       case WM_PRINTCLIENT:
    1880           mr = WmPrintClient((HDC)wParam, lParam);
    1881           break;
    1882
    1883       case WM_NCCALCSIZE:
    1884           mr = WmNcCalcSize((BOOL)wParam, (LPNCCALCSIZE_PARAMS)lParam,
    1885                             retValue);
    1886           break;
    1887       case WM_NCPAINT:
    1888           mr = WmNcPaint((HRGN)wParam);
    1889           break;
    1890       case WM_NCHITTEST:
    1891           mr = WmNcHitTest(LOWORD(lParam), HIWORD(lParam), retValue);
    1892           break;
    1893
    1894       case WM_AWT_RESHAPE_COMPONENT: {
    1895           RECT* r = (RECT*)lParam;
    1896           WPARAM checkEmbedded = wParam;
    1897           if (checkEmbedded == CHECK_EMBEDDED && IsEmbeddedFrame()) {
    1898               ::OffsetRect(r, -r->left, -r->top);
    1899           }
    1900           Reshape(r->left, r->top, r->right - r->left, r->bottom - r->top);
    1901           delete r;
    1902           mr = mrConsume;
    1903           break;
    1904       }
    1905
    1906       case WM_AWT_SETALWAYSONTOP: {
    1907         AwtWindow* w = (AwtWindow*)lParam;
    1908         BOOL value = (BOOL)wParam;
    1909         UINT flags = SWP_NOMOVE | SWP_NOSIZE;
    1910         // transient windows shouldn't change the owner window's position in the z-order
    1911         if (w->IsRetainingHierarchyZOrder()) {
    1912             flags |= SWP_NOOWNERZORDER;
    1913         }
    1914         ::SetWindowPos(w->GetHWnd(), (value != 0 ? HWND_TOPMOST : HWND_NOTOPMOST),
    1915                        0,0,0,0, flags);
    1916         break;
    1917       }
    1918
    1919       case WM_AWT_BEGIN_VALIDATE:
    1920           BeginValidate();
    1921           mr = mrConsume;
    1922           break;
    1923       case WM_AWT_END_VALIDATE:
    1924           EndValidate();
    1925           mr = mrConsume;
    1926           break;
    1927
    1928       case WM_PALETTEISCHANGING:
    1929           mr = WmPaletteIsChanging((HWND)wParam);
    1930           mr = mrDoDefault;
    1931           break;
    1932       case WM_QUERYNEWPALETTE:
    1933           mr = WmQueryNewPalette(retValue);
    1934           break;
    1935       case WM_PALETTECHANGED:
    1936           mr = WmPaletteChanged((HWND)wParam);
    1937           break;
    1938       case WM_STYLECHANGED:
    1939           mr = WmStyleChanged(static_cast<int>(wParam), (LPSTYLESTRUCT)lParam);
    1940           break;
    1941       case WM_SETTINGCHANGE:
    1942           CheckFontSmoothingSettings(NULL);
    1943           mr = WmSettingChange(static_cast<UINT>(wParam), (LPCTSTR)lParam);
    1944           break;
    1945       case WM_CONTEXTMENU:
    1946           mr = WmContextMenu((HWND)wParam,
    1947                              GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
    1948           break;
    1949
    1950           /*
    1951            * These messages are used to route Win32 calls to the
    1952            * creating thread, since these calls fail unless executed
    1953            * there.
    1954            */
    1955       case WM_AWT_COMPONENT_SHOW:
    1956           Show();
    1957           mr = mrConsume;
    1958           break;
    1959       case WM_AWT_COMPONENT_HIDE:
    1960           Hide();
    1961           mr = mrConsume;
    1962           break;
    1963
    1964       case WM_AWT_COMPONENT_SETFOCUS:
    1965           if ((BOOL)wParam) {
    1966               retValue = SynthesizeWmSetFocus(GetHWnd(), NULL);
    1967           } else {
    1968               retValue = SynthesizeWmKillFocus(GetHWnd(), NULL);
    1969           }
    1970           mr = mrConsume;
    1971           break;
    1972       case WM_AWT_WINDOW_SETACTIVE:
    1973           retValue = (LRESULT)((AwtWindow*)this)->AwtSetActiveWindow((BOOL)wParam);
    1974           mr = mrConsume;
    1975           break;
    1976
    1977       case WM_AWT_SET_SCROLL_INFO: {
    1978           SCROLLINFO *si = (SCROLLINFO *) lParam;
    1979           ::SetScrollInfo(GetHWnd(), (int) wParam, si, TRUE);
    1980           delete si;
    1981           mr = mrConsume;
    1982           break;
    1983       }
    1984       case WM_AWT_CREATE_PRINTED_PIXELS: {
    1985           CreatePrintedPixelsStruct* cpps = (CreatePrintedPixelsStruct*)wParam;
    1986           SIZE loc = { cpps->srcx, cpps->srcy };
    1987           SIZE size = { cpps->srcw, cpps->srch };
    1988           retValue = (LRESULT)CreatePrintedPixels(loc, size, cpps->alpha);
    1989           mr = mrConsume;
    1990           break;
    1991       }
    1992       case WM_UNDOCUMENTED_CLICKMENUBAR:
    1993       {
    1994           if (::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()))) {
    1995               mr = mrConsume;
    1996           }
    1997       }
    1998     }
    1999
    2000     /*
    2001      * If not a specific Consume, it was a specific DoDefault, or a
    2002      * PassAlong (since the default is the next in chain), then call the
    2003      * default proc.
    2004      */
    2005     if (mr != mrConsume) {
    2006         retValue = DefWindowProc(message, wParam, lParam);
    2007     }
    2008
    2009     return retValue;
    2010 }
    2011 /*
    2012  * Call this instance's default window proc, or if none set, call the stock
    2013  * Window's one.
    2014  */
    2015 LRESULT AwtComponent::DefWindowProc(UINT msg, WPARAM wParam, LPARAM lParam)
    2016 {
    2017     return ComCtl32Util::GetInstance().DefWindowProc(m_DefWindowProc, GetHWnd(), msg, wParam, lParam);
    2018 }
    2019
    2020 /*
    2021  * This message should only be received when a window is destroyed by
    2022  * Windows, and not Java.  Window termination has been reworked so
    2023  * this method should never be called during termination.
    2024  */
    2025 MsgRouting AwtComponent::WmDestroy()
    2026 {
    2027     return mrConsume;
    2028 }
    2029
    2030 /*
    2031  * This message should only be received when a window is destroyed by
    2032  * Windows, and not Java. It is sent only after child windows were destroyed.
    2033  */
    2034 MsgRouting AwtComponent::WmNcDestroy()
    2035 {
    2036     if (m_peerObject != NULL) { // is not being terminating
    2037         // Stay in this handler until AwtComponent::Dispose is called.
    2038         m_bPauseDestroy = TRUE;
    2039
    2040         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    2041         // Post invocation event for WObjectPeer.dispose to EDT
    2042         env->CallVoidMethod(m_peerObject, AwtComponent::disposeLaterMID);
    2043         // Wait until AwtComponent::Dispose is called
    2044         AwtToolkit::GetInstance().PumpToDestroy(this);
    2045     }
    2046
    2047     return mrConsume;
    2048 }
    2049
    2050 MsgRouting AwtComponent::WmGetMinMaxInfo(LPMINMAXINFO lpmmi)
    2051 {
    2052     return mrDoDefault;
    2053 }
    2054
    2055 MsgRouting AwtComponent::WmMove(int x, int y)
    2056 {
    2057     SetDrawState(GetDrawState() | static_cast<jint>(JAWT_LOCK_BOUNDS_CHANGED)
    2058         | static_cast<jint>(JAWT_LOCK_CLIP_CHANGED));
    2059     return mrDoDefault;
    2060 }
    2061
    2062 MsgRouting AwtComponent::WmSize(UINT type, int w, int h)
    2063 {
    2064     SetDrawState(GetDrawState() | static_cast<jint>(JAWT_LOCK_BOUNDS_CHANGED)
    2065         | static_cast<jint>(JAWT_LOCK_CLIP_CHANGED));
    2066     return mrDoDefault;
    2067 }
    2068
    2069 MsgRouting AwtComponent::WmSizing()
    2070 {
    2071     return mrDoDefault;
    2072 }
    2073
    2074 MsgRouting AwtComponent::WmSysCommand(UINT uCmdType, int xPos, int yPos)
    2075 {
    2076     return mrDoDefault;
    2077 }
    2078
    2079 MsgRouting AwtComponent::WmEnterSizeMove()
    2080 {
    2081     return mrDoDefault;
    2082 }
    2083
    2084 MsgRouting AwtComponent::WmExitSizeMove()
    2085 {
    2086     return mrDoDefault;
    2087 }
    2088
    2089 MsgRouting AwtComponent::WmEnterMenuLoop(BOOL isTrackPopupMenu)
    2090 {
    2091     return mrDoDefault;
    2092 }
    2093
    2094 MsgRouting AwtComponent::WmExitMenuLoop(BOOL isTrackPopupMenu)
    2095 {
    2096     return mrDoDefault;
    2097 }
    2098
    2099 MsgRouting AwtComponent::WmShowWindow(BOOL show, UINT status)
    2100 {
    2101     return mrDoDefault;
    2102 }
    2103
    2104 MsgRouting AwtComponent::WmSetFocus(HWND hWndLostFocus)
    2105 {
    2106     m_wheelRotationAmountX = 0;
    2107     m_wheelRotationAmountY = 0;
    2108     return mrDoDefault;
    2109 }
    2110
    2111 MsgRouting AwtComponent::WmKillFocus(HWND hWndGotFocus)
    2112 {
    2113     m_wheelRotationAmountX = 0;
    2114     m_wheelRotationAmountY = 0;
    2115     return mrDoDefault;
    2116 }
    2117
    2118 MsgRouting AwtComponent::WmCtlColor(HDC hDC, HWND hCtrl,
    2119                                     UINT ctlColor, HBRUSH& retBrush)
    2120 {
    2121     AwtComponent* child = AwtComponent::GetComponent(hCtrl);
    2122     if (child) {
    2123         ::SetBkColor(hDC, child->GetBackgroundColor());
    2124         ::SetTextColor(hDC, child->GetColor());
    2125         retBrush = child->GetBackgroundBrush();
    2126         return mrConsume;
    2127     }
    2128     return mrDoDefault;
    2129 /*
    2130     switch (ctlColor) {
    2131         case CTLCOLOR_MSGBOX:
    2132         case CTLCOLOR_EDIT:
    2133         case CTLCOLOR_LISTBOX:
    2134         case CTLCOLOR_BTN:
    2135         case CTLCOLOR_DLG:
    2136         case CTLCOLOR_SCROLLBAR:
    2137         case CTLCOLOR_STATIC:
    2138     }
    2139 */
    2140 }
    2141
    2142 MsgRouting AwtComponent::WmHScroll(UINT scrollCode, UINT pos,
    2143                                    HWND hScrollbar) {
    2144     if (hScrollbar && hScrollbar != GetHWnd()) {
    2145         /* the last test should never happen */
    2146         AwtComponent* sb = GetComponent(hScrollbar);
    2147         if (sb) {
    2148             sb->WmHScroll(scrollCode, pos, hScrollbar);
    2149         }
    2150     }
    2151     return mrDoDefault;
    2152 }
    2153
    2154 MsgRouting AwtComponent::WmVScroll(UINT scrollCode, UINT pos, HWND hScrollbar)
    2155 {
    2156     if (hScrollbar && hScrollbar != GetHWnd()) {
    2157         /* the last test should never happen */
    2158         AwtComponent* sb = GetComponent(hScrollbar);
    2159         if (sb) {
    2160             sb->WmVScroll(scrollCode, pos, hScrollbar);
    2161         }
    2162     }
    2163     return mrDoDefault;
    2164 }
    2165
    2166
    2167 MsgRouting AwtComponent::WmPaint(HDC)
    2168 {
    2169     /* Get the rectangle that covers all update regions, if any exist. */
    2170     RECT r;
    2171     if (::GetUpdateRect(GetHWnd(), &r, FALSE)) {
    2172         if ((r.right-r.left) > 0 && (r.bottom-r.top) > 0 &&
    2173             m_peerObject != NULL && m_callbacksEnabled) {
    2174             /*
    2175              * Always call handlePaint, because the underlying control
    2176              * will have painted itself (the "background") before any
    2177              * paint method is called.
    2178              */
    2179             DoCallback("handlePaint", "(IIII)V",
    2180                        r.left, r.top, r.right-r.left, r.bottom-r.top);
    2181         }
    2182     }
    2183     return mrDoDefault;
    2184 }
    2185
    2186 void AwtComponent::PaintUpdateRgn(const RECT *insets)
    2187 {
    2188     // Fix 4530093: Don't Validate if can't actually paint
    2189     if (m_peerObject == NULL || !m_callbacksEnabled) {
    2190
    2191         // Fix 4745222: If we don't ValidateRgn,  windows will keep sending
    2192         // WM_PAINT messages until we do. This causes java to go into
    2193         // a tight loop that increases CPU to 100% and starves main
    2194         // thread which needs to complete initialization, but cant.
    2195         ::ValidateRgn(GetHWnd(), NULL);
    2196
    2197         return;
    2198     }
    2199
    2200     HRGN rgn = ::CreateRectRgn(0,0,1,1);
    2201     int updated = ::GetUpdateRgn(GetHWnd(), rgn, FALSE);
    2202     /*
    2203      * Now remove all update regions from this window -- do it
    2204      * here instead of after the Java upcall, in case any new
    2205      * updating is requested.
    2206      */
    2207     ::ValidateRgn(GetHWnd(), NULL);
    2208
    2209     if (updated == COMPLEXREGION || updated == SIMPLEREGION) {
    2210         if (insets != NULL) {
    2211             ::OffsetRgn(rgn, insets->left, insets->top);
    2212         }
    2213         DWORD size = ::GetRegionData(rgn, 0, NULL);
    2214         if (size == 0) {
    2215             ::DeleteObject((HGDIOBJ)rgn);
    2216             return;
    2217         }
    2218         char* buffer = new char[size]; // safe because sizeof(char)==1
    2219         memset(buffer, 0, size);
    2220         LPRGNDATA rgndata = (LPRGNDATA)buffer;
    2221         rgndata->rdh.dwSize = sizeof(RGNDATAHEADER);
    2222         rgndata->rdh.iType = RDH_RECTANGLES;
    2223         int retCode = ::GetRegionData(rgn, size, rgndata);
    2224         VERIFY(retCode);
    2225         if (retCode == 0) {
    2226             delete [] buffer;
    2227             ::DeleteObject((HGDIOBJ)rgn);
    2228             return;
    2229         }
    2230         /*
    2231          * Updating rects are divided into mostly vertical and mostly horizontal
    2232          * Each group is united together and if not empty painted separately
    2233          */
    2234         RECT* r = (RECT*)(buffer + rgndata->rdh.dwSize);
    2235         RECT* un[2] = {0, 0};
    2236     DWORD i;
    2237     for (i = 0; i < rgndata->rdh.nCount; i++, r++) {
    2238             int width = r->right-r->left;
    2239             int height = r->bottom-r->top;
    2240             if (width > 0 && height > 0) {
    2241                 int toAdd = (width > height) ? 0: 1;
    2242                 if (un[toAdd] != 0) {
    2243                     ::UnionRect(un[toAdd], un[toAdd], r);
    2244                 } else {
    2245                     un[toAdd] = r;
    2246                 }
    2247             }
    2248         }
    2249         for(i = 0; i < 2; i++) {
    2250             if (un[i] != 0) {
    2251                 DoCallback("handleExpose", "(IIII)V",
    2252                            ScaleDownX(un[i]->left),
    2253                            ScaleDownY(un[i]->top),
    2254                            ScaleDownX(un[i]->right - un[i]->left),
    2255                            ScaleDownY(un[i]->bottom - un[i]->top));
    2256             }
    2257         }
    2258         delete [] buffer;
    2259     }
    2260     ::DeleteObject((HGDIOBJ)rgn);
    2261 }
    2262
    2263 MsgRouting AwtComponent::WmMouseEnter(UINT flags, int x, int y)
    2264 {
    2265     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_ENTERED,
    2266                    ::JVM_CurrentTimeMillis(NULL, 0), x, y, GetJavaModifiers(), 0, JNI_FALSE);
    2267     if ((flags & ALL_MK_BUTTONS) == 0) {
    2268         AwtCursor::UpdateCursor(this);
    2269     }
    2270     sm_cursorOn = GetHWnd();
    2271     return mrConsume;   /* Don't pass our synthetic event on! */
    2272 }
    2273
    2274 MSG*
    2275 AwtComponent::CreateMessage(UINT message, WPARAM wParam, LPARAM lParam,
    2276                             int x = 0, int y = 0)
    2277 {
    2278     MSG* pMsg = new MSG;
    2279     InitMessage(pMsg, message, wParam, lParam, x, y);
    2280     return pMsg;
    2281 }
    2282
    2283
    2284 jint
    2285 AwtComponent::GetDrawState(HWND hwnd) {
    2286     return (jint)(INT_PTR)(::GetProp(hwnd, DrawingStateProp));
    2287 }
    2288
    2289 void
    2290 AwtComponent::SetDrawState(HWND hwnd, jint state) {
    2291     ::SetProp(hwnd, DrawingStateProp, (HANDLE)(INT_PTR)state);
    2292 }
    2293
    2294 void
    2295 AwtComponent::InitMessage(MSG* msg, UINT message, WPARAM wParam, LPARAM lParam,
    2296                             int x = 0, int y = 0)
    2297 {
    2298     msg->message = message;
    2299     msg->wParam = wParam;
    2300     msg->lParam = lParam;
    2301     msg->time = ::GetMessageTime();
    2302     msg->pt.x = x;
    2303     msg->pt.y = y;
    2304 }
    2305
    2306 MsgRouting AwtComponent::WmNcMouseDown(WPARAM hitTest, int x, int y, int button) {
    2307     return mrDoDefault;
    2308 }
    2309 MsgRouting AwtComponent::WmNcMouseUp(WPARAM hitTest, int x, int y, int button) {
    2310     return mrDoDefault;
    2311 }
    2312
    2313 MsgRouting AwtComponent::WmWindowPosChanging(LPARAM windowPos) {
    2314     return mrDoDefault;
    2315 }
    2316 MsgRouting AwtComponent::WmWindowPosChanged(LPARAM windowPos) {
    2317     return mrDoDefault;
    2318 }
    2319
    2320 void AwtComponent::WmTouch(WPARAM wParam, LPARAM lParam) {
    2321     AwtToolkit& tk = AwtToolkit::GetInstance();
    2322     if (!tk.IsWin8OrLater() || !tk.IsTouchKeyboardAutoShowEnabled()) {
    2323         return;
    2324     }
    2325
    2326     UINT inputsCount = LOWORD(wParam);
    2327     TOUCHINPUT* pInputs = new TOUCHINPUT[inputsCount];
    2328     if (pInputs != NULL) {
    2329         if (tk.TIGetTouchInputInfo((HTOUCHINPUT)lParam, inputsCount, pInputs,
    2330                 sizeof(TOUCHINPUT)) != 0) {
    2331             for (UINT i = 0; i < inputsCount; i++) {
    2332                 TOUCHINPUT ti = pInputs[i];
    2333                 if (ti.dwFlags & TOUCHEVENTF_PRIMARY) {
    2334                     if (ti.dwFlags & TOUCHEVENTF_DOWN) {
    2335                         m_touchDownPoint.x = ti.x / 100;
    2336                         m_touchDownPoint.y = ti.y / 100;
    2337                         ::ScreenToClient(GetHWnd(), &m_touchDownPoint);
    2338                         m_touchDownOccurred = TRUE;
    2339                     } else if (ti.dwFlags & TOUCHEVENTF_UP) {
    2340                         m_touchUpPoint.x = ti.x / 100;
    2341                         m_touchUpPoint.y = ti.y / 100;
    2342                         ::ScreenToClient(GetHWnd(), &m_touchUpPoint);
    2343                         m_touchUpOccurred = TRUE;
    2344                     }
    2345                 }
    2346             }
    2347         }
    2348         delete[] pInputs;
    2349     }
    2350 }
    2351
    2352 /* Double-click variables. */
    2353 static jlong multiClickTime = ::GetDoubleClickTime();
    2354 static int multiClickMaxX = ::GetSystemMetrics(SM_CXDOUBLECLK);
    2355 static int multiClickMaxY = ::GetSystemMetrics(SM_CYDOUBLECLK);
    2356 static AwtComponent* lastClickWnd = NULL;
    2357 static jlong lastTime = 0;
    2358 static int lastClickX = 0;
    2359 static int lastClickY = 0;
    2360 static int lastButton = 0;
    2361 static int clickCount = 0;
    2362
    2363 // A static method that makes the clickCount available in the derived classes
    2364 // overriding WmMouseDown().
    2365 int AwtComponent::GetClickCount()
    2366 {
    2367     return clickCount;
    2368 }
    2369
    2370 MsgRouting AwtComponent::WmMouseDown(UINT flags, int x, int y, int button)
    2371 {
    2372     jlong now = ::JVM_CurrentTimeMillis(NULL, 0);
    2373
    2374     if (lastClickWnd == this &&
    2375         lastButton == button &&
    2376         (now - lastTime) <= multiClickTime &&
    2377         abs(x - lastClickX) <= multiClickMaxX &&
    2378         abs(y - lastClickY) <= multiClickMaxY)
    2379     {
    2380         clickCount++;
    2381     } else {
    2382         clickCount = 1;
    2383         lastClickWnd = this;
    2384         lastButton = button;
    2385         lastClickX = x;
    2386         lastClickY = y;
    2387     }
    2388     /*
    2389      *Set appropriate bit of the mask on WM_MOUSE_DOWN message.
    2390      */
    2391     m_mouseButtonClickAllowed |= GetButtonMK(button);
    2392     lastTime = now;
    2393
    2394     BOOL causedByTouchEvent = FALSE;
    2395     if (m_touchDownOccurred &&
    2396         (abs(m_touchDownPoint.x - x) <= TOUCH_MOUSE_COORDS_DELTA) &&
    2397         (abs(m_touchDownPoint.y - y) <= TOUCH_MOUSE_COORDS_DELTA)) {
    2398         causedByTouchEvent = TRUE;
    2399         m_touchDownOccurred = FALSE;
    2400     }
    2401
    2402     MSG msg;
    2403     InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
    2404
    2405     AwtWindow *toplevel = GetContainer();
    2406     if (toplevel && !toplevel->IsSimpleWindow()) {
    2407         /*
    2408          * The frame should be focused by click in case it is
    2409          * the active window but not the focused window. See 6886678.
    2410          */
    2411         if (toplevel->GetHWnd() == ::GetActiveWindow() &&
    2412             toplevel->GetHWnd() != AwtComponent::GetFocusedWindow())
    2413         {
    2414             toplevel->AwtSetActiveWindow();
    2415         }
    2416     }
    2417
    2418     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_PRESSED, now, x, y,
    2419                    GetJavaModifiers(), clickCount, JNI_FALSE,
    2420                    GetButton(button), &msg, causedByTouchEvent);
    2421     /*
    2422      * NOTE: this call is intentionally placed after all other code,
    2423      * since AwtComponent::WmMouseDown() assumes that the cached id of the
    2424      * latest retrieved message (see lastMessage in awt_Component.cpp)
    2425      * matches the mouse message being processed.
    2426      * SetCapture() sends WM_CAPTURECHANGED and breaks that
    2427      * assumption.
    2428      */
    2429     SetDragCapture(flags);
    2430
    2431     AwtWindow * owner = (AwtWindow*)GetComponent(GetTopLevelParentForWindow(GetHWnd()));
    2432     if (AwtWindow::GetGrabbedWindow() != NULL && owner != NULL) {
    2433         if (!AwtWindow::GetGrabbedWindow()->IsOneOfOwnersOf(owner)) {
    2434             AwtWindow::GetGrabbedWindow()->Ungrab();
    2435         }
    2436     }
    2437     return mrConsume;
    2438 }
    2439
    2440 MsgRouting AwtComponent::WmMouseUp(UINT flags, int x, int y, int button)
    2441 {
    2442     BOOL causedByTouchEvent = FALSE;
    2443     if (m_touchUpOccurred &&
    2444         (abs(m_touchUpPoint.x - x) <= TOUCH_MOUSE_COORDS_DELTA) &&
    2445         (abs(m_touchUpPoint.y - y) <= TOUCH_MOUSE_COORDS_DELTA)) {
    2446         causedByTouchEvent = TRUE;
    2447         m_touchUpOccurred = FALSE;
    2448     }
    2449
    2450     MSG msg;
    2451     InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
    2452
    2453     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_RELEASED, ::JVM_CurrentTimeMillis(NULL, 0),
    2454                    x, y, GetJavaModifiers(), clickCount,
    2455                    (GetButton(button) == java_awt_event_MouseEvent_BUTTON3 ?
    2456                     TRUE : FALSE), GetButton(button), &msg, causedByTouchEvent);
    2457     /*
    2458      * If no movement, then report a click following the button release.
    2459      * When WM_MOUSEUP comes to a window without previous WM_MOUSEDOWN,
    2460      * spurous MOUSE_CLICK is about to happen. See 6430553.
    2461      */
    2462     if ((m_mouseButtonClickAllowed & GetButtonMK(button)) != 0) { //CLICK allowed
    2463         SendMouseEvent(java_awt_event_MouseEvent_MOUSE_CLICKED,
    2464                        ::JVM_CurrentTimeMillis(NULL, 0), x, y, GetJavaModifiers(),
    2465                        clickCount, JNI_FALSE, GetButton(button));
    2466     }
    2467     // Exclude button from allowed to generate CLICK messages
    2468     m_mouseButtonClickAllowed &= ~GetButtonMK(button);
    2469
    2470     if ((flags & ALL_MK_BUTTONS) == 0) {
    2471         // only update if all buttons have been released
    2472         AwtCursor::UpdateCursor(this);
    2473     }
    2474     /*
    2475      * NOTE: this call is intentionally placed after all other code,
    2476      * since AwtComponent::WmMouseUp() assumes that the cached id of the
    2477      * latest retrieved message (see lastMessage in awt_Component.cpp)
    2478      * matches the mouse message being processed.
    2479      * ReleaseCapture() sends WM_CAPTURECHANGED and breaks that
    2480      * assumption.
    2481      */
    2482     ReleaseDragCapture(flags);
    2483
    2484     return mrConsume;
    2485 }
    2486
    2487 MsgRouting AwtComponent::WmMouseMove(UINT flags, int x, int y)
    2488 {
    2489     static AwtComponent* lastComp = NULL;
    2490     static int lastX = 0;
    2491     static int lastY = 0;
    2492
    2493     /*
    2494      * Only report mouse move and drag events if a move or drag
    2495      * actually happened -- Windows sends a WM_MOUSEMOVE in case the
    2496      * app wants to modify the cursor.
    2497      */
    2498     if (lastComp != this || x != lastX || y != lastY) {
    2499         lastComp = this;
    2500         lastX = x;
    2501         lastY = y;
    2502         BOOL extraButtonsEnabled = AwtToolkit::GetInstance().areExtraMouseButtonsEnabled();
    2503         if (((flags & (ALL_MK_BUTTONS)) != 0) ||
    2504             (extraButtonsEnabled && (flags & (X_BUTTONS)) != 0))
    2505 //        if (( extraButtonsEnabled && ( (flags & (ALL_MK_BUTTONS | X_BUTTONS)) != 0 )) ||
    2506 //            ( !extraButtonsEnabled && (((flags & (ALL_MK_BUTTONS)) != 0 )) && ((flags & (X_BUTTONS)) == 0) ))
    2507         {
    2508             // 6404008 : if Dragged event fired we shouldn't fire
    2509             // Clicked event: m_firstDragSent set to TRUE.
    2510             // This is a partial backout of 5039416 fix.
    2511             MSG msg;
    2512             InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
    2513             SendMouseEvent(java_awt_event_MouseEvent_MOUSE_DRAGGED, ::JVM_CurrentTimeMillis(NULL, 0), x, y,
    2514                            GetJavaModifiers(), 0, JNI_FALSE,
    2515                            java_awt_event_MouseEvent_NOBUTTON, &msg);
    2516             //dragging means no more CLICKs until next WM_MOUSE_DOWN/WM_MOUSE_UP message sequence
    2517             m_mouseButtonClickAllowed = 0;
    2518         } else {
    2519             MSG msg;
    2520             InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
    2521             SendMouseEvent(java_awt_event_MouseEvent_MOUSE_MOVED, ::JVM_CurrentTimeMillis(NULL, 0), x, y,
    2522                            GetJavaModifiers(), 0, JNI_FALSE,
    2523                            java_awt_event_MouseEvent_NOBUTTON, &msg);
    2524         }
    2525     }
    2526
    2527     return mrConsume;
    2528 }
    2529
    2530 MsgRouting AwtComponent::WmMouseExit(UINT flags, int x, int y)
    2531 {
    2532     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_EXITED, ::JVM_CurrentTimeMillis(NULL, 0), x,
    2533                    y, GetJavaModifiers(), 0, JNI_FALSE);
    2534     sm_cursorOn = NULL;
    2535     return mrConsume;   /* Don't pass our synthetic event on! */
    2536 }
    2537
    2538 MsgRouting AwtComponent::WmMouseWheel(UINT flags, int x, int y,
    2539                                       int wheelRotation, BOOL isHorizontal)
    2540 {
    2541     // convert coordinates to be Component-relative, not screen relative
    2542     // for wheeling when outside the window, this works similar to
    2543     // coordinates during a drag
    2544     POINT eventPt;
    2545     eventPt.x = x;
    2546     eventPt.y = y;
    2547     DTRACE_PRINT2("  original coords: %i,%i\n", x, y);
    2548     ::ScreenToClient(GetHWnd(), &eventPt);
    2549     DTRACE_PRINT2("  new coords: %i,%i\n\n", eventPt.x, eventPt.y);
    2550
    2551     // set some defaults
    2552     jint scrollType = java_awt_event_MouseWheelEvent_WHEEL_UNIT_SCROLL;
    2553     jint scrollUnits = 3;
    2554
    2555     BOOL result;
    2556     UINT platformUnits;
    2557     jint roundedWheelRotation;
    2558     jdouble preciseWheelRotation;
    2559
    2560     // AWT interprets wheel rotation differently than win32, so we need to
    2561     // decode wheel amount.
    2562     jint modifiers = GetJavaModifiers();
    2563     if (isHorizontal) {
    2564         modifiers |= java_awt_event_InputEvent_SHIFT_DOWN_MASK;
    2565         m_wheelRotationAmountX += wheelRotation;
    2566         roundedWheelRotation = m_wheelRotationAmountX / (WHEEL_DELTA);
    2567         preciseWheelRotation = (jdouble) wheelRotation / (WHEEL_DELTA);
    2568         result = ::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0,
    2569                                         &platformUnits, 0);
    2570     } else {
    2571         m_wheelRotationAmountY += wheelRotation;
    2572         roundedWheelRotation = m_wheelRotationAmountY / (-1 * WHEEL_DELTA);
    2573         preciseWheelRotation = (jdouble) wheelRotation / (-1 * WHEEL_DELTA);
    2574         result = ::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
    2575                                         &platformUnits, 0);
    2576     }
    2577
    2578     MSG msg;
    2579     InitMessage(&msg, lastMessage, MAKEWPARAM(flags, wheelRotation),
    2580                 MAKELPARAM(x, y));
    2581
    2582     if (result) {
    2583         if (platformUnits == WHEEL_PAGESCROLL) {
    2584             scrollType = java_awt_event_MouseWheelEvent_WHEEL_BLOCK_SCROLL;
    2585             scrollUnits = 1;
    2586         }
    2587         else {
    2588             scrollType = java_awt_event_MouseWheelEvent_WHEEL_UNIT_SCROLL;
    2589             scrollUnits = platformUnits;
    2590         }
    2591     }
    2592
    2593     DTRACE_PRINTLN("calling SendMouseWheelEvent");
    2594
    2595     SendMouseWheelEvent(java_awt_event_MouseEvent_MOUSE_WHEEL, ::JVM_CurrentTimeMillis(NULL, 0),
    2596                         eventPt.x, eventPt.y, modifiers, 0, 0, scrollType,
    2597                         scrollUnits, roundedWheelRotation, preciseWheelRotation, &msg);
    2598
    2599     m_wheelRotationAmountX %= WHEEL_DELTA;
    2600     m_wheelRotationAmountY %= WHEEL_DELTA;
    2601     // this message could be propagated up to the parent chain
    2602     // by the mouse message post processors
    2603     return mrConsume;
    2604 }
    2605
    2606 jint AwtComponent::GetKeyLocation(UINT wkey, UINT flags) {
    2607     // Rector+Newcomer page 413
    2608     // The extended keys are the Alt and Control on the right of
    2609     // the space bar, the non-Numpad arrow keys, the non-Numpad
    2610     // Insert, PageUp, etc. keys, and the Numpad Divide and Enter keys.
    2611     // Note that neither Shift key is extended.
    2612     // Although not listed in Rector+Newcomer, both Windows keys
    2613     // (91 and 92) are extended keys, the Context Menu key
    2614     // (property key or application key - 93) is extended,
    2615     // and so is the NumLock key.
    2616
    2617     // wkey is the wParam, flags is the HIWORD of the lParam
    2618
    2619     // "Extended" bit is 24th in lParam, so it's 8th in flags = HIWORD(lParam)
    2620     BOOL extended = ((1<<8) & flags);
    2621
    2622     if (IsNumPadKey(wkey, extended)) {
    2623         return java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD;
    2624     }
    2625
    2626     switch (wkey) {
    2627       case VK_SHIFT:
    2628         return AwtComponent::GetShiftKeyLocation(wkey, flags);
    2629       case VK_CONTROL: // fall through
    2630       case VK_MENU:
    2631         if (extended) {
    2632             return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
    2633         } else {
    2634             return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
    2635         }
    2636       case VK_LWIN:
    2637         return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
    2638       case VK_RWIN:
    2639         return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
    2640       default:
    2641         break;
    2642     }
    2643
    2644     // REMIND: if we add keycodes for the windows keys, we'll have to
    2645     // include left/right discrimination code for them.
    2646
    2647     return java_awt_event_KeyEvent_KEY_LOCATION_STANDARD;
    2648 }
    2649
    2650 jint AwtComponent::GetShiftKeyLocation(UINT vkey, UINT flags)
    2651 {
    2652     // init scancodes to safe values
    2653     UINT leftShiftScancode = 0;
    2654     UINT rightShiftScancode = 0;
    2655
    2656     // First 8 bits of flags is the scancode
    2657     UINT keyScanCode = flags & 0xFF;
    2658
    2659     DTRACE_PRINTLN3(
    2660       "AwtComponent::GetShiftKeyLocation  vkey = %d = 0x%x  scan = %d",
    2661       vkey, vkey, keyScanCode);
    2662
    2663     leftShiftScancode = ::MapVirtualKey(VK_LSHIFT, 0);
    2664     rightShiftScancode = ::MapVirtualKey(VK_RSHIFT, 0);
    2665
    2666     if (keyScanCode == leftShiftScancode) {
    2667         return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
    2668     }
    2669     if (keyScanCode == rightShiftScancode) {
    2670         return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
    2671     }
    2672
    2673     DASSERT(false);
    2674     // Note: the above should not fail on NT (or 2000)
    2675
    2676     // default value
    2677     return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
    2678 }
    2679
    2680 /* Returns Java ActionEvent modifieres.
    2681  * When creating ActionEvent, modifiers provided by ActionEvent
    2682  * class should be set.
    2683  */
    2684 jint
    2685 AwtComponent::GetActionModifiers()
    2686 {
    2687     jint modifiers = GetJavaModifiers();
    2688
    2689     if (modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK) {
    2690         modifiers |= java_awt_event_ActionEvent_CTRL_MASK;
    2691     }
    2692     if (modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) {
    2693         modifiers |= java_awt_event_ActionEvent_SHIFT_MASK;
    2694     }
    2695     if (modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) {
    2696         modifiers |= java_awt_event_ActionEvent_ALT_MASK;
    2697     }
    2698     return modifiers;
    2699 }
    2700
    2701 /* Returns Java extended InputEvent modifieres.
    2702  * Since ::GetKeyState returns current state and Java modifiers represent
    2703  * state before event, modifier on changed key are inverted.
    2704  */
    2705 jint
    2706 AwtComponent::GetJavaModifiers()
    2707 {
    2708     jint modifiers = 0;
    2709
    2710     if (HIBYTE(::GetKeyState(VK_CONTROL)) != 0) {
    2711         modifiers |= java_awt_event_InputEvent_CTRL_DOWN_MASK;
    2712     }
    2713     if (HIBYTE(::GetKeyState(VK_SHIFT)) != 0) {
    2714         modifiers |= java_awt_event_InputEvent_SHIFT_DOWN_MASK;
    2715     }
    2716     if (HIBYTE(::GetKeyState(VK_MENU)) != 0) {
    2717         modifiers |= java_awt_event_InputEvent_ALT_DOWN_MASK;
    2718     }
    2719     if (HIBYTE(::GetKeyState(VK_RMENU)) != 0) {
    2720         modifiers |= java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK;
    2721     }
    2722     if (HIBYTE(::GetKeyState(VK_MBUTTON)) != 0) {
    2723        modifiers |= java_awt_event_InputEvent_BUTTON2_DOWN_MASK;
    2724     }
    2725     if (HIBYTE(::GetKeyState(VK_RBUTTON)) != 0) {
    2726         modifiers |= java_awt_event_InputEvent_BUTTON3_DOWN_MASK;
    2727     }
    2728     if (HIBYTE(::GetKeyState(VK_LBUTTON)) != 0) {
    2729         modifiers |= java_awt_event_InputEvent_BUTTON1_DOWN_MASK;
    2730     }
    2731
    2732     if (HIBYTE(::GetKeyState(VK_XBUTTON1)) != 0) {
    2733         modifiers |= masks[3];
    2734     }
    2735     if (HIBYTE(::GetKeyState(VK_XBUTTON2)) != 0) {
    2736         modifiers |= masks[4];
    2737     }
    2738     return modifiers;
    2739 }
    2740
    2741 jint
    2742 AwtComponent::GetButton(int mouseButton)
    2743 {
    2744     /* Mouse buttons are already set correctly for left/right handedness */
    2745     switch(mouseButton) {
    2746     case LEFT_BUTTON:
    2747         return java_awt_event_MouseEvent_BUTTON1;
    2748     case MIDDLE_BUTTON:
    2749         return java_awt_event_MouseEvent_BUTTON2;
    2750     case RIGHT_BUTTON:
    2751         return java_awt_event_MouseEvent_BUTTON3;
    2752     case X1_BUTTON: //16 :
    2753         //just assign 4 and 5 numbers because MouseEvent class doesn't contain const identifier for them now
    2754         return 4;
    2755     case X2_BUTTON: //32
    2756         return 5;
    2757     }
    2758     return java_awt_event_MouseEvent_NOBUTTON;
    2759 }
    2760
    2761 UINT
    2762 AwtComponent::GetButtonMK(int mouseButton)
    2763 {
    2764     switch(mouseButton) {
    2765     case LEFT_BUTTON:
    2766         return MK_LBUTTON;
    2767     case MIDDLE_BUTTON:
    2768         return MK_MBUTTON;
    2769     case RIGHT_BUTTON:
    2770         return MK_RBUTTON;
    2771     case X1_BUTTON:
    2772         return MK_XBUTTON1;
    2773     case X2_BUTTON:
    2774         return MK_XBUTTON2;
    2775     }
    2776     return 0;
    2777 }
    2778
    2779 // FIXME: Keyboard related stuff has grown so big and hairy that we
    2780 // really need to move it into a class of its own.  And, since
    2781 // keyboard is a shared resource, AwtComponent is a bad place for it.
    2782
    2783 // These constants are defined in the Japanese version of VC++5.0,
    2784 // but not the US version
    2785 #ifndef VK_CONVERT
    2786 #define VK_KANA           0x15
    2787 #define VK_KANJI          0x19
    2788 #define VK_CONVERT        0x1C
    2789 #define VK_NONCONVERT     0x1D
    2790 #endif
    2791
    2792 #ifndef VK_XBUTTON1
    2793 #define VK_XBUTTON1      0x05
    2794 #endif
    2795
    2796 #ifndef VK_XBUTTON2
    2797 #define VK_XBUTTON2      0x06
    2798 #endif
    2799
    2800 typedef struct {
    2801     UINT javaKey;
    2802     UINT windowsKey;
    2803 } KeyMapEntry;
    2804
    2805 // Static table, arranged more or less spatially.
    2806 KeyMapEntry keyMapTable[] = {
    2807     // Modifier keys
    2808     {java_awt_event_KeyEvent_VK_CAPS_LOCK,        VK_CAPITAL},
    2809     {java_awt_event_KeyEvent_VK_SHIFT,            VK_SHIFT},
    2810     {java_awt_event_KeyEvent_VK_CONTROL,          VK_CONTROL},
    2811     {java_awt_event_KeyEvent_VK_ALT,              VK_MENU},
    2812     {java_awt_event_KeyEvent_VK_ALT_GRAPH,        VK_RMENU},
    2813     {java_awt_event_KeyEvent_VK_NUM_LOCK,         VK_NUMLOCK},
    2814
    2815     // Miscellaneous Windows keys
    2816     {java_awt_event_KeyEvent_VK_WINDOWS,          VK_LWIN},
    2817     {java_awt_event_KeyEvent_VK_WINDOWS,          VK_RWIN},
    2818     {java_awt_event_KeyEvent_VK_CONTEXT_MENU,     VK_APPS},
    2819
    2820     // Alphabet
    2821     {java_awt_event_KeyEvent_VK_A,                'A'},
    2822     {java_awt_event_KeyEvent_VK_B,                'B'},
    2823     {java_awt_event_KeyEvent_VK_C,                'C'},
    2824     {java_awt_event_KeyEvent_VK_D,                'D'},
    2825     {java_awt_event_KeyEvent_VK_E,                'E'},
    2826     {java_awt_event_KeyEvent_VK_F,                'F'},
    2827     {java_awt_event_KeyEvent_VK_G,                'G'},
    2828     {java_awt_event_KeyEvent_VK_H,                'H'},
    2829     {java_awt_event_KeyEvent_VK_I,                'I'},
    2830     {java_awt_event_KeyEvent_VK_J,                'J'},
    2831     {java_awt_event_KeyEvent_VK_K,                'K'},
    2832     {java_awt_event_KeyEvent_VK_L,                'L'},
    2833     {java_awt_event_KeyEvent_VK_M,                'M'},
    2834     {java_awt_event_KeyEvent_VK_N,                'N'},
    2835     {java_awt_event_KeyEvent_VK_O,                'O'},
    2836     {java_awt_event_KeyEvent_VK_P,                'P'},
    2837     {java_awt_event_KeyEvent_VK_Q,                'Q'},
    2838     {java_awt_event_KeyEvent_VK_R,                'R'},
    2839     {java_awt_event_KeyEvent_VK_S,                'S'},
    2840     {java_awt_event_KeyEvent_VK_T,                'T'},
    2841     {java_awt_event_KeyEvent_VK_U,                'U'},
    2842     {java_awt_event_KeyEvent_VK_V,                'V'},
    2843     {java_awt_event_KeyEvent_VK_W,                'W'},
    2844     {java_awt_event_KeyEvent_VK_X,                'X'},
    2845     {java_awt_event_KeyEvent_VK_Y,                'Y'},
    2846     {java_awt_event_KeyEvent_VK_Z,                'Z'},
    2847
    2848     // Standard numeric row
    2849     {java_awt_event_KeyEvent_VK_0,                '0'},
    2850     {java_awt_event_KeyEvent_VK_1,                '1'},
    2851     {java_awt_event_KeyEvent_VK_2,                '2'},
    2852     {java_awt_event_KeyEvent_VK_3,                '3'},
    2853     {java_awt_event_KeyEvent_VK_4,                '4'},
    2854     {java_awt_event_KeyEvent_VK_5,                '5'},
    2855     {java_awt_event_KeyEvent_VK_6,                '6'},
    2856     {java_awt_event_KeyEvent_VK_7,                '7'},
    2857     {java_awt_event_KeyEvent_VK_8,                '8'},
    2858     {java_awt_event_KeyEvent_VK_9,                '9'},
    2859
    2860     // Misc key from main block
    2861     {java_awt_event_KeyEvent_VK_ENTER,            VK_RETURN},
    2862     {java_awt_event_KeyEvent_VK_SPACE,            VK_SPACE},
    2863     {java_awt_event_KeyEvent_VK_BACK_SPACE,       VK_BACK},
    2864     {java_awt_event_KeyEvent_VK_TAB,              VK_TAB},
    2865     {java_awt_event_KeyEvent_VK_ESCAPE,           VK_ESCAPE},
    2866
    2867     // NumPad with NumLock off & extended block (rectangular)
    2868     {java_awt_event_KeyEvent_VK_INSERT,           VK_INSERT},
    2869     {java_awt_event_KeyEvent_VK_DELETE,           VK_DELETE},
    2870     {java_awt_event_KeyEvent_VK_HOME,             VK_HOME},
    2871     {java_awt_event_KeyEvent_VK_END,              VK_END},
    2872     {java_awt_event_KeyEvent_VK_PAGE_UP,          VK_PRIOR},
    2873     {java_awt_event_KeyEvent_VK_PAGE_DOWN,        VK_NEXT},
    2874     {java_awt_event_KeyEvent_VK_CLEAR,            VK_CLEAR}, // NumPad 5
    2875
    2876     // NumPad with NumLock off & extended arrows block (triangular)
    2877     {java_awt_event_KeyEvent_VK_LEFT,             VK_LEFT},
    2878     {java_awt_event_KeyEvent_VK_RIGHT,            VK_RIGHT},
    2879     {java_awt_event_KeyEvent_VK_UP,               VK_UP},
    2880     {java_awt_event_KeyEvent_VK_DOWN,             VK_DOWN},
    2881
    2882     // NumPad with NumLock on: numbers
    2883     {java_awt_event_KeyEvent_VK_NUMPAD0,          VK_NUMPAD0},
    2884     {java_awt_event_KeyEvent_VK_NUMPAD1,          VK_NUMPAD1},
    2885     {java_awt_event_KeyEvent_VK_NUMPAD2,          VK_NUMPAD2},
    2886     {java_awt_event_KeyEvent_VK_NUMPAD3,          VK_NUMPAD3},
    2887     {java_awt_event_KeyEvent_VK_NUMPAD4,          VK_NUMPAD4},
    2888     {java_awt_event_KeyEvent_VK_NUMPAD5,          VK_NUMPAD5},
    2889     {java_awt_event_KeyEvent_VK_NUMPAD6,          VK_NUMPAD6},
    2890     {java_awt_event_KeyEvent_VK_NUMPAD7,          VK_NUMPAD7},
    2891     {java_awt_event_KeyEvent_VK_NUMPAD8,          VK_NUMPAD8},
    2892     {java_awt_event_KeyEvent_VK_NUMPAD9,          VK_NUMPAD9},
    2893
    2894     // NumPad with NumLock on
    2895     {java_awt_event_KeyEvent_VK_MULTIPLY,         VK_MULTIPLY},
    2896     {java_awt_event_KeyEvent_VK_ADD,              VK_ADD},
    2897     {java_awt_event_KeyEvent_VK_SEPARATOR,        VK_SEPARATOR},
    2898     {java_awt_event_KeyEvent_VK_SUBTRACT,         VK_SUBTRACT},
    2899     {java_awt_event_KeyEvent_VK_DECIMAL,          VK_DECIMAL},
    2900     {java_awt_event_KeyEvent_VK_DIVIDE,           VK_DIVIDE},
    2901
    2902     // Functional keys
    2903     {java_awt_event_KeyEvent_VK_F1,               VK_F1},
    2904     {java_awt_event_KeyEvent_VK_F2,               VK_F2},
    2905     {java_awt_event_KeyEvent_VK_F3,               VK_F3},
    2906     {java_awt_event_KeyEvent_VK_F4,               VK_F4},
    2907     {java_awt_event_KeyEvent_VK_F5,               VK_F5},
    2908     {java_awt_event_KeyEvent_VK_F6,               VK_F6},
    2909     {java_awt_event_KeyEvent_VK_F7,               VK_F7},
    2910     {java_awt_event_KeyEvent_VK_F8,               VK_F8},
    2911     {java_awt_event_KeyEvent_VK_F9,               VK_F9},
    2912     {java_awt_event_KeyEvent_VK_F10,              VK_F10},
    2913     {java_awt_event_KeyEvent_VK_F11,              VK_F11},
    2914     {java_awt_event_KeyEvent_VK_F12,              VK_F12},
    2915     {java_awt_event_KeyEvent_VK_F13,              VK_F13},
    2916     {java_awt_event_KeyEvent_VK_F14,              VK_F14},
    2917     {java_awt_event_KeyEvent_VK_F15,              VK_F15},
    2918     {java_awt_event_KeyEvent_VK_F16,              VK_F16},
    2919     {java_awt_event_KeyEvent_VK_F17,              VK_F17},
    2920     {java_awt_event_KeyEvent_VK_F18,              VK_F18},
    2921     {java_awt_event_KeyEvent_VK_F19,              VK_F19},
    2922     {java_awt_event_KeyEvent_VK_F20,              VK_F20},
    2923     {java_awt_event_KeyEvent_VK_F21,              VK_F21},
    2924     {java_awt_event_KeyEvent_VK_F22,              VK_F22},
    2925     {java_awt_event_KeyEvent_VK_F23,              VK_F23},
    2926     {java_awt_event_KeyEvent_VK_F24,              VK_F24},
    2927
    2928     {java_awt_event_KeyEvent_VK_PRINTSCREEN,      VK_SNAPSHOT},
    2929     {java_awt_event_KeyEvent_VK_SCROLL_LOCK,      VK_SCROLL},
    2930     {java_awt_event_KeyEvent_VK_PAUSE,            VK_PAUSE},
    2931     {java_awt_event_KeyEvent_VK_CANCEL,           VK_CANCEL},
    2932     {java_awt_event_KeyEvent_VK_HELP,             VK_HELP},
    2933
    2934     // Japanese
    2935     {java_awt_event_KeyEvent_VK_CONVERT,          VK_CONVERT},
    2936     {java_awt_event_KeyEvent_VK_NONCONVERT,       VK_NONCONVERT},
    2937     {java_awt_event_KeyEvent_VK_INPUT_METHOD_ON_OFF, VK_KANJI},
    2938     {java_awt_event_KeyEvent_VK_ALPHANUMERIC,     VK_DBE_ALPHANUMERIC},
    2939     {java_awt_event_KeyEvent_VK_KATAKANA,         VK_DBE_KATAKANA},
    2940     {java_awt_event_KeyEvent_VK_HIRAGANA,         VK_DBE_HIRAGANA},
    2941     {java_awt_event_KeyEvent_VK_FULL_WIDTH,       VK_DBE_DBCSCHAR},
    2942     {java_awt_event_KeyEvent_VK_HALF_WIDTH,       VK_DBE_SBCSCHAR},
    2943     {java_awt_event_KeyEvent_VK_ROMAN_CHARACTERS, VK_DBE_ROMAN},
    2944
    2945     {java_awt_event_KeyEvent_VK_UNDEFINED,        0}
    2946 };
    2947
    2948
    2949 // Dynamic mapping table for OEM VK codes.  This table is refilled
    2950 // by BuildDynamicKeyMapTable when keyboard layout is switched.
    2951 // (see NT4 DDK src/input/inc/vkoem.h for OEM VK_ values).
    2952 struct DynamicKeyMapEntry {
    2953     UINT windowsKey;            // OEM VK codes known in advance
    2954     UINT javaKey;               // depends on input langauge (kbd layout)
    2955 };
    2956
    2957 static DynamicKeyMapEntry dynamicKeyMapTable[] = {
    2958     {0x00BA,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_1
    2959     {0x00BB,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_PLUS
    2960     {0x00BC,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_COMMA
    2961     {0x00BD,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_MINUS
    2962     {0x00BE,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_PERIOD
    2963     {0x00BF,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_2
    2964     {0x00C0,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_3
    2965     {0x00DB,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_4
    2966     {0x00DC,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_5
    2967     {0x00DD,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_6
    2968     {0x00DE,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_7
    2969     {0x00DF,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_8
    2970     {0x00E2,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_102
    2971     {0, 0}
    2972 };
    2973
    2974
    2975
    2976 // Auxiliary tables used to fill the above dynamic table.  We first
    2977 // find the character for the OEM VK code using ::MapVirtualKey and
    2978 // then go through these auxiliary tables to map it to Java VK code.
    2979
    2980 struct CharToVKEntry {
    2981     WCHAR c;
    2982     UINT  javaKey;
    2983 };
    2984
    2985 static const CharToVKEntry charToVKTable[] = {
    2986     {L'!',   java_awt_event_KeyEvent_VK_EXCLAMATION_MARK},
    2987     {L'"',   java_awt_event_KeyEvent_VK_QUOTEDBL},
    2988     {L'#',   java_awt_event_KeyEvent_VK_NUMBER_SIGN},
    2989     {L'$',   java_awt_event_KeyEvent_VK_DOLLAR},
    2990     {L'&',   java_awt_event_KeyEvent_VK_AMPERSAND},
    2991     {L'\'',  java_awt_event_KeyEvent_VK_QUOTE},
    2992     {L'(',   java_awt_event_KeyEvent_VK_LEFT_PARENTHESIS},
    2993     {L')',   java_awt_event_KeyEvent_VK_RIGHT_PARENTHESIS},
    2994     {L'*',   java_awt_event_KeyEvent_VK_ASTERISK},
    2995     {L'+',   java_awt_event_KeyEvent_VK_PLUS},
    2996     {L',',   java_awt_event_KeyEvent_VK_COMMA},
    2997     {L'-',   java_awt_event_KeyEvent_VK_MINUS},
    2998     {L'.',   java_awt_event_KeyEvent_VK_PERIOD},
    2999     {L'/',   java_awt_event_KeyEvent_VK_SLASH},
    3000     {L':',   java_awt_event_KeyEvent_VK_COLON},
    3001     {L';',   java_awt_event_KeyEvent_VK_SEMICOLON},
    3002     {L'<',   java_awt_event_KeyEvent_VK_LESS},
    3003     {L'=',   java_awt_event_KeyEvent_VK_EQUALS},
    3004     {L'>',   java_awt_event_KeyEvent_VK_GREATER},
    3005     {L'@',   java_awt_event_KeyEvent_VK_AT},
    3006     {L'[',   java_awt_event_KeyEvent_VK_OPEN_BRACKET},
    3007     {L'\\',  java_awt_event_KeyEvent_VK_BACK_SLASH},
    3008     {L']',   java_awt_event_KeyEvent_VK_CLOSE_BRACKET},
    3009     {L'^',   java_awt_event_KeyEvent_VK_CIRCUMFLEX},
    3010     {L'_',   java_awt_event_KeyEvent_VK_UNDERSCORE},
    3011     {L'`',   java_awt_event_KeyEvent_VK_BACK_QUOTE},
    3012     {L'{',   java_awt_event_KeyEvent_VK_BRACELEFT},
    3013     {L'}',   java_awt_event_KeyEvent_VK_BRACERIGHT},
    3014     {0x00A1, java_awt_event_KeyEvent_VK_INVERTED_EXCLAMATION_MARK},
    3015     {0x20A0, java_awt_event_KeyEvent_VK_EURO_SIGN}, // ????
    3016     {0,0}
    3017 };
    3018
    3019 // For dead accents some layouts return ASCII punctuation, while some
    3020 // return spacing accent chars, so both should be listed.  NB: MS docs
    3021 // say that conversion routings return spacing accent character, not
    3022 // combining.
    3023 static const CharToVKEntry charToDeadVKTable[] = {
    3024     {L'`',   java_awt_event_KeyEvent_VK_DEAD_GRAVE},
    3025     {L'\'',  java_awt_event_KeyEvent_VK_DEAD_ACUTE},
    3026     {0x00B4, java_awt_event_KeyEvent_VK_DEAD_ACUTE},
    3027     {L'^',   java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX},
    3028     {L'~',   java_awt_event_KeyEvent_VK_DEAD_TILDE},
    3029     {0x02DC, java_awt_event_KeyEvent_VK_DEAD_TILDE},
    3030     {0x00AF, java_awt_event_KeyEvent_VK_DEAD_MACRON},
    3031     {0x02D8, java_awt_event_KeyEvent_VK_DEAD_BREVE},
    3032     {0x02D9, java_awt_event_KeyEvent_VK_DEAD_ABOVEDOT},
    3033     {L'"',   java_awt_event_KeyEvent_VK_DEAD_DIAERESIS},
    3034     {0x00A8, java_awt_event_KeyEvent_VK_DEAD_DIAERESIS},
    3035     {0x02DA, java_awt_event_KeyEvent_VK_DEAD_ABOVERING},
    3036     {0x02DD, java_awt_event_KeyEvent_VK_DEAD_DOUBLEACUTE},
    3037     {0x02C7, java_awt_event_KeyEvent_VK_DEAD_CARON},            // aka hacek
    3038     {L',',   java_awt_event_KeyEvent_VK_DEAD_CEDILLA},
    3039     {0x00B8, java_awt_event_KeyEvent_VK_DEAD_CEDILLA},
    3040     {0x02DB, java_awt_event_KeyEvent_VK_DEAD_OGONEK},
    3041     {0x037A, java_awt_event_KeyEvent_VK_DEAD_IOTA},             // ASCII ???
    3042     {0x309B, java_awt_event_KeyEvent_VK_DEAD_VOICED_SOUND},
    3043     {0x309C, java_awt_event_KeyEvent_VK_DEAD_SEMIVOICED_SOUND},
    3044     {0x0004, java_awt_event_KeyEvent_VK_COMPOSE},
    3045     {0,0}
    3046 };
    3047
    3048 // The full map of the current keyboard state including
    3049 // windows virtual key, scancode, java virtual key, and unicode
    3050 // for this key sans modifiers.
    3051 // All but first element may be 0.
    3052 // XXX in the update releases this is an addition to the unchanged existing code
    3053 struct DynPrimaryKeymapEntry {
    3054     UINT wkey;
    3055     UINT scancode;
    3056     UINT jkey;
    3057     WCHAR unicode;
    3058 };
    3059
    3060 static DynPrimaryKeymapEntry dynPrimaryKeymap[256];
    3061
    3062 void
    3063 AwtComponent::InitDynamicKeyMapTable()
    3064 {
    3065     static BOOL kbdinited = FALSE;
    3066
    3067     if (!kbdinited) {
    3068         AwtComponent::BuildDynamicKeyMapTable();
    3069         // We cannot build it here since JNI is not available yet:
    3070         //AwtComponent::BuildPrimaryDynamicTable();
    3071         kbdinited = TRUE;
    3072     }
    3073 }
    3074
    3075 void
    3076 AwtComponent::BuildDynamicKeyMapTable()
    3077 {
    3078     HKL hkl = GetKeyboardLayout();
    3079
    3080     DTRACE_PRINTLN2("Building dynamic VK mapping tables: HKL = %08X (CP%d)",
    3081                     hkl, AwtComponent::GetCodePage());
    3082
    3083     // Will need this to reset layout after dead keys.
    3084     UINT spaceScanCode = ::MapVirtualKeyEx(VK_SPACE, 0, hkl);
    3085
    3086     // Entries in dynamic table that maps between Java VK and Windows
    3087     // VK are built in three steps:
    3088     //   1. Map windows VK to ANSI character (cannot map to unicode
    3089     //      directly, since ::ToUnicode is not implemented on win9x)
    3090     //   2. Convert ANSI char to Unicode char
    3091     //   3. Map Unicode char to Java VK via two auxilary tables.
    3092
    3093     for (DynamicKeyMapEntry *dynamic = dynamicKeyMapTable;
    3094          dynamic->windowsKey != 0;
    3095          ++dynamic)
    3096     {
    3097         // Defaults to VK_UNDEFINED
    3098         dynamic->javaKey = java_awt_event_KeyEvent_VK_UNDEFINED;
    3099
    3100         BYTE kbdState[AwtToolkit::KB_STATE_SIZE];
    3101         AwtToolkit::GetKeyboardState(kbdState);
    3102
    3103         kbdState[dynamic->windowsKey] |=  0x80; // Press the key.
    3104
    3105         // Unpress modifiers, since they are most likely pressed as
    3106         // part of the keyboard switching shortcut.
    3107         kbdState[VK_CONTROL] &= ~0x80;
    3108         kbdState[VK_SHIFT]   &= ~0x80;
    3109         kbdState[VK_MENU]    &= ~0x80;
    3110
    3111         char cbuf[2] = { '\0', '\0'};
    3112         UINT scancode = ::MapVirtualKeyEx(dynamic->windowsKey, 0, hkl);
    3113         int nchars = ::ToAsciiEx(dynamic->windowsKey, scancode, kbdState,
    3114                                  (WORD*)cbuf, 0, hkl);
    3115
    3116         // Auxiliary table used to map Unicode character to Java VK.
    3117         // Will assign a different table for dead keys (below).
    3118         const CharToVKEntry *charMap = charToVKTable;
    3119
    3120         if (nchars < 0) { // Dead key
    3121             // Use a different table for dead chars since different layouts
    3122             // return different characters for the same dead key.
    3123             charMap = charToDeadVKTable;
    3124
    3125             // We also need to reset layout so that next translation
    3126             // is unaffected by the dead status.  We do this by
    3127             // translating <SPACE> key.
    3128             kbdState[dynamic->windowsKey] &= ~0x80;
    3129             kbdState[VK_SPACE] |= 0x80;
    3130
    3131             char junkbuf[2] = { '\0', '\0'};
    3132             ::ToAsciiEx(VK_SPACE, spaceScanCode, kbdState,
    3133                         (WORD*)junkbuf, 0, hkl);
    3134         }
    3135
    3136 #ifdef DEBUG
    3137         if (nchars == 0) {
    3138             DTRACE_PRINTLN1("VK 0x%02X -> cannot convert to ANSI char",
    3139                             dynamic->windowsKey);
    3140             continue;
    3141         }
    3142         else if (nchars > 1) {  // can't happen, see reset code below
    3143             DTRACE_PRINTLN3("VK 0x%02X -> converted to <0x%02X,0x%02X>",
    3144                             dynamic->windowsKey,
    3145                             (UCHAR)cbuf[0], (UCHAR)cbuf[1]);
    3146             continue;
    3147         }
    3148 #endif
    3149
    3150         WCHAR ucbuf[2] = { L'\0', L'\0' };
    3151         int nconverted = ::MultiByteToWideChar(AwtComponent::GetCodePage(), 0,
    3152                                                cbuf, 1, ucbuf, 2);
    3153 #ifdef DEBUG
    3154         if (nconverted < 0) {
    3155             DTRACE_PRINTLN3("VK 0x%02X -> ANSI 0x%02X -> MultiByteToWideChar failed (0x%X)",
    3156                             dynamic->windowsKey, (UCHAR)cbuf[0],
    3157                             ::GetLastError());
    3158             continue;
    3159         }
    3160 #endif
    3161
    3162         WCHAR uc = ucbuf[0];
    3163         for (const CharToVKEntry *map = charMap;  map->c != 0;  ++map) {
    3164             if (uc == map->c) {
    3165                 dynamic->javaKey = map->javaKey;
    3166                 break;
    3167             }
    3168         }
    3169
    3170         DTRACE_PRINTLN4("VK 0x%02X -> ANSI 0x%02X -> U+%04X -> Java VK 0x%X",
    3171                         dynamic->windowsKey, (UCHAR)cbuf[0], (UINT)ucbuf[0],
    3172                         dynamic->javaKey);
    3173     } // for each VK_OEM_*
    3174 }
    3175
    3176
    3177 static BOOL isKanaLockAvailable()
    3178 {
    3179     // This method is to determine whether the Kana Lock feature is
    3180     // available on the attached keyboard.  Kana Lock feature does not
    3181     // necessarily require that the real KANA keytop is available on
    3182     // keyboard, so using MapVirtualKey(VK_KANA) is not sufficient for testing.
    3183     // Instead of that we regard it as Japanese keyboard (w/ Kana Lock) if :-
    3184     //
    3185     // - the keyboard layout is Japanese (VK_KANA has the same value as VK_HANGUL)
    3186     // - the keyboard is Japanese keyboard (keyboard type == 7).
    3187     return (LOWORD(GetKeyboardLayout(0)) == MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT))
    3188         && (GetKeyboardType(0) == 7);
    3189 }
    3190
    3191 void AwtComponent::JavaKeyToWindowsKey(UINT javaKey,
    3192                                        UINT *windowsKey, UINT *modifiers, UINT originalWindowsKey)
    3193 {
    3194     // Handle the few cases where a Java VK code corresponds to a Windows
    3195     // key/modifier combination or applies only to specific keyboard layouts
    3196     switch (javaKey) {
    3197         case java_awt_event_KeyEvent_VK_ALL_CANDIDATES:
    3198             *windowsKey = VK_CONVERT;
    3199             *modifiers = java_awt_event_InputEvent_ALT_DOWN_MASK;
    3200             return;
    3201         case java_awt_event_KeyEvent_VK_PREVIOUS_CANDIDATE:
    3202             *windowsKey = VK_CONVERT;
    3203             *modifiers = java_awt_event_InputEvent_SHIFT_DOWN_MASK;
    3204             return;
    3205         case java_awt_event_KeyEvent_VK_CODE_INPUT:
    3206             *windowsKey = VK_DBE_ALPHANUMERIC;
    3207             *modifiers = java_awt_event_InputEvent_ALT_DOWN_MASK;
    3208             return;
    3209         case java_awt_event_KeyEvent_VK_KANA_LOCK:
    3210             if (isKanaLockAvailable()) {
    3211                 *windowsKey = VK_KANA;
    3212                 *modifiers = java_awt_event_InputEvent_CTRL_DOWN_MASK;
    3213                 return;
    3214             }
    3215     }
    3216
    3217     // for the general case, use a bi-directional table
    3218     for (int i = 0; keyMapTable[i].windowsKey != 0; i++) {
    3219         if (keyMapTable[i].javaKey == javaKey) {
    3220             *windowsKey = keyMapTable[i].windowsKey;
    3221             *modifiers = 0;
    3222             return;
    3223         }
    3224     }
    3225
    3226     // Bug 4766655
    3227     // Two Windows keys could map to the same Java key, so
    3228     // give preference to the originalWindowsKey if it is
    3229     // specified (not IGNORE_KEY).
    3230     if (originalWindowsKey == IGNORE_KEY) {
    3231         for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
    3232             if (dynamicKeyMapTable[j].javaKey == javaKey) {
    3233                 *windowsKey = dynamicKeyMapTable[j].windowsKey;
    3234                 *modifiers = 0;
    3235                 return;
    3236             }
    3237         }
    3238     } else {
    3239         BOOL found = false;
    3240         for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
    3241             if (dynamicKeyMapTable[j].javaKey == javaKey) {
    3242                 *windowsKey = dynamicKeyMapTable[j].windowsKey;
    3243                 *modifiers = 0;
    3244                 found = true;
    3245                 if (*windowsKey == originalWindowsKey) {
    3246                     return;   /* if ideal case found return, else keep looking */
    3247                 }
    3248             }
    3249         }
    3250         if (found) {
    3251             return;
    3252         }
    3253     }
    3254
    3255     *windowsKey = 0;
    3256     *modifiers = 0;
    3257     return;
    3258 }
    3259
    3260 UINT AwtComponent::WindowsKeyToJavaKey(UINT windowsKey, UINT modifiers, UINT character, BOOL isDeadKey)
    3261
    3262 {
    3263     // Handle the few cases where we need to take the modifier into
    3264     // consideration for the Java VK code or where we have to take the keyboard
    3265     // layout into consideration so that function keys can get
    3266     // recognized in a platform-independent way.
    3267     switch (windowsKey) {
    3268         case VK_CONVERT:
    3269             if ((modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) != 0) {
    3270                 return java_awt_event_KeyEvent_VK_ALL_CANDIDATES;
    3271             }
    3272             if ((modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) != 0) {
    3273                 return java_awt_event_KeyEvent_VK_PREVIOUS_CANDIDATE;
    3274             }
    3275             break;
    3276         case VK_DBE_ALPHANUMERIC:
    3277             if ((modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) != 0) {
    3278                 return java_awt_event_KeyEvent_VK_CODE_INPUT;
    3279             }
    3280             break;
    3281         case VK_KANA:
    3282             if (isKanaLockAvailable()) {
    3283                 return java_awt_event_KeyEvent_VK_KANA_LOCK;
    3284             }
    3285             break;
    3286     };
    3287
    3288     // check dead key
    3289     if (isDeadKey) {
    3290       for (int i = 0; charToDeadVKTable[i].c != 0; i++) {
    3291         if (charToDeadVKTable[i].c == character) {
    3292             return charToDeadVKTable[i].javaKey;
    3293         }
    3294       }
    3295     }
    3296
    3297     // for the general case, use a bi-directional table
    3298     for (int i = 0; keyMapTable[i].windowsKey != 0; i++) {
    3299         if (keyMapTable[i].windowsKey == windowsKey) {
    3300             return keyMapTable[i].javaKey;
    3301         }
    3302     }
    3303
    3304     for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
    3305         if (dynamicKeyMapTable[j].windowsKey == windowsKey) {
    3306             if (dynamicKeyMapTable[j].javaKey != java_awt_event_KeyEvent_VK_UNDEFINED) {
    3307                 return dynamicKeyMapTable[j].javaKey;
    3308             }else{
    3309                 break;
    3310             }
    3311         }
    3312     }
    3313
    3314     return java_awt_event_KeyEvent_VK_UNDEFINED;
    3315 }
    3316
    3317 BOOL AwtComponent::IsNavigationKey(UINT wkey) {
    3318     switch (wkey) {
    3319       case VK_END:
    3320       case VK_PRIOR:  // PageUp
    3321       case VK_NEXT:  // PageDown
    3322       case VK_HOME:
    3323       case VK_LEFT:
    3324       case VK_UP:
    3325       case VK_RIGHT:
    3326       case VK_DOWN:
    3327           return TRUE;
    3328     }
    3329     return FALSE;
    3330 }
    3331
    3332 // determine if a key is a numpad key (distinguishes the numpad
    3333 // arrow keys from the non-numpad arrow keys, for example).
    3334 BOOL AwtComponent::IsNumPadKey(UINT vkey, BOOL extended)
    3335 {
    3336     // Note: scancodes are the same for the numpad arrow keys and
    3337     // the non-numpad arrow keys (also for PageUp, etc.).
    3338     // The scancodes for the numpad divide and the non-numpad slash
    3339     // are the same, but the wparams are different
    3340
    3341     DTRACE_PRINTLN3("AwtComponent::IsNumPadKey  vkey = %d = 0x%x  extended = %d",
    3342       vkey, vkey, extended);
    3343
    3344     switch (vkey) {
    3345       case VK_CLEAR:  // numpad 5 with numlock off
    3346       case VK_NUMPAD0:
    3347       case VK_NUMPAD1:
    3348       case VK_NUMPAD2:
    3349       case VK_NUMPAD3:
    3350       case VK_NUMPAD4:
    3351       case VK_NUMPAD5:
    3352       case VK_NUMPAD6:
    3353       case VK_NUMPAD7:
    3354       case VK_NUMPAD8:
    3355       case VK_NUMPAD9:
    3356       case VK_MULTIPLY:
    3357       case VK_ADD:
    3358       case VK_SEPARATOR:  // numpad ,  not on US kbds
    3359       case VK_SUBTRACT:
    3360       case VK_DECIMAL:
    3361       case VK_DIVIDE:
    3362       case VK_NUMLOCK:
    3363         return TRUE;
    3364         break;
    3365       case VK_END:
    3366       case VK_PRIOR:  // PageUp
    3367       case VK_NEXT:  // PageDown
    3368       case VK_HOME:
    3369       case VK_LEFT:
    3370       case VK_UP:
    3371       case VK_RIGHT:
    3372       case VK_DOWN:
    3373       case VK_INSERT:
    3374       case VK_DELETE:
    3375         // extended if non-numpad
    3376         return (!extended);
    3377         break;
    3378       case VK_RETURN:  // extended if on numpad
    3379         return (extended);
    3380         break;
    3381       default:
    3382         break;
    3383     }
    3384
    3385     return FALSE;
    3386 }
    3387 static void
    3388 resetKbdState( BYTE kstate[256]) {
    3389     BYTE tmpState[256];
    3390     WCHAR wc[2];
    3391     memmove(tmpState, kstate, sizeof(kstate));
    3392     tmpState[VK_SHIFT] = 0;
    3393     tmpState[VK_CONTROL] = 0;
    3394     tmpState[VK_MENU] = 0;
    3395
    3396     ::ToUnicodeEx(VK_SPACE,::MapVirtualKey(VK_SPACE, 0), tmpState, wc, 2, 0,  GetKeyboardLayout(0));
    3397 }
    3398
    3399 // XXX in the update releases this is an addition to the unchanged existing code
    3400 // After the call, a table will have a unicode associated with a windows virtual keycode
    3401 // sans modifiers. With some further simplification, one can
    3402 // derive java keycode from it, and anyway we will pass this unicode value
    3403 // all the way up in a comment to a KeyEvent.
    3404 void
    3405 AwtComponent::BuildPrimaryDynamicTable() {
    3406     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    3407     // XXX: how about that?
    3408     //CriticalSection::Lock l(GetLock());
    3409     //if (GetPeer(env) == NULL) {
    3410     //    /* event received during termination. */
    3411     //    return;
    3412     //}
    3413
    3414     HKL hkl = GetKeyboardLayout();
    3415     UINT sc = 0;
    3416     BYTE kbdState[AwtToolkit::KB_STATE_SIZE];
    3417     memset(kbdState, 0, sizeof (kbdState));
    3418
    3419     // Use JNI call to obtain java key code. We should keep a list
    3420     // of currently available keycodes in a single place.
    3421     static jclass extKeyCodesCls;
    3422     if( extKeyCodesCls == NULL) {
    3423         jclass extKeyCodesClsLocal = env->FindClass("sun/awt/ExtendedKeyCodes");
    3424         DASSERT(extKeyCodesClsLocal);
    3425         CHECK_NULL(extKeyCodesClsLocal);
    3426         extKeyCodesCls = (jclass)env->NewGlobalRef(extKeyCodesClsLocal);
    3427         env->DeleteLocalRef(extKeyCodesClsLocal);
    3428     }
    3429     static jmethodID getExtendedKeyCodeForChar;
    3430     if (getExtendedKeyCodeForChar == NULL) {
    3431         getExtendedKeyCodeForChar =
    3432                   env->GetStaticMethodID(extKeyCodesCls, "getExtendedKeyCodeForChar", "(I)I");
    3433         DASSERT(getExtendedKeyCodeForChar);
    3434         CHECK_NULL(getExtendedKeyCodeForChar);
    3435     }
    3436     jint extJKC; //extended Java key code
    3437
    3438     for (UINT i = 0; i < 256; i++) {
    3439         dynPrimaryKeymap[i].wkey = i;
    3440         dynPrimaryKeymap[i].jkey = java_awt_event_KeyEvent_VK_UNDEFINED;
    3441         dynPrimaryKeymap[i].unicode = 0;
    3442
    3443         if ((sc = MapVirtualKey (i, 0)) == 0) {
    3444             dynPrimaryKeymap[i].scancode = 0;
    3445             continue;
    3446         }
    3447         dynPrimaryKeymap[i].scancode = sc;
    3448
    3449         // XXX process cases like VK_SHIFT etc.
    3450         kbdState[i] = 0x80; // "key pressed".
    3451         WCHAR wc[16];
    3452         int k = ::ToUnicodeEx(i, sc, kbdState, wc, 16, 0, hkl);
    3453         if (k == 1) {
    3454             // unicode
    3455             dynPrimaryKeymap[i].unicode = wc[0];
    3456             if (dynPrimaryKeymap[i].jkey == java_awt_event_KeyEvent_VK_UNDEFINED) {
    3457             // Convert unicode to java keycode.
    3458                 //dynPrimaryKeymap[i].jkey = ((UINT)(wc[0]) + 0x01000000);
    3459                 //
    3460                 //XXX If this key in on the keypad, we should force a special value equal to
    3461                 //XXX an old java keycode: but how to say if it is a keypad key?
    3462                 //XXX We'll do it in WmKeyUp/Down.
    3463                 extJKC = env->CallStaticIntMethod(extKeyCodesCls,
    3464                                                   getExtendedKeyCodeForChar, (jint)(wc[0]));
    3465                 dynPrimaryKeymap[i].jkey = extJKC;
    3466             }
    3467         }else if (k == -1) {
    3468             // dead key: use charToDeadVKTable
    3469             dynPrimaryKeymap[i].unicode = wc[0];
    3470             resetKbdState( kbdState );
    3471             for (const CharToVKEntry *map = charToDeadVKTable;  map->c != 0;  ++map) {
    3472                 if (wc[0] == map->c) {
    3473                     dynPrimaryKeymap[i].jkey = map->javaKey;
    3474                     break;
    3475                 }
    3476             }
    3477         } else if (k == 0) {
    3478             // reset
    3479             resetKbdState( kbdState );
    3480         }else {
    3481             // k > 1: this key does generate multiple characters. Ignore it.
    3482             // An example: Arabic Lam and Alef ligature.
    3483             // There will be no extended keycode and thus shortcuts for this  key.
    3484             // XXX shouldn't we reset the kbd state?
    3485 #ifdef DEBUG
    3486             DTRACE_PRINTLN2("wkey 0x%02X (%d)", i,i);
    3487 #endif
    3488         }
    3489         kbdState[i] = 0; // "key unpressed"
    3490     }
    3491 }
    3492 void
    3493 AwtComponent::UpdateDynPrimaryKeymap(UINT wkey, UINT jkeyLegacy, jint keyLocation, UINT modifiers)
    3494 {
    3495     if( wkey && wkey < 256 ) {
    3496         if(keyLocation == java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD) {
    3497             // At the creation time,
    3498             // dynPrimaryKeymap cannot distinguish between e.g. "/" and "NumPad /"
    3499             dynPrimaryKeymap[wkey].jkey = jkeyLegacy;
    3500         }
    3501         if(dynPrimaryKeymap[wkey].jkey ==  java_awt_event_KeyEvent_VK_UNDEFINED) {
    3502             // E.g. it is non-unicode key
    3503             dynPrimaryKeymap[wkey].jkey = jkeyLegacy;
    3504         }
    3505     }
    3506 }
    3507
    3508 UINT AwtComponent::WindowsKeyToJavaChar(UINT wkey, UINT modifiers, TransOps ops, BOOL &isDeadKey)
    3509 {
    3510     static Hashtable transTable("VKEY translations");
    3511     static Hashtable deadKeyFlagTable("Dead Key Flags");
    3512     isDeadKey = FALSE;
    3513
    3514     // Try to translate using last saved translation
    3515     if (ops == LOAD) {
    3516        void* deadKeyFlag = deadKeyFlagTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
    3517        void* value = transTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
    3518        if (value != NULL) {
    3519            isDeadKey = static_cast<BOOL>(reinterpret_cast<INT_PTR>(deadKeyFlag));
    3520            return static_cast<UINT>(reinterpret_cast<INT_PTR>(value));
    3521        }
    3522     }
    3523
    3524     // If the windows key is a return, wkey will equal 13 ('\r')
    3525     // In this case, we want to return 10 ('\n')
    3526     // Since ToAscii would convert VK_RETURN to '\r', we need
    3527     // to have a special case here.
    3528     if (wkey == VK_RETURN)
    3529         return '\n';
    3530
    3531     // high order bit in keyboardState indicates whether the key is down
    3532     static const BYTE KEY_STATE_DOWN = 0x80;
    3533     BYTE    keyboardState[AwtToolkit::KB_STATE_SIZE];
    3534     AwtToolkit::GetKeyboardState(keyboardState);
    3535
    3536     // apply modifiers to keyboard state if necessary
    3537     BOOL shiftIsDown = FALSE;
    3538     if (modifiers) {
    3539         shiftIsDown = modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK;
    3540         BOOL altIsDown = modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK;

    3541         BOOL ctrlIsDown = modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK;
    3542
    3543         // Windows treats AltGr as Ctrl+Alt
    3544         if (modifiers & java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK) {
    3545             altIsDown = TRUE;
    3546             ctrlIsDown = TRUE;
    3547         }
    3548
    3549         if (shiftIsDown) {
    3550             keyboardState[VK_SHIFT] |= KEY_STATE_DOWN;
    3551         }
    3552
    3553         // fix for 4623376,4737679,4501485,4740906,4708221 (4173679/4122715)
    3554         // Here we try to resolve a conflict with ::ToAsciiEx's translating
    3555         // ALT+number key combinations. kdm@sarc.spb.su
    3556         // yan: Do it for navigation keys only, otherwise some AltGr deadkeys fail.
    3557         if( IsNavigationKey(wkey) ) {
    3558             keyboardState[VK_MENU] &= ~KEY_STATE_DOWN;
    3559         }
    3560
    3561         if (ctrlIsDown)
    3562         {
    3563             if (altIsDown) {
    3564                 // bugid 4215009: don't mess with AltGr == Ctrl + Alt
    3565                 keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
    3566             }
    3567             else {
    3568                 // bugid 4098210: old event model doesn't have KEY_TYPED
    3569                 // events, so try to provide a meaningful character for
    3570                 // Ctrl+<key>.  Take Ctrl into account only when we know
    3571                 // that Ctrl+<key> will be an ASCII control.  Ignore by
    3572                 // default.
    3573                 keyboardState[VK_CONTROL] &= ~KEY_STATE_DOWN;
    3574
    3575                 // Letters have Ctrl+<letter> counterparts.  According to
    3576                 // <winuser.h> VK_A through VK_Z are the same as ASCII
    3577                 // 'A' through 'Z'.
    3578                 if (wkey >= 'A' && wkey <= 'Z') {
    3579                     keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
    3580                 }
    3581                 else {
    3582                     // Non-letter controls 033 to 037 are:
    3583                     // ^[ (ESC), ^\ (FS), ^] (GS), ^^ (RS), and ^_ (US)
    3584
    3585                     // Shift state bits returned by ::VkKeyScan in HIBYTE
    3586                     static const UINT _VKS_SHIFT_MASK = 0x01;
    3587                     static const UINT _VKS_CTRL_MASK = 0x02;
    3588                     static const UINT _VKS_ALT_MASK = 0x04;
    3589
    3590                     // Check to see whether there is a meaningful translation
    3591                     TCHAR ch;
    3592                     short vk;
    3593                     for (ch = _T('\033'); ch < _T('\040'); ch++) {
    3594                         vk = ::VkKeyScan(ch);
    3595                         if (wkey == LOBYTE(vk)) {
    3596                             UINT shiftState = HIBYTE(vk);
    3597                             if ((shiftState & _VKS_CTRL_MASK) ||
    3598                                 (!(shiftState & _VKS_SHIFT_MASK)
    3599                                 == !shiftIsDown))
    3600                             {
    3601                                 keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
    3602                             }
    3603                             break;
    3604                         }
    3605                     }
    3606                 }
    3607             } // ctrlIsDown && altIsDown
    3608         } // ctrlIsDown
    3609     } // modifiers
    3610
    3611     WORD wChar[2];
    3612     int converted = 1;
    3613     UINT ch = ::MapVirtualKeyEx(wkey, 2, GetKeyboardLayout());
    3614     if (ch & 0x80000000) {
    3615         // Dead key which is handled as a normal key
    3616         isDeadKey = deadKeyActive = TRUE;
    3617     } else if (deadKeyActive) {
    3618         // We cannot use ::ToUnicodeEx if dead key is active because this will
    3619         // break dead key function
    3620         wChar[0] = shiftIsDown ? ch : tolower(ch);
    3621     } else {
    3622         UINT scancode = ::MapVirtualKey(wkey, 0);
    3623         converted = ::ToUnicodeEx(wkey, scancode, keyboardState,
    3624                                               wChar, 2, 0, GetKeyboardLayout());
    3625     }
    3626
    3627     UINT translation;
    3628     BOOL deadKeyFlag = (converted == 2);
    3629
    3630     // Dead Key
    3631     if (converted < 0 || isDeadKey) {
    3632         translation = java_awt_event_KeyEvent_CHAR_UNDEFINED;
    3633     } else
    3634     // No translation available -- try known conversions or else punt.
    3635     if (converted == 0) {
    3636         if (wkey == VK_DELETE) {
    3637             translation = '\177';
    3638         } else
    3639         if (wkey >= VK_NUMPAD0 && wkey <= VK_NUMPAD9) {
    3640             translation = '0' + wkey - VK_NUMPAD0;
    3641         } else {
    3642             translation = java_awt_event_KeyEvent_CHAR_UNDEFINED;
    3643         }
    3644     } else
    3645     // the caller expects a Unicode character.
    3646     if (converted > 0) {
    3647         translation = wChar[0];
    3648     }
    3649     if (ops == SAVE) {
    3650         transTable.put(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)),
    3651                        reinterpret_cast<void*>(static_cast<INT_PTR>(translation)));
    3652         if (deadKeyFlag) {
    3653             deadKeyFlagTable.put(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)),
    3654                          reinterpret_cast<void*>(static_cast<INT_PTR>(deadKeyFlag)));
    3655         } else {
    3656             deadKeyFlagTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
    3657         }
    3658     }
    3659
    3660     isDeadKey = deadKeyFlag;
    3661     return translation;
    3662 }
    3663
    3664 MsgRouting AwtComponent::WmKeyDown(UINT wkey, UINT repCnt,
    3665                                    UINT flags, BOOL system)
    3666 {
    3667     // VK_PROCESSKEY is a special value which means
    3668     //          "Current IME wants to consume this KeyEvent"
    3669     // Real key code is saved by IMM32.DLL and can be retrieved by
    3670     // calling ImmGetVirtualKey();
    3671     if (wkey == VK_PROCESSKEY) {
    3672         return mrDoDefault;
    3673     }
    3674     MSG msg;
    3675     InitMessage(&msg, (system ? WM_SYSKEYDOWN : WM_KEYDOWN),
    3676                              wkey, MAKELPARAM(repCnt, flags));
    3677
    3678     UINT modifiers = GetJavaModifiers();
    3679     jint keyLocation = GetKeyLocation(wkey, flags);
    3680     BOOL isDeadKey = FALSE;
    3681     UINT character = WindowsKeyToJavaChar(wkey, modifiers, SAVE, isDeadKey);
    3682     UINT jkey = WindowsKeyToJavaKey(wkey, modifiers, character, isDeadKey);
    3683     UpdateDynPrimaryKeymap(wkey, jkey, keyLocation, modifiers);
    3684
    3685
    3686     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_PRESSED,
    3687                              ::JVM_CurrentTimeMillis(NULL, 0), jkey, character,
    3688                              modifiers, keyLocation, (jlong)wkey, &msg);
    3689
    3690     // bugid 4724007: Windows does not create a WM_CHAR for the Del key
    3691     // for some reason, so we need to create the KEY_TYPED event on the
    3692     // WM_KEYDOWN.  Use null msg so the character doesn't get sent back
    3693     // to the native window for processing (this event is synthesized
    3694     // for Java - we don't want Windows trying to process it).
    3695     if (jkey == java_awt_event_KeyEvent_VK_DELETE) {
    3696         SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
    3697                                  ::JVM_CurrentTimeMillis(NULL, 0),
    3698                                  java_awt_event_KeyEvent_VK_UNDEFINED,
    3699                                  character, modifiers,
    3700                                  java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0);
    3701     }
    3702
    3703     return mrConsume;
    3704 }
    3705
    3706 MsgRouting AwtComponent::WmKeyUp(UINT wkey, UINT repCnt,
    3707                                  UINT flags, BOOL system)
    3708 {
    3709
    3710     // VK_PROCESSKEY is a special value which means
    3711     //          "Current IME wants to consume this KeyEvent"
    3712     // Real key code is saved by IMM32.DLL and can be retrieved by
    3713     // calling ImmGetVirtualKey();
    3714     if (wkey == VK_PROCESSKEY) {
    3715         return mrDoDefault;
    3716     }
    3717     MSG msg;
    3718     InitMessage(&msg, (system ? WM_SYSKEYUP : WM_KEYUP),
    3719                              wkey, MAKELPARAM(repCnt, flags));
    3720
    3721     UINT modifiers = GetJavaModifiers();
    3722     jint keyLocation = GetKeyLocation(wkey, flags);
    3723     BOOL isDeadKey = FALSE;
    3724     UINT character = WindowsKeyToJavaChar(wkey, modifiers, LOAD, isDeadKey);
    3725     UINT jkey = WindowsKeyToJavaKey(wkey, modifiers, character, isDeadKey);
    3726     UpdateDynPrimaryKeymap(wkey, jkey, keyLocation, modifiers);
    3727
    3728     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_RELEASED,
    3729                              ::JVM_CurrentTimeMillis(NULL, 0), jkey, character,
    3730                              modifiers, keyLocation, (jlong)wkey, &msg);
    3731     return mrConsume;
    3732 }
    3733
    3734 MsgRouting AwtComponent::WmInputLangChange(UINT charset, HKL hKeyboardLayout)
    3735 {
    3736     // Normally we would be able to use charset and TranslateCharSetInfo
    3737     // to get a code page that should be associated with this keyboard
    3738     // layout change. However, there seems to be an NT 4.0 bug associated
    3739     // with the WM_INPUTLANGCHANGE message, which makes the charset parameter
    3740     // unreliable, especially on Asian systems. Our workaround uses the
    3741     // keyboard layout handle instead.
    3742     m_hkl = hKeyboardLayout;
    3743     m_idLang = LOWORD(hKeyboardLayout); // lower word of HKL is LANGID
    3744     m_CodePage = LangToCodePage(m_idLang);
    3745     BuildDynamicKeyMapTable();  // compute new mappings for VK_OEM
    3746     BuildPrimaryDynamicTable();
    3747     return mrConsume;           // do not propagate to children
    3748 }
    3749
    3750 // Convert Language ID to CodePage
    3751 UINT AwtComponent::LangToCodePage(LANGID idLang)
    3752 {
    3753     TCHAR strCodePage[MAX_ACP_STR_LEN];
    3754     // use the LANGID to create a LCID
    3755     LCID idLocale = MAKELCID(idLang, SORT_DEFAULT);
    3756     // get the ANSI code page associated with this locale
    3757     if (GetLocaleInfo(idLocale, LOCALE_IDEFAULTANSICODEPAGE, strCodePage, sizeof(strCodePage)/sizeof(TCHAR)) > 0 )
    3758         return _ttoi(strCodePage);
    3759     else
    3760         return GetACP();
    3761 }
    3762
    3763
    3764 MsgRouting AwtComponent::WmIMEChar(UINT character, UINT repCnt, UINT flags, BOOL system)
    3765 {
    3766     // We will simply create Java events here.
    3767     WCHAR unicodeChar = character;
    3768     MSG msg;
    3769     InitMessage(&msg, WM_IME_CHAR, character,
    3770                               MAKELPARAM(repCnt, flags));
    3771
    3772     jint modifiers = GetJavaModifiers();
    3773     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
    3774                              ::JVM_CurrentTimeMillis(NULL, 0),
    3775                              java_awt_event_KeyEvent_VK_UNDEFINED,
    3776                              unicodeChar, modifiers,
    3777                              java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0,
    3778                              &msg);
    3779     return mrConsume;
    3780 }
    3781
    3782 MsgRouting AwtComponent::WmChar(UINT character, UINT repCnt, UINT flags,
    3783                                 BOOL system)
    3784 {
    3785     deadKeyActive = FALSE;
    3786
    3787     // Will only get WmChar messages with DBCS if we create them for
    3788     // an Edit class in the WmForwardChar method. These synthesized
    3789     // DBCS chars are ok to pass on directly to the default window
    3790     // procedure. They've already been filtered through the Java key
    3791     // event queue. We will never get the trail byte since the edit
    3792     // class will PeekMessage(&msg, hwnd, WM_CHAR, WM_CHAR,
    3793     // PM_REMOVE).  I would like to be able to pass this character off
    3794     // via WM_AWT_FORWARD_BYTE, but the Edit classes don't seem to
    3795     // like that.
    3796
    3797     // We will simply create Java events here.
    3798     UINT message = system ? WM_SYSCHAR : WM_CHAR;
    3799
    3800     // The Alt modifier is reported in the 29th bit of the lParam,
    3801     // i.e., it is the 13th bit of `flags' (which is HIWORD(lParam)).
    3802     bool alt_is_down = (flags & (1<<13)) != 0;
    3803
    3804     // Fix for bug 4141621, corrected by fix for bug 6223726: Alt+space doesn't invoke system menu
    3805     // We should not pass this particular combination to Java.
    3806
    3807     if (system && alt_is_down) {
    3808         if (character == VK_SPACE) {
    3809             return mrDoDefault;
    3810         }
    3811     }
    3812
    3813     // If this is a WM_CHAR (non-system) message, then the Alt flag
    3814     // indicates that the character was typed using an AltGr key
    3815     // (which Windows treats as Ctrl+Alt), so in this case we do NOT
    3816     // pass the Ctrl and Alt modifiers to Java, but instead we
    3817     // replace them with Java's AltGraph modifier.  Note: the AltGraph
    3818     // modifier does not exist in 1.1.x releases.
    3819     jint modifiers = GetJavaModifiers();
    3820     if (!system && alt_is_down) {
    3821         // character typed with AltGraph
    3822         modifiers &= ~(java_awt_event_InputEvent_ALT_DOWN_MASK
    3823                        | java_awt_event_InputEvent_CTRL_DOWN_MASK);
    3824         modifiers |= java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK;
    3825     }
    3826
    3827     WCHAR unicodeChar = character;
    3828
    3829     // Kludge: Combine pending single byte with this char for some Chinese IMEs
    3830     if (m_PendingLeadByte != 0) {
    3831         character = (m_PendingLeadByte & 0x00ff) | (character << 8);
    3832         m_PendingLeadByte = 0;
    3833         ::MultiByteToWideChar(GetCodePage(), 0, (CHAR*)&character, 2,
    3834                           &unicodeChar, 1);
    3835     }
    3836
    3837     if (unicodeChar == VK_RETURN) {
    3838         // Enter key generates \r in windows, but \n is required in java
    3839         unicodeChar = java_awt_event_KeyEvent_VK_ENTER;
    3840     }
    3841     MSG msg;
    3842     InitMessage(&msg, message, character,
    3843                               MAKELPARAM(repCnt, flags));
    3844     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
    3845                              ::JVM_CurrentTimeMillis(NULL, 0),
    3846                              java_awt_event_KeyEvent_VK_UNDEFINED,
    3847                              unicodeChar, modifiers,
    3848                              java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0,
    3849                              &msg);
    3850     return mrConsume;
    3851 }
    3852
    3853 MsgRouting AwtComponent::WmForwardChar(WCHAR character, LPARAM lParam,
    3854                                        BOOL synthetic)
    3855 {
    3856     // just post WM_CHAR with unicode key value
    3857     DefWindowProc(WM_CHAR, (WPARAM)character, lParam);
    3858     return mrConsume;
    3859 }
    3860
    3861 MsgRouting AwtComponent::WmPaste()
    3862 {
    3863     return mrDoDefault;
    3864 }
    3865
    3866 // support IME Composition messages
    3867 void AwtComponent::SetCompositionWindow(RECT& r)
    3868 {
    3869     HWND hwnd = ImmGetHWnd();
    3870     HIMC hIMC = ImmGetContext(hwnd);
    3871     if (hIMC == NULL) {
    3872         return;
    3873     }
    3874     COMPOSITIONFORM cf = {CFS_DEFAULT, {0, 0}, {0, 0, 0, 0}};
    3875     ImmSetCompositionWindow(hIMC, &cf);
    3876     ImmReleaseContext(hwnd, hIMC);
    3877 }
    3878
    3879 void AwtComponent::OpenCandidateWindow(int x, int y)
    3880 {
    3881     UINT bits = 1;
    3882     POINT p = {0, 0}; // upper left corner of the client area
    3883     HWND hWnd = GetHWnd();
    3884     if (!::IsWindowVisible(hWnd)) {
    3885         return;
    3886     }
    3887     HWND hTop = GetTopLevelParentForWindow(hWnd);
    3888     ::ClientToScreen(hTop, &p);
    3889     if (!m_bitsCandType) {
    3890         SetCandidateWindow(m_bitsCandType, x - p.x, y - p.y);
    3891         return;
    3892     }
    3893     for (int iCandType=0; iCandType<32; iCandType++, bits<<=1) {
    3894         if ( m_bitsCandType & bits )
    3895             SetCandidateWindow(iCandType, x - p.x, y - p.y);
    3896     }
    3897 }
    3898
    3899 void AwtComponent::SetCandidateWindow(int iCandType, int x, int y)
    3900 {
    3901     HWND hwnd = ImmGetHWnd();
    3902     HIMC hIMC = ImmGetContext(hwnd);
    3903     if (hIMC) {
    3904         CANDIDATEFORM cf;
    3905         cf.dwStyle = CFS_POINT;
    3906         ImmGetCandidateWindow(hIMC, 0, &cf);
    3907         if (x != cf.ptCurrentPos.x || y != cf.ptCurrentPos.y) {
    3908             cf.dwIndex = iCandType;
    3909             cf.dwStyle = CFS_POINT;
    3910             cf.ptCurrentPos = {x, y};
    3911             cf.rcArea = {0, 0, 0, 0};
    3912             ImmSetCandidateWindow(hIMC, &cf);
    3913         }
    3914         COMPOSITIONFORM cfr;
    3915         cfr.dwStyle = CFS_POINT;
    3916         ImmGetCompositionWindow(hIMC, &cfr);
    3917         if (x != cfr.ptCurrentPos.x || y != cfr.ptCurrentPos.y) {
    3918             cfr.dwStyle = CFS_POINT;
    3919             cfr.ptCurrentPos = {x, y};
    3920             cfr.rcArea = {0, 0, 0, 0};
    3921             ImmSetCompositionWindow(hIMC, &cfr);
    3922         }
    3923         ImmReleaseContext(hwnd, hIMC);
    3924     }
    3925 }
    3926
    3927 MsgRouting AwtComponent::WmImeSetContext(BOOL fSet, LPARAM *lplParam)
    3928 {
    3929     // If the Windows input context is disabled, do not let Windows
    3930     // display any UIs.
    3931     HWND hwnd = ImmGetHWnd();
    3932     HIMC hIMC = ImmGetContext(hwnd);
    3933     if (hIMC == NULL) {
    3934         *lplParam = 0;
    3935         return mrDoDefault;
    3936     }
    3937     ImmReleaseContext(hwnd, hIMC);
    3938
    3939     if (fSet) {
    3940         LPARAM lParam = *lplParam;
    3941         if (!m_useNativeCompWindow) {
    3942             // stop to draw native composing window.
    3943             *lplParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
    3944         }
    3945     }
    3946     return mrDoDefault;
    3947 }
    3948
    3949 MsgRouting AwtComponent::WmImeNotify(WPARAM subMsg, LPARAM bitsCandType)
    3950 {
    3951     if (!m_useNativeCompWindow) {
    3952         if (subMsg == IMN_OPENCANDIDATE || subMsg == IMN_CHANGECANDIDATE) {
    3953             m_bitsCandType = bitsCandType;
    3954             InquireCandidatePosition();
    3955         } else if (subMsg == IMN_OPENSTATUSWINDOW ||
    3956                    subMsg == WM_IME_STARTCOMPOSITION ||
    3957                    subMsg == IMN_SETCANDIDATEPOS) {
    3958             InquireCandidatePosition();
    3959         }
    3960     }
    3961     return mrDoDefault;
    3962 }
    3963
    3964 MsgRouting AwtComponent::WmImeStartComposition()
    3965 {
    3966     if (m_useNativeCompWindow) {
    3967         RECT rc;
    3968         ::GetClientRect(GetHWnd(), &rc);
    3969         SetCompositionWindow(rc);
    3970         return mrDoDefault;
    3971     } else
    3972         return mrConsume;
    3973 }
    3974
    3975 MsgRouting AwtComponent::WmImeEndComposition()
    3976 {
    3977     if (m_useNativeCompWindow)   return mrDoDefault;
    3978
    3979     SendInputMethodEvent(
    3980         java_awt_event_InputMethodEvent_INPUT_METHOD_TEXT_CHANGED,
    3981         NULL, 0, NULL, NULL, 0, NULL, NULL, 0, 0, 0 );
    3982     return mrConsume;
    3983 }
    3984
    3985 MsgRouting AwtComponent::WmImeComposition(WORD wChar, LPARAM flags)
    3986 {
    3987     if (m_useNativeCompWindow)   return mrDoDefault;
    3988
    3989     int*      bndClauseW = NULL;
    3990     jstring*  readingClauseW = NULL;
    3991     int*      bndAttrW = NULL;
    3992     BYTE*     valAttrW = NULL;
    3993     int       cClauseW = 0;
    3994     AwtInputTextInfor* textInfor = NULL;
    3995
    3996     try {
    3997         HWND hwnd = ImmGetHWnd();
    3998         HIMC hIMC = ImmGetContext(hwnd);
    3999         DASSERT(hIMC!=0);
    4000
    4001         textInfor = new AwtInputTextInfor;
    4002         textInfor->GetContextData(hIMC, flags);
    4003         ImmReleaseContext(hwnd, hIMC);
    4004
    4005         jstring jtextString = textInfor->GetText();
    4006         /* The conditions to send the input method event to AWT EDT are:
    4007            1. Whenever there is a composition message sent regarding whether
    4008            the composition text is NULL or not. See details at bug 6222692.
    4009            2. When there is a committed message sent, in which case, we have to
    4010            check whether the committed string is NULL or not. If the committed string
    4011            is NULL, there is no need to send any input method event.
    4012            (Minor note: 'jtextString' returned is the merged string in the case of
    4013            partial commit.)
    4014         */
    4015         if ((flags & GCS_RESULTSTR && jtextString != NULL) ||
    4016             (flags & GCS_COMPSTR)) {
    4017             int       cursorPosW = textInfor->GetCursorPosition();
    4018             // In order not to delete the readingClauseW in the catch clause,
    4019             // calling GetAttributeInfor before GetClauseInfor.
    4020             int       cAttrW = textInfor->GetAttributeInfor(bndAttrW, valAttrW);
    4021             cClauseW = textInfor->GetClauseInfor(bndClauseW, readingClauseW);
    4022
    4023             /* Send INPUT_METHOD_TEXT_CHANGED event to the WInputMethod which in turn sends
    4024                the event to AWT EDT.
    4025
    4026                The last two paremeters are set to equal since we don't have recommendations for
    4027                the visible position within the current composed text. See details at
    4028                java.awt.event.InputMethodEvent.
    4029             */
    4030             SendInputMethodEvent(java_awt_event_InputMethodEvent_INPUT_METHOD_TEXT_CHANGED,
    4031                                  jtextString,
    4032                                  cClauseW, bndClauseW, readingClauseW,
    4033                                  cAttrW, bndAttrW, valAttrW,
    4034                                  textInfor->GetCommittedTextLength(),
    4035                                  cursorPosW, cursorPosW);
    4036         }
    4037     } catch (...) {
    4038         // since GetClauseInfor and GetAttributeInfor could throw exception, we have to release
    4039         // the pointer here.
    4040         delete [] bndClauseW;
    4041         delete [] readingClauseW;
    4042         delete [] bndAttrW;
    4043         delete [] valAttrW;
    4044         throw;
    4045     }
    4046
    4047     /* Free the storage allocated. Since jtextString won't be passed from threads
    4048      *  to threads, we just use the local ref and it will be deleted within the destructor
    4049      *  of AwtInputTextInfor object.
    4050      */
    4051     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4052     if (cClauseW && readingClauseW) {
    4053         for (int i = 0; i < cClauseW; i ++) {
    4054             if (readingClauseW[i]) {
    4055                 env->DeleteLocalRef(readingClauseW[i]);
    4056             }
    4057         }
    4058     }
    4059     delete [] bndClauseW;
    4060     delete [] readingClauseW;
    4061     delete [] bndAttrW;
    4062     delete [] valAttrW;
    4063     delete textInfor;
    4064
    4065     return mrConsume;
    4066 }
    4067
    4068 //
    4069 // generate and post InputMethodEvent
    4070 //
    4071 void AwtComponent::SendInputMethodEvent(jint id, jstring text,
    4072                                         int cClause, int* rgClauseBoundary, jstring* rgClauseReading,
    4073                                         int cAttrBlock, int* rgAttrBoundary, BYTE *rgAttrValue,
    4074                                         int commitedTextLength, int caretPos, int visiblePos)
    4075 {
    4076     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4077
    4078     // assumption for array type casting
    4079     DASSERT(sizeof(int)==sizeof(jint));
    4080     DASSERT(sizeof(BYTE)==sizeof(jbyte));
    4081
    4082     // caluse information
    4083     jintArray clauseBoundary = NULL;
    4084     jobjectArray clauseReading = NULL;
    4085     if (cClause && rgClauseBoundary && rgClauseReading) {
    4086         // convert clause boundary offset array to java array
    4087         clauseBoundary = env->NewIntArray(cClause+1);
    4088         DASSERT(clauseBoundary);
    4089         CHECK_NULL(clauseBoundary);
    4090         env->SetIntArrayRegion(clauseBoundary, 0, cClause+1, (jint *)rgClauseBoundary);
    4091         DASSERT(!safe_ExceptionOccurred(env));
    4092
    4093         // convert clause reading string array to java array
    4094         jclass stringCls = JNU_ClassString(env);
    4095         DASSERT(stringCls);
    4096         CHECK_NULL(stringCls);
    4097         clauseReading = env->NewObjectArray(cClause, stringCls, NULL);
    4098         DASSERT(clauseReading);
    4099         CHECK_NULL(clauseReading);
    4100         for (int i=0; i<cClause; i++)   env->SetObjectArrayElement(clauseReading, i, rgClauseReading[i]);
    4101         DASSERT(!safe_ExceptionOccurred(env));
    4102     }
    4103
    4104
    4105     // attrubute value definition in WInputMethod.java must be equal to that in IMM.H
    4106     DASSERT(ATTR_INPUT==sun_awt_windows_WInputMethod_ATTR_INPUT);
    4107     DASSERT(ATTR_TARGET_CONVERTED==sun_awt_windows_WInputMethod_ATTR_TARGET_CONVERTED);
    4108     DASSERT(ATTR_CONVERTED==sun_awt_windows_WInputMethod_ATTR_CONVERTED);
    4109     DASSERT(ATTR_TARGET_NOTCONVERTED==sun_awt_windows_WInputMethod_ATTR_TARGET_NOTCONVERTED);
    4110     DASSERT(ATTR_INPUT_ERROR==sun_awt_windows_WInputMethod_ATTR_INPUT_ERROR);
    4111
    4112     // attribute information
    4113     jintArray attrBoundary = NULL;
    4114     jbyteArray attrValue = NULL;
    4115     if (cAttrBlock && rgAttrBoundary && rgAttrValue) {
    4116         // convert attribute boundary offset array to java array
    4117         attrBoundary = env->NewIntArray(cAttrBlock+1);
    4118         DASSERT(attrBoundary);
    4119         CHECK_NULL(attrBoundary);
    4120         env->SetIntArrayRegion(attrBoundary, 0, cAttrBlock+1, (jint *)rgAttrBoundary);
    4121         DASSERT(!safe_ExceptionOccurred(env));
    4122
    4123         // convert attribute value byte array to java array
    4124         attrValue = env->NewByteArray(cAttrBlock);
    4125         DASSERT(attrValue);
    4126         CHECK_NULL(attrValue);
    4127         env->SetByteArrayRegion(attrValue, 0, cAttrBlock, (jbyte *)rgAttrValue);
    4128         DASSERT(!safe_ExceptionOccurred(env));
    4129     }
    4130
    4131
    4132     // get global reference of WInputMethod class (run only once)
    4133     static jclass wInputMethodCls = NULL;
    4134     if (wInputMethodCls == NULL) {
    4135         jclass wInputMethodClsLocal = env->FindClass("sun/awt/windows/WInputMethod");
    4136         DASSERT(wInputMethodClsLocal);
    4137         CHECK_NULL(wInputMethodClsLocal);
    4138         wInputMethodCls = (jclass)env->NewGlobalRef(wInputMethodClsLocal);
    4139         env->DeleteLocalRef(wInputMethodClsLocal);
    4140     }
    4141
    4142     // get method ID of sendInputMethodEvent() (run only once)
    4143     static jmethodID sendIMEventMid = 0;
    4144     if (sendIMEventMid == 0) {
    4145         sendIMEventMid =  env->GetMethodID(wInputMethodCls, "sendInputMethodEvent",
    4146                                            "(IJLjava/lang/String;[I[Ljava/lang/String;[I[BIII)V");
    4147         DASSERT(sendIMEventMid);
    4148         CHECK_NULL(sendIMEventMid);
    4149     }
    4150
    4151     // call m_InputMethod.sendInputMethod()
    4152     env->CallVoidMethod(m_InputMethod, sendIMEventMid, id, ::JVM_CurrentTimeMillis(NULL, 0),
    4153                         text, clauseBoundary, clauseReading, attrBoundary,
    4154                         attrValue, commitedTextLength, caretPos, visiblePos);
    4155     if (safe_ExceptionOccurred(env))   env->ExceptionDescribe();
    4156     DASSERT(!safe_ExceptionOccurred(env));
    4157
    4158 }
    4159
    4160
    4161
    4162 //
    4163 // Inquires candidate position according to the composed text
    4164 //
    4165 void AwtComponent::InquireCandidatePosition()
    4166 {
    4167     if (!::IsWindowVisible(GetHWnd())) {
    4168         return;
    4169     }
    4170     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4171
    4172     // get global reference of WInputMethod class (run only once)
    4173     static jclass wInputMethodCls = NULL;
    4174     if (wInputMethodCls == NULL) {
    4175         jclass wInputMethodClsLocal = env->FindClass("sun/awt/windows/WInputMethod");
    4176         DASSERT(wInputMethodClsLocal);
    4177         CHECK_NULL(wInputMethodClsLocal);
    4178         wInputMethodCls = (jclass)env->NewGlobalRef(wInputMethodClsLocal);
    4179         env->DeleteLocalRef(wInputMethodClsLocal);
    4180     }
    4181
    4182     // get method ID of sendInputMethodEvent() (run only once)
    4183     static jmethodID inqCandPosMid = 0;
    4184     if (inqCandPosMid == 0) {
    4185         inqCandPosMid =  env->GetMethodID(wInputMethodCls, "inquireCandidatePosition", "()V");
    4186         DASSERT(!safe_ExceptionOccurred(env));
    4187         DASSERT(inqCandPosMid);
    4188         CHECK_NULL(inqCandPosMid);
    4189     }
    4190
    4191     // call m_InputMethod.sendInputMethod()
    4192     jobject candPos = env->CallObjectMethod(m_InputMethod, inqCandPosMid);
    4193     DASSERT(!safe_ExceptionOccurred(env));
    4194 }
    4195
    4196 HWND AwtComponent::ImmGetHWnd()
    4197 {
    4198     HWND proxy = GetProxyFocusOwner();
    4199     return (proxy != NULL) ? proxy : GetHWnd();
    4200 }
    4201
    4202 HIMC AwtComponent::ImmAssociateContext(HIMC himc)
    4203 {
    4204     return ::ImmAssociateContext(ImmGetHWnd(), himc);
    4205 }
    4206
    4207 HWND AwtComponent::GetProxyFocusOwner()
    4208 {
    4209     AwtWindow *window = GetContainer();
    4210     if (window != 0) {
    4211         AwtFrame *owner = window->GetOwningFrameOrDialog();
    4212         if (owner != 0) {
    4213             return owner->GetProxyFocusOwner();
    4214         } else if (!window->IsSimpleWindow()) { // isn't an owned simple window
    4215             return ((AwtFrame*)window)->GetProxyFocusOwner();
    4216         }
    4217     }
    4218     return (HWND)NULL;
    4219 }
    4220
    4221 /* Redirects message to the focus proxy, if any */
    4222 void AwtComponent::CallProxyDefWindowProc(UINT message, WPARAM wParam,
    4223     LPARAM lParam, LRESULT &retVal, MsgRouting &mr)
    4224 {
    4225     if (mr != mrConsume)  {
    4226         HWND proxy = GetProxyFocusOwner();
    4227         if (proxy != NULL && ::IsWindowEnabled(proxy)) {
    4228             retVal = ::DefWindowProc(proxy, message, wParam, lParam);
    4229             mr = mrConsume;
    4230         }
    4231     }
    4232 }
    4233
    4234 MsgRouting AwtComponent::WmCommand(UINT id, HWND hWndChild, UINT notifyCode)
    4235 {
    4236     /* Menu/Accelerator */
    4237     if (hWndChild == 0) {
    4238         AwtObject* obj = AwtToolkit::GetInstance().LookupCmdID(id);
    4239         if (obj == NULL) {
    4240             return mrConsume;
    4241         }
    4242         DASSERT(((AwtMenuItem*)obj)->GetID() == id);
    4243         obj->DoCommand();
    4244         return mrConsume;
    4245     }
    4246     /* Child id notification */
    4247     else {
    4248         AwtComponent* child = AwtComponent::GetComponent(hWndChild);
    4249         if (child) {
    4250             child->WmNotify(notifyCode);
    4251         }
    4252     }
    4253     return mrDoDefault;
    4254 }
    4255
    4256 MsgRouting AwtComponent::WmNotify(UINT notifyCode)
    4257 {
    4258     return mrDoDefault;
    4259 }
    4260
    4261 MsgRouting AwtComponent::WmCompareItem(UINT ctrlId,
    4262                                        COMPAREITEMSTRUCT &compareInfo,
    4263                                        LRESULT &result)
    4264 {
    4265     AwtComponent* child = AwtComponent::GetComponent(compareInfo.hwndItem);
    4266     if (child == this) {
    4267         /* DoCallback("handleItemDelete", */
    4268     }
    4269     else if (child) {
    4270         return child->WmCompareItem(ctrlId, compareInfo, result);
    4271     }
    4272     return mrConsume;
    4273 }
    4274
    4275 MsgRouting AwtComponent::WmDeleteItem(UINT ctrlId,
    4276                                       DELETEITEMSTRUCT &deleteInfo)
    4277 {
    4278     /*
    4279      * Workaround for NT 4.0 bug -- if SetWindowPos is called on a AwtList
    4280      * window, a WM_DELETEITEM message is sent to its parent with a window
    4281      * handle of one of the list's child windows.  The property lookup
    4282      * succeeds, but the HWNDs don't match.
    4283      */
    4284     if (deleteInfo.hwndItem == NULL) {
    4285         return mrConsume;
    4286     }
    4287     AwtComponent* child = (AwtComponent *)AwtComponent::GetComponent(deleteInfo.hwndItem);
    4288
    4289     if (child && child->GetHWnd() != deleteInfo.hwndItem) {
    4290         return mrConsume;
    4291     }
    4292
    4293     if (child == this) {
    4294         /*DoCallback("handleItemDelete", */
    4295     }
    4296     else if (child) {
    4297         return child->WmDeleteItem(ctrlId, deleteInfo);
    4298     }
    4299     return mrConsume;
    4300 }
    4301
    4302 MsgRouting AwtComponent::WmDrawItem(UINT ctrlId, DRAWITEMSTRUCT &drawInfo)
    4303 {
    4304     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4305
    4306     if (drawInfo.CtlType == ODT_MENU) {
    4307         if (IsMenu((HMENU)drawInfo.hwndItem) && drawInfo.itemData != 0) {
    4308             AwtMenu* menu = (AwtMenu*)(drawInfo.itemData);
    4309             menu->DrawItem(drawInfo);
    4310         }
    4311     } else {
    4312         return OwnerDrawItem(ctrlId, drawInfo);
    4313     }
    4314     return mrConsume;
    4315 }
    4316
    4317 MsgRouting AwtComponent::WmMeasureItem(UINT ctrlId,
    4318                                        MEASUREITEMSTRUCT &measureInfo)
    4319 {
    4320     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4321
    4322     if (measureInfo.CtlType == ODT_MENU) {
    4323         if (measureInfo.itemData != 0) {
    4324             AwtMenu* menu = (AwtMenu*)(measureInfo.itemData);
    4325             HDC hDC = ::GetDC(GetHWnd());
    4326             /* menu->MeasureItem(env, hDC, measureInfo); */
    4327             menu->MeasureItem(hDC, measureInfo);
    4328             ::ReleaseDC(GetHWnd(), hDC);
    4329         }
    4330     } else {
    4331         return OwnerMeasureItem(ctrlId, measureInfo);
    4332     }
    4333     return mrConsume;
    4334 }
    4335
    4336 MsgRouting AwtComponent::OwnerDrawItem(UINT ctrlId,
    4337     DRAWITEMSTRUCT &drawInfo)
    4338 {
    4339     AwtComponent* child = AwtComponent::GetComponent(drawInfo.hwndItem);
    4340     if (child == this) {
    4341         /* DoCallback("handleItemDelete", */
    4342     } else if (child != NULL) {
    4343         return child->WmDrawItem(ctrlId, drawInfo);
    4344     }
    4345     return mrConsume;
    4346 }
    4347
    4348 MsgRouting AwtComponent::OwnerMeasureItem(UINT ctrlId,
    4349     MEASUREITEMSTRUCT &measureInfo)
    4350 {
    4351     HWND  hChild = ::GetDlgItem(GetHWnd(), measureInfo.CtlID);
    4352     AwtComponent* child = AwtComponent::GetComponent(hChild);
    4353     /*
    4354      * If the parent cannot find the child's instance from its handle,
    4355      * maybe the child is in its creation.  So the child must be searched
    4356      * from the list linked before the child's creation.
    4357      */
    4358     if (child == NULL) {
    4359         child = SearchChild((UINT)ctrlId);
    4360     }
    4361
    4362     if (child == this) {
    4363     /* DoCallback("handleItemDelete",  */
    4364     }
    4365     else if (child) {
    4366         return child->WmMeasureItem(ctrlId, measureInfo);
    4367     }
    4368     return mrConsume;
    4369 }
    4370
    4371 /* for WmDrawItem method of Label, Button and Checkbox */
    4372 void AwtComponent::DrawWindowText(HDC hDC, jobject font, jstring text,
    4373                                   int x, int y)
    4374 {
    4375     int nOldBkMode = ::SetBkMode(hDC,TRANSPARENT);
    4376     DASSERT(nOldBkMode != 0);
    4377     AwtFont::drawMFString(hDC, font, text, x, y, GetCodePage());
    4378     VERIFY(::SetBkMode(hDC,nOldBkMode));
    4379 }
    4380
    4381 /*
    4382  * Draw text in gray (the color being set to COLOR_GRAYTEXT) when the
    4383  * component is disabled.  Used only for label, checkbox and button in
    4384  * OWNER_DRAW.  It draws the text in emboss.
    4385  */
    4386 void AwtComponent::DrawGrayText(HDC hDC, jobject font, jstring text,
    4387                                 int x, int y)
    4388 {
    4389     ::SetTextColor(hDC, ::GetSysColor(COLOR_BTNHILIGHT));
    4390     AwtComponent::DrawWindowText(hDC, font, text, x+1, y+1);
    4391     ::SetTextColor(hDC, ::GetSysColor(COLOR_BTNSHADOW));
    4392     AwtComponent::DrawWindowText(hDC, font, text, x, y);
    4393 }
    4394
    4395 /* for WmMeasureItem method of List and Choice */
    4396 jstring AwtComponent::GetItemString(JNIEnv *env, jobject target, jint index)
    4397 {
    4398     jstring str = (jstring)JNU_CallMethodByName(env, NULL, target, "getItemImpl",
    4399                                                 "(I)Ljava/lang/String;",
    4400                                                 index).l;
    4401     DASSERT(!safe_ExceptionOccurred(env));
    4402     return str;
    4403 }
    4404
    4405 /* for WmMeasureItem method of List and Choice */
    4406 void AwtComponent::MeasureListItem(JNIEnv *env,
    4407                                    MEASUREITEMSTRUCT &measureInfo)
    4408 {
    4409     if (env->EnsureLocalCapacity(1) < 0) {
    4410         return;
    4411     }
    4412     jobject dimension = PreferredItemSize(env);
    4413     DASSERT(dimension);
    4414     measureInfo.itemWidth =
    4415       env->GetIntField(dimension, AwtDimension::widthID);
    4416     measureInfo.itemHeight =
    4417       env->GetIntField(dimension, AwtDimension::heightID);
    4418     env->DeleteLocalRef(dimension);
    4419 }
    4420
    4421 /* for WmDrawItem method of List and Choice */
    4422 void AwtComponent::DrawListItem(JNIEnv *env, DRAWITEMSTRUCT &drawInfo)
    4423 {
    4424     if (env->EnsureLocalCapacity(3) < 0) {
    4425         return;
    4426     }
    4427     jobject peer = GetPeer(env);
    4428     jobject target = env->GetObjectField(peer, AwtObject::targetID);
    4429
    4430     HDC hDC = drawInfo.hDC;
    4431     RECT rect = drawInfo.rcItem;
    4432
    4433     BOOL bEnabled = isEnabled();
    4434     BOOL unfocusableChoice = (drawInfo.itemState & ODS_COMBOBOXEDIT) && !IsFocusable();
    4435     DWORD crBack, crText;
    4436     if (drawInfo.itemState & ODS_SELECTED){
    4437         /* Set background and text colors for selected item */
    4438         crBack = ::GetSysColor (COLOR_HIGHLIGHT);
    4439         crText = ::GetSysColor (COLOR_HIGHLIGHTTEXT);
    4440     } else {
    4441         /* Set background and text colors for unselected item */
    4442         crBack = GetBackgroundColor();
    4443         crText = bEnabled ? GetColor() : ::GetSysColor(COLOR_GRAYTEXT);
    4444     }
    4445     if (unfocusableChoice) {
    4446         //6190728. Shouldn't draw selection field (edit control) of an owner-drawn combo box.
    4447         crBack = GetBackgroundColor();
    4448         crText = bEnabled ? GetColor() : ::GetSysColor(COLOR_GRAYTEXT);
    4449     }
    4450
    4451     /* Fill item rectangle with background color */
    4452     HBRUSH hbrBack = ::CreateSolidBrush (crBack);
    4453     DASSERT(hbrBack);
    4454     /* 6190728. Shouldn't draw any kind of rectangle around selection field
    4455      * (edit control) of an owner-drawn combo box while unfocusable
    4456      */
    4457     if (!unfocusableChoice){
    4458         VERIFY(::FillRect (hDC, &rect, hbrBack));
    4459     }
    4460     VERIFY(::DeleteObject (hbrBack));
    4461
    4462     /* Set current background and text colors */
    4463     ::SetBkColor (hDC, crBack);
    4464     ::SetTextColor (hDC, crText);
    4465
    4466     /*draw string (with left margin of 1 point) */
    4467     if ((int) (drawInfo.itemID) >= 0) {
    4468             jobject font = GET_FONT(target, peer);
    4469             jstring text = GetItemString(env, target, drawInfo.itemID);
    4470             if (env->ExceptionCheck()) {
    4471                 env->DeleteLocalRef(font);
    4472                 env->DeleteLocalRef(target);
    4473                 return;
    4474             }
    4475             SIZE size = AwtFont::getMFStringSize(hDC, font, text);
    4476             AwtFont::drawMFString(hDC, font, text,
    4477                                   (GetRTL()) ? rect.right - size.cx - 1
    4478                                              : rect.left + 1,
    4479                                   (rect.top + rect.bottom - size.cy) / 2,
    4480                                   GetCodePage());
    4481             env->DeleteLocalRef(font);
    4482             env->DeleteLocalRef(text);
    4483     }
    4484     if ((drawInfo.itemState & ODS_FOCUS)  &&
    4485         (drawInfo.itemAction & (ODA_FOCUS | ODA_DRAWENTIRE))) {
    4486       if (!unfocusableChoice){
    4487           if(::DrawFocusRect(hDC, &rect) == 0)
    4488               VERIFY(::GetLastError() == 0);
    4489       }
    4490     }
    4491     env->DeleteLocalRef(target);
    4492 }
    4493
    4494 /* for MeasureListItem method and WmDrawItem method of Checkbox */
    4495 jint AwtComponent::GetFontHeight(JNIEnv *env)
    4496 {
    4497     if (env->EnsureLocalCapacity(4) < 0) {
    4498         return NULL;
    4499     }
    4500     jobject self = GetPeer(env);
    4501     jobject target = env->GetObjectField(self, AwtObject::targetID);
    4502
    4503     jobject font = GET_FONT(target, self);
    4504     jobject toolkit = env->CallObjectMethod(target,
    4505                                             AwtComponent::getToolkitMID);
    4506
    4507     DASSERT(!safe_ExceptionOccurred(env));
    4508
    4509     jobject fontMetrics =
    4510         env->CallObjectMethod(toolkit, AwtToolkit::getFontMetricsMID, font);
    4511
    4512     DASSERT(!safe_ExceptionOccurred(env));
    4513
    4514     jint height = env->CallIntMethod(fontMetrics, AwtFont::getHeightMID);
    4515     DASSERT(!safe_ExceptionOccurred(env));
    4516
    4517     env->DeleteLocalRef(target);
    4518     env->DeleteLocalRef(font);
    4519     env->DeleteLocalRef(toolkit);
    4520     env->DeleteLocalRef(fontMetrics);
    4521
    4522     return height;
    4523 }
    4524
    4525 // If you override WmPrint, make sure to save a copy of the DC on the GDI
    4526 // stack to be restored in WmPrintClient. Windows mangles the DC in
    4527 // ::DefWindowProc.
    4528 MsgRouting AwtComponent::WmPrint(HDC hDC, LPARAM flags)
    4529 {
    4530     /*
    4531      * DefWindowProc for WM_PRINT changes DC parameters, so we have
    4532      * to restore it ourselves. Otherwise it will cause problems
    4533      * when several components are printed to the same DC.
    4534      */
    4535     int nOriginalDC = ::SaveDC(hDC);
    4536     DASSERT(nOriginalDC != 0);
    4537
    4538     if (flags & PRF_NONCLIENT) {
    4539
    4540         VERIFY(::SaveDC(hDC));
    4541
    4542         DefWindowProc(WM_PRINT, (WPARAM)hDC,
    4543                       (flags & (PRF_NONCLIENT
    4544                                 | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
    4545
    4546         VERIFY(::RestoreDC(hDC, -1));
    4547
    4548         // Special case for components with a sunken border. Windows does not
    4549         // print the border correctly on PCL printers, so we have to do it ourselves.
    4550         if (GetStyleEx() & WS_EX_CLIENTEDGE) {
    4551             RECT r;
    4552             VERIFY(::GetWindowRect(GetHWnd(), &r));
    4553             VERIFY(::OffsetRect(&r, -r.left, -r.top));
    4554             VERIFY(::DrawEdge(hDC, &r, EDGE_SUNKEN, BF_RECT));
    4555         }
    4556     }
    4557
    4558     if (flags & PRF_CLIENT) {
    4559
    4560         /*
    4561          * Special case for components with a sunken border.
    4562          * Windows prints a client area without offset to a border width.
    4563          * We will first print the non-client area with the original offset,
    4564          * then the client area with a corrected offset.
    4565          */
    4566         if (GetStyleEx() & WS_EX_CLIENTEDGE) {
    4567
    4568             int nEdgeWidth = ::GetSystemMetrics(SM_CXEDGE);
    4569             int nEdgeHeight = ::GetSystemMetrics(SM_CYEDGE);
    4570
    4571             VERIFY(::OffsetWindowOrgEx(hDC, -nEdgeWidth, -nEdgeHeight, NULL));
    4572
    4573             // Save a copy of the DC for WmPrintClient
    4574             VERIFY(::SaveDC(hDC));
    4575
    4576             DefWindowProc(WM_PRINT, (WPARAM) hDC,
    4577                           (flags & (PRF_CLIENT
    4578                                     | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
    4579
    4580             VERIFY(::OffsetWindowOrgEx(hDC, nEdgeWidth, nEdgeHeight, NULL));
    4581
    4582         } else {
    4583
    4584             // Save a copy of the DC for WmPrintClient
    4585             VERIFY(::SaveDC(hDC));
    4586             DefWindowProc(WM_PRINT, (WPARAM) hDC,
    4587                           (flags & (PRF_CLIENT
    4588                                     | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
    4589         }
    4590     }
    4591
    4592     if (flags & (PRF_CHILDREN | PRF_OWNED)) {
    4593         DefWindowProc(WM_PRINT, (WPARAM) hDC,
    4594                       (flags & ~PRF_CLIENT & ~PRF_NONCLIENT));
    4595     }
    4596
    4597     VERIFY(::RestoreDC(hDC, nOriginalDC));
    4598
    4599     return mrConsume;
    4600 }
    4601
    4602 // If you override WmPrintClient, make sure to obtain a valid copy of
    4603 // the DC from the GDI stack. The copy of the DC should have been placed
    4604 // there by WmPrint. Windows mangles the DC in ::DefWindowProc.
    4605 MsgRouting AwtComponent::WmPrintClient(HDC hDC, LPARAM)
    4606 {
    4607     // obtain valid DC from GDI stack
    4608     ::RestoreDC(hDC, -1);
    4609
    4610     return mrDoDefault;
    4611 }
    4612
    4613 MsgRouting AwtComponent::WmNcCalcSize(BOOL fCalcValidRects,
    4614                                       LPNCCALCSIZE_PARAMS lpncsp,
    4615                                       LRESULT &retVal)
    4616 {
    4617     return mrDoDefault;
    4618 }
    4619
    4620 MsgRouting AwtComponent::WmNcPaint(HRGN hrgn)
    4621 {
    4622     return mrDoDefault;
    4623 }
    4624
    4625 MsgRouting AwtComponent::WmNcHitTest(UINT x, UINT y, LRESULT &retVal)
    4626 {
    4627     return mrDoDefault;
    4628 }
    4629
    4630 /**
    4631  * WmQueryNewPalette is called whenever our component is coming to
    4632  * the foreground; this gives us an opportunity to install our
    4633  * custom palette.  If this install actually changes entries in
    4634  * the system palette, then we get a further call to WmPaletteChanged
    4635  * (but note that we only need to realize our palette once).
    4636  */
    4637 MsgRouting AwtComponent::WmQueryNewPalette(LRESULT &retVal)
    4638 {
    4639     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
    4640     m_QueryNewPaletteCalled = TRUE;
    4641     HDC hDC = ::GetDC(GetHWnd());
    4642     DASSERT(hDC);
    4643     AwtWin32GraphicsDevice::SelectPalette(hDC, screen);
    4644     AwtWin32GraphicsDevice::RealizePalette(hDC, screen);
    4645     ::ReleaseDC(GetHWnd(), hDC);
    4646     // We must realize the palettes of all of our DC's
    4647     // There is sometimes a problem where the realization of
    4648     // our temporary hDC here does not actually do what
    4649     // we want.  Not clear why, but presumably fallout from
    4650     // our use of several simultaneous hDC's.
    4651     activeDCList.RealizePalettes(screen);
    4652     // Do not invalidate here; if the palette
    4653     // has not changed we will get an extra repaint
    4654     retVal = TRUE;
    4655
    4656     return mrDoDefault;
    4657 }
    4658
    4659 /**
    4660  * We should not need to track this event since we handle our
    4661  * palette management effectively in the WmQueryNewPalette and
    4662  * WmPaletteChanged methods.  However, there seems to be a bug
    4663  * on some win32 systems (e.g., NT4) whereby the palette
    4664  * immediately after a displayChange is not yet updated to its
    4665  * final post-display-change values (hence we adjust our palette
    4666  * using the wrong system palette entries), then the palette is
    4667  * updated, but a WM_PALETTECHANGED message is never sent.
    4668  * By tracking the ISCHANGING message as well (and by tracking
    4669  * displayChange events in the AwtToolkit object), we can account
    4670  * for this error by forcing our WmPaletteChanged method to be
    4671  * called and thereby realizing our logical palette and updating
    4672  * our dynamic colorModel object.
    4673  */
    4674 MsgRouting AwtComponent::WmPaletteIsChanging(HWND hwndPalChg)
    4675 {
    4676     if (AwtToolkit::GetInstance().HasDisplayChanged()) {
    4677         WmPaletteChanged(hwndPalChg);
    4678         AwtToolkit::GetInstance().ResetDisplayChanged();
    4679     }
    4680     return mrDoDefault;
    4681 }
    4682
    4683 MsgRouting AwtComponent::WmPaletteChanged(HWND hwndPalChg)
    4684 {
    4685     // We need to re-realize our palette here (unless we're the one
    4686     // that was realizing it in the first place).  That will let us match the
    4687     // remaining colors in the system palette as best we can.  We always
    4688     // invalidate because the palette will have changed when we receive this
    4689     // message.
    4690
    4691     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
    4692     if (hwndPalChg != GetHWnd()) {
    4693         HDC hDC = ::GetDC(GetHWnd());
    4694         DASSERT(hDC);
    4695         AwtWin32GraphicsDevice::SelectPalette(hDC, screen);
    4696         AwtWin32GraphicsDevice::RealizePalette(hDC, screen);
    4697         ::ReleaseDC(GetHWnd(), hDC);
    4698         // We must realize the palettes of all of our DC's
    4699         activeDCList.RealizePalettes(screen);
    4700     }
    4701     if (AwtWin32GraphicsDevice::UpdateSystemPalette(screen)) {
    4702         AwtWin32GraphicsDevice::UpdateDynamicColorModel(screen);
    4703     }
    4704     Invalidate(NULL);
    4705     return mrDoDefault;
    4706 }
    4707
    4708 MsgRouting AwtComponent::WmStyleChanged(int wStyleType, LPSTYLESTRUCT lpss)
    4709 {
    4710     DASSERT(!IsBadReadPtr(lpss, sizeof(STYLESTRUCT)));
    4711     return mrDoDefault;
    4712 }
    4713
    4714 MsgRouting AwtComponent::WmSettingChange(UINT wFlag, LPCTSTR pszSection)
    4715 {
    4716     DASSERT(!IsBadStringPtr(pszSection, 20));
    4717     DTRACE_PRINTLN2("WM_SETTINGCHANGE: wFlag=%d pszSection=%s", (int)wFlag, pszSection);
    4718     return mrDoDefault;
    4719 }
    4720
    4721 HDC AwtComponent::GetDCFromComponent()
    4722 {
    4723     GetDCReturnStruct *hdcStruct =
    4724         (GetDCReturnStruct*)SendMessage(WM_AWT_GETDC);
    4725     HDC hdc;
    4726     if (hdcStruct) {
    4727         if (hdcStruct->gdiLimitReached) {
    4728             if (jvm != NULL) {
    4729                 JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4730                 if (env != NULL && !safe_ExceptionOccurred(env)) {
    4731                     JNU_ThrowByName(env, "java/awt/AWTError",
    4732                         "HDC creation failure - " \
    4733                         "exceeded maximum GDI resources");
    4734                 }
    4735             }
    4736         }
    4737         hdc = hdcStruct->hDC;
    4738         delete hdcStruct;
    4739     } else {
    4740         hdc = NULL;
    4741     }
    4742     return hdc;
    4743 }
    4744
    4745 void AwtComponent::FillBackground(HDC hMemoryDC, SIZE &size)
    4746 {
    4747     RECT eraseR = { 0, 0, size.cx, size.cy };
    4748     VERIFY(::FillRect(hMemoryDC, &eraseR, GetBackgroundBrush()));
    4749 }
    4750
    4751 void AwtComponent::FillAlpha(void *bitmapBits, SIZE &size, BYTE alpha)
    4752 {
    4753     if (!bitmapBits) {
    4754         return;
    4755     }
    4756
    4757     DWORD* dest = (DWORD*)bitmapBits;
    4758     //XXX: might be optimized to use one loop (cy*cx -> 0)
    4759     for (int i = 0; i < size.cy; i++ ) {
    4760         for (int j = 0; j < size.cx; j++ ) {
    4761             ((BYTE*)(dest++))[3] = alpha;
    4762         }
    4763     }
    4764 }
    4765
    4766 int AwtComponent::ScaleUpX(int x) {
    4767     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
    4768     Devices::InstanceAccess devices;
    4769     AwtWin32GraphicsDevice* device = devices->GetDevice(screen);
    4770     return device == NULL ? x : device->ScaleUpX(x);
    4771 }
    4772
    4773 int AwtComponent::ScaleUpY(int y) {
    4774     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
    4775     Devices::InstanceAccess devices;
    4776     AwtWin32GraphicsDevice* device = devices->GetDevice(screen);
    4777     return device == NULL ? y : device->ScaleUpY(y);
    4778 }
    4779
    4780 int AwtComponent::ScaleDownX(int x) {
    4781     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
    4782     Devices::InstanceAccess devices;
    4783     AwtWin32GraphicsDevice* device = devices->GetDevice(screen);
    4784     return device == NULL ? x : device->ScaleDownX(x);
    4785 }
    4786
    4787 int AwtComponent::ScaleDownY(int y) {
    4788     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
    4789     Devices::InstanceAccess devices;
    4790     AwtWin32GraphicsDevice* device = devices->GetDevice(screen);
    4791     return device == NULL ? y : device->ScaleDownY(y);
    4792 }
    4793
    4794 jintArray AwtComponent::CreatePrintedPixels(SIZE &loc, SIZE &size, int alpha) {
    4795     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4796
    4797     if (!::IsWindowVisible(GetHWnd())) {
    4798         return NULL;
    4799     }
    4800
    4801     HDC hdc = GetDCFromComponent();
    4802     if (!hdc) {
    4803         return NULL;
    4804     }
    4805     HDC hMemoryDC = ::CreateCompatibleDC(hdc);
    4806     void *bitmapBits = NULL;
    4807     HBITMAP hBitmap = BitmapUtil::CreateARGBBitmap(size.cx, size.cy, &bitmapBits);
    4808     HBITMAP hOldBitmap = (HBITMAP)::SelectObject(hMemoryDC, hBitmap);
    4809     SendMessage(WM_AWT_RELEASEDC, (WPARAM)hdc);
    4810
    4811     FillBackground(hMemoryDC, size);
    4812
    4813     VERIFY(::SetWindowOrgEx(hMemoryDC, loc.cx, loc.cy, NULL));
    4814
    4815     // Don't bother with PRF_CHECKVISIBLE because we called IsWindowVisible
    4816     // above.
    4817     SendMessage(WM_PRINT, (WPARAM)hMemoryDC, PRF_CLIENT | PRF_NONCLIENT);
    4818
    4819     // First make sure the system completed any drawing to the bitmap.
    4820     ::GdiFlush();
    4821
    4822     // WM_PRINT does not fill the alpha-channel of the ARGB bitmap
    4823     // leaving it equal to zero. Hence we need to fill it manually. Otherwise
    4824     // the pixels will be considered transparent when interpreting the data.
    4825     FillAlpha(bitmapBits, size, alpha);
    4826
    4827     ::SelectObject(hMemoryDC, hOldBitmap);
    4828
    4829     BITMAPINFO bmi;
    4830     memset(&bmi, 0, sizeof(BITMAPINFO));
    4831     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    4832     bmi.bmiHeader.biWidth = size.cx;
    4833     bmi.bmiHeader.biHeight = -size.cy;
    4834     bmi.bmiHeader.biPlanes = 1;
    4835     bmi.bmiHeader.biBitCount = 32;
    4836     bmi.bmiHeader.biCompression = BI_RGB;
    4837
    4838     jobject localPixelArray = env->NewIntArray(size.cx * size.cy);
    4839     jintArray pixelArray = NULL;
    4840     if (localPixelArray != NULL) {
    4841         pixelArray = (jintArray)env->NewGlobalRef(localPixelArray);
    4842         env->DeleteLocalRef(localPixelArray); localPixelArray = NULL;
    4843
    4844         jboolean isCopy;
    4845         jint *pixels = env->GetIntArrayElements(pixelArray, &isCopy);
    4846
    4847         ::GetDIBits(hMemoryDC, hBitmap, 0, size.cy, (LPVOID)pixels, &bmi,
    4848                     DIB_RGB_COLORS);
    4849
    4850         env->ReleaseIntArrayElements(pixelArray, pixels, 0);
    4851     }
    4852
    4853     VERIFY(::DeleteObject(hBitmap));
    4854     VERIFY(::DeleteDC(hMemoryDC));
    4855
    4856     return pixelArray;
    4857 }
    4858
    4859 void* AwtComponent::SetNativeFocusOwner(void *self) {
    4860     if (self == NULL) {
    4861         // It means that the KFM wants to set focus to null
    4862         sm_focusOwner = NULL;
    4863         return NULL;
    4864     }
    4865
    4866     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4867
    4868     AwtComponent *c = NULL;
    4869     jobject peer = (jobject)self;
    4870
    4871     PDATA pData;
    4872     JNI_CHECK_NULL_GOTO(peer, "peer", ret);
    4873     pData = JNI_GET_PDATA(peer);
    4874     if (pData == NULL) {
    4875         goto ret;
    4876     }
    4877     c = (AwtComponent *)pData;
    4878
    4879 ret:
    4880     if (c && ::IsWindow(c->GetHWnd())) {
    4881         sm_focusOwner = c->GetHWnd();
    4882     } else {
    4883         sm_focusOwner = NULL;
    4884     }
    4885     env->DeleteGlobalRef(peer);
    4886     return NULL;
    4887 }
    4888
    4889 void* AwtComponent::GetNativeFocusedWindow() {
    4890     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4891     AwtComponent *comp =
    4892         AwtComponent::GetComponent(AwtComponent::GetFocusedWindow());
    4893     return (comp != NULL) ? comp->GetTargetAsGlobalRef(env) : NULL;
    4894 }
    4895
    4896 void* AwtComponent::GetNativeFocusOwner() {
    4897     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4898     AwtComponent *comp =
    4899         AwtComponent::GetComponent(AwtComponent::sm_focusOwner);
    4900     return (comp != NULL) ? comp->GetTargetAsGlobalRef(env) : NULL;
    4901 }
    4902
    4903 AwtComponent* AwtComponent::SearchChild(UINT id) {
    4904     ChildListItem* child;
    4905     for (child = m_childList; child != NULL;child = child->m_next) {
    4906         if (child->m_ID == id)
    4907             return child->m_Component;
    4908     }
    4909     /*
    4910      * DASSERT(FALSE);
    4911      * This should not be happend if all children are recorded
    4912      */
    4913     return NULL;        /* make compiler happy */
    4914 }
    4915
    4916 void AwtComponent::RemoveChild(UINT id) {
    4917     ChildListItem* child = m_childList;
    4918     ChildListItem* lastChild = NULL;
    4919     while (child != NULL) {
    4920         if (child->m_ID == id) {
    4921             if (lastChild == NULL) {
    4922                 m_childList = child->m_next;
    4923             } else {
    4924                 lastChild->m_next = child->m_next;
    4925             }
    4926             child->m_next = NULL;
    4927             DASSERT(child != NULL);
    4928             delete child;
    4929             return;
    4930         }
    4931         lastChild = child;
    4932         child = child->m_next;
    4933     }
    4934 }
    4935
    4936 void AwtComponent::SendKeyEvent(jint id, jlong when, jint raw, jint cooked,
    4937                                 jint modifiers, jint keyLocation, jlong nativeCode, MSG *pMsg)
    4938 {
    4939     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    4940     CriticalSection::Lock l(GetLock());
    4941     if (GetPeer(env) == NULL) {
    4942         /* event received during termination. */
    4943         return;
    4944     }
    4945
    4946     static jclass keyEventCls;
    4947     if (keyEventCls == NULL) {
    4948         jclass keyEventClsLocal = env->FindClass("java/awt/event/KeyEvent");
    4949         DASSERT(keyEventClsLocal);
    4950         if (keyEventClsLocal == NULL) {
    4951             /* exception already thrown */
    4952             return;
    4953         }
    4954         keyEventCls = (jclass)env->NewGlobalRef(keyEventClsLocal);
    4955         env->DeleteLocalRef(keyEventClsLocal);
    4956     }
    4957
    4958     static jmethodID keyEventConst;
    4959     if (keyEventConst == NULL) {
    4960         keyEventConst =  env->GetMethodID(keyEventCls, "<init>",
    4961                                           "(Ljava/awt/Component;IJIICI)V");
    4962         DASSERT(keyEventConst);
    4963         CHECK_NULL(keyEventConst);
    4964     }
    4965     if (env->EnsureLocalCapacity(2) < 0) {
    4966         return;
    4967     }
    4968     jobject target = GetTarget(env);
    4969     jobject keyEvent = env->NewObject(keyEventCls, keyEventConst, target,
    4970                                       id, when, modifiers, raw, cooked,
    4971                                       keyLocation);
    4972     if (safe_ExceptionOccurred(env)) env->ExceptionDescribe();
    4973     DASSERT(!safe_ExceptionOccurred(env));
    4974     DASSERT(keyEvent != NULL);
    4975     if (keyEvent == NULL) {
    4976         env->DeleteLocalRef(target);
    4977         return;
    4978     }
    4979     env->SetLongField(keyEvent, AwtKeyEvent::rawCodeID, nativeCode);
    4980     if( nativeCode && nativeCode < 256 ) {
    4981         env->SetLongField(keyEvent, AwtKeyEvent::primaryLevelUnicodeID, (jlong)(dynPrimaryKeymap[nativeCode].unicode));
    4982         env->SetLongField(keyEvent, AwtKeyEvent::extendedKeyCodeID, (jlong)(dynPrimaryKeymap[nativeCode].jkey));
    4983         if( nativeCode < 255 ) {
    4984             env->SetLongField(keyEvent, AwtKeyEvent::scancodeID, (jlong)(dynPrimaryKeymap[nativeCode].scancode));
    4985         }else if( pMsg != NULL ) {
    4986             // unknown key with virtual keycode 0xFF.
    4987             // Its scancode is not in the table, pickup it from the message.
    4988             env->SetLongField(keyEvent, AwtKeyEvent::scancodeID, (jlong)(HIWORD(pMsg->lParam) & 0xFF));
    4989         }
    4990     }
    4991     if (pMsg != NULL) {
    4992         AwtAWTEvent::saveMSG(env, pMsg, keyEvent);
    4993     }
    4994     SendEvent(keyEvent);
    4995
    4996     env->DeleteLocalRef(keyEvent);
    4997     env->DeleteLocalRef(target);
    4998 }
    4999
    5000 void
    5001 AwtComponent::SendKeyEventToFocusOwner(jint id, jlong when,
    5002                                        jint raw, jint cooked,
    5003                                        jint modifiers, jint keyLocation,
    5004                                        jlong nativeCode,
    5005                                        MSG *msg)
    5006 {
    5007     /*
    5008      * if focus owner is null, but focused window isn't
    5009      * we will send key event to focused window
    5010      */
    5011     HWND hwndTarget = ((sm_focusOwner != NULL) ? sm_focusOwner : AwtComponent::GetFocusedWindow());
    5012
    5013     if (hwndTarget == GetHWnd()) {
    5014         SendKeyEvent(id, when, raw, cooked, modifiers, keyLocation, nativeCode, msg);
    5015     } else {
    5016         AwtComponent *target = NULL;
    5017         if (hwndTarget != NULL) {
    5018             target = AwtComponent::GetComponent(hwndTarget);
    5019             if (target == NULL) {
    5020                 target = this;
    5021             }
    5022         }
    5023         if (target != NULL) {
    5024             target->SendKeyEvent(id, when, raw, cooked, modifiers,
    5025               keyLocation, nativeCode, msg);
    5026         }
    5027     }
    5028 }
    5029
    5030 void AwtComponent::SetDragCapture(UINT flags)
    5031 {
    5032     // don't want to interfere with other controls
    5033     if (::GetCapture() == NULL) {
    5034         ::SetCapture(GetHWnd());
    5035     }
    5036 }
    5037
    5038 void AwtComponent::ReleaseDragCapture(UINT flags)
    5039 {
    5040     if ((::GetCapture() == GetHWnd()) && ((flags & ALL_MK_BUTTONS) == 0)) {
    5041         // user has released all buttons, so release the capture
    5042         ::ReleaseCapture();
    5043     }
    5044 }
    5045
    5046 void AwtComponent::SendMouseEvent(jint id, jlong when, jint x, jint y,
    5047                                   jint modifiers, jint clickCount,
    5048                                   jboolean popupTrigger, jint button,
    5049                                   MSG *pMsg, BOOL causedByTouchEvent)
    5050 {
    5051     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5052     CriticalSection::Lock l(GetLock());
    5053     if (GetPeer(env) == NULL) {
    5054         /* event received during termination. */
    5055         return;
    5056     }
    5057
    5058     static jclass mouseEventCls;
    5059     if (mouseEventCls == NULL) {
    5060         jclass mouseEventClsLocal =
    5061             env->FindClass("java/awt/event/MouseEvent");
    5062         CHECK_NULL(mouseEventClsLocal);
    5063         mouseEventCls = (jclass)env->NewGlobalRef(mouseEventClsLocal);
    5064         env->DeleteLocalRef(mouseEventClsLocal);
    5065     }
    5066     RECT insets;
    5067     GetInsets(&insets);
    5068
    5069     static jmethodID mouseEventConst;
    5070     if (mouseEventConst == NULL) {
    5071         mouseEventConst =
    5072             env->GetMethodID(mouseEventCls, "<init>",
    5073                  "(Ljava/awt/Component;IJIIIIIIZI)V");
    5074         DASSERT(mouseEventConst);
    5075         CHECK_NULL(mouseEventConst);
    5076     }
    5077     if (env->EnsureLocalCapacity(2) < 0) {
    5078         return;
    5079     }
    5080     jobject target = GetTarget(env);
    5081     DWORD curMousePos = ::GetMessagePos();
    5082     int xAbs = GET_X_LPARAM(curMousePos);
    5083     int yAbs = GET_Y_LPARAM(curMousePos);
    5084     jobject mouseEvent = env->NewObject(mouseEventCls, mouseEventConst,
    5085                                         target,
    5086                                         id, when, modifiers,
    5087                                         ScaleDownX(x + insets.left),
    5088                                         ScaleDownY(y + insets.top),
    5089                                         ScaleDownX(xAbs), ScaleDownY(yAbs),
    5090                                         clickCount, popupTrigger, button);
    5091
    5092     if (safe_ExceptionOccurred(env)) {
    5093         env->ExceptionDescribe();
    5094         env->ExceptionClear();
    5095     }
    5096
    5097     DASSERT(mouseEvent != NULL);
    5098     CHECK_NULL(mouseEvent);
    5099     if (causedByTouchEvent) {
    5100         env->SetBooleanField(mouseEvent, AwtMouseEvent::causedByTouchEventID,
    5101             JNI_TRUE);
    5102     }
    5103     if (pMsg != 0) {
    5104         AwtAWTEvent::saveMSG(env, pMsg, mouseEvent);
    5105     }
    5106     SendEvent(mouseEvent);
    5107
    5108     env->DeleteLocalRef(mouseEvent);
    5109     env->DeleteLocalRef(target);
    5110 }
    5111
    5112 void
    5113 AwtComponent::SendMouseWheelEvent(jint id, jlong when, jint x, jint y,
    5114                                   jint modifiers, jint clickCount,
    5115                                   jboolean popupTrigger, jint scrollType,
    5116                                   jint scrollAmount, jint roundedWheelRotation,
    5117                                   jdouble preciseWheelRotation, MSG *pMsg)
    5118 {
    5119     /* Code based not so loosely on AwtComponent::SendMouseEvent */
    5120     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5121     CriticalSection::Lock l(GetLock());
    5122     if (GetPeer(env) == NULL) {
    5123         /* event received during termination. */
    5124         return;
    5125     }
    5126
    5127     static jclass mouseWheelEventCls;
    5128     if (mouseWheelEventCls == NULL) {
    5129         jclass mouseWheelEventClsLocal =
    5130             env->FindClass("java/awt/event/MouseWheelEvent");
    5131         CHECK_NULL(mouseWheelEventClsLocal);
    5132         mouseWheelEventCls = (jclass)env->NewGlobalRef(mouseWheelEventClsLocal);
    5133         env->DeleteLocalRef(mouseWheelEventClsLocal);
    5134     }
    5135     RECT insets;
    5136     GetInsets(&insets);
    5137
    5138     static jmethodID mouseWheelEventConst;
    5139     if (mouseWheelEventConst == NULL) {
    5140         mouseWheelEventConst =
    5141             env->GetMethodID(mouseWheelEventCls, "<init>",
    5142                            "(Ljava/awt/Component;IJIIIIIIZIIID)V");
    5143         DASSERT(mouseWheelEventConst);
    5144         CHECK_NULL(mouseWheelEventConst);
    5145     }
    5146     if (env->EnsureLocalCapacity(2) < 0) {
    5147         return;
    5148     }
    5149     jobject target = GetTarget(env);
    5150     DWORD curMousePos = ::GetMessagePos();
    5151     int xAbs = GET_X_LPARAM(curMousePos);
    5152     int yAbs = GET_Y_LPARAM(curMousePos);
    5153
    5154     DTRACE_PRINTLN("creating MWE in JNI");
    5155
    5156     jobject mouseWheelEvent = env->NewObject(mouseWheelEventCls,
    5157                                              mouseWheelEventConst,
    5158                                              target,
    5159                                              id, when, modifiers,
    5160                                              ScaleDownX(x + insets.left),
    5161                                              ScaleDownY(y + insets.top),
    5162                                              ScaleDownX(xAbs),
    5163                                              ScaleDownY(yAbs),
    5164                                              clickCount, popupTrigger,
    5165                                              scrollType, scrollAmount,
    5166                                              roundedWheelRotation, preciseWheelRotation);
    5167
    5168     DASSERT(mouseWheelEvent != NULL);
    5169     if (mouseWheelEvent == NULL || safe_ExceptionOccurred(env)) {
    5170         env->ExceptionDescribe();
    5171         env->ExceptionClear();
    5172         env->DeleteLocalRef(target);
    5173         return;
    5174     }
    5175     if (pMsg != NULL) {
    5176         AwtAWTEvent::saveMSG(env, pMsg, mouseWheelEvent);
    5177     }
    5178     SendEvent(mouseWheelEvent);
    5179
    5180     env->DeleteLocalRef(mouseWheelEvent);
    5181     env->DeleteLocalRef(target);
    5182 }
    5183
    5184 void AwtComponent::SendFocusEvent(jint id, HWND opposite)
    5185 {
    5186     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5187
    5188     CriticalSection::Lock l(GetLock());
    5189     if (GetPeer(env) == NULL) {
    5190         /* event received during termination. */
    5191         return;
    5192     }
    5193
    5194     static jclass focusEventCls;
    5195     if (focusEventCls == NULL) {
    5196         jclass focusEventClsLocal
    5197             = env->FindClass("java/awt/event/FocusEvent");
    5198         DASSERT(focusEventClsLocal);
    5199         CHECK_NULL(focusEventClsLocal);
    5200         focusEventCls = (jclass)env->NewGlobalRef(focusEventClsLocal);
    5201         env->DeleteLocalRef(focusEventClsLocal);
    5202     }
    5203
    5204     static jmethodID focusEventConst;
    5205     if (focusEventConst == NULL) {
    5206         focusEventConst =
    5207             env->GetMethodID(focusEventCls, "<init>",
    5208                              "(Ljava/awt/Component;IZLjava/awt/Component;)V");
    5209         DASSERT(focusEventConst);
    5210         CHECK_NULL(focusEventConst);
    5211     }
    5212
    5213     static jclass sequencedEventCls;
    5214     if (sequencedEventCls == NULL) {
    5215         jclass sequencedEventClsLocal =
    5216             env->FindClass("java/awt/SequencedEvent");
    5217         DASSERT(sequencedEventClsLocal);
    5218         CHECK_NULL(sequencedEventClsLocal);
    5219         sequencedEventCls =
    5220             (jclass)env->NewGlobalRef(sequencedEventClsLocal);
    5221         env->DeleteLocalRef(sequencedEventClsLocal);
    5222     }
    5223
    5224     static jmethodID sequencedEventConst;
    5225     if (sequencedEventConst == NULL) {
    5226         sequencedEventConst =
    5227             env->GetMethodID(sequencedEventCls, "<init>",
    5228                              "(Ljava/awt/AWTEvent;)V");
    5229         DASSERT(sequencedEventConst);
    5230         CHECK_NULL(sequencedEventConst);
    5231     }
    5232
    5233     if (env->EnsureLocalCapacity(3) < 0) {
    5234         return;
    5235     }
    5236
    5237     jobject target = GetTarget(env);
    5238     jobject jOpposite = NULL;
    5239     if (opposite != NULL) {
    5240         AwtComponent *awtOpposite = AwtComponent::GetComponent(opposite);
    5241         if (awtOpposite != NULL) {
    5242             jOpposite = awtOpposite->GetTarget(env);
    5243         }
    5244     }
    5245     jobject focusEvent = env->NewObject(focusEventCls, focusEventConst,
    5246                                         target, id, JNI_FALSE, jOpposite);
    5247     DASSERT(!safe_ExceptionOccurred(env));
    5248     DASSERT(focusEvent != NULL);
    5249     if (jOpposite != NULL) {
    5250         env->DeleteLocalRef(jOpposite); jOpposite = NULL;
    5251     }
    5252     env->DeleteLocalRef(target); target = NULL;
    5253     CHECK_NULL(focusEvent);
    5254
    5255     jobject sequencedEvent = env->NewObject(sequencedEventCls,
    5256                                             sequencedEventConst,
    5257                                             focusEvent);
    5258     DASSERT(!safe_ExceptionOccurred(env));
    5259     DASSERT(sequencedEvent != NULL);
    5260     env->DeleteLocalRef(focusEvent); focusEvent = NULL;
    5261     CHECK_NULL(sequencedEvent);
    5262     SendEvent(sequencedEvent);
    5263
    5264     env->DeleteLocalRef(sequencedEvent);
    5265 }
    5266
    5267 /*
    5268  * Forward a filtered event directly to the subclassed window.
    5269  * This method is needed so that DefWindowProc is invoked on the
    5270  * component's owning thread.
    5271  */
    5272 MsgRouting AwtComponent::HandleEvent(MSG *msg, BOOL)
    5273 {
    5274     DefWindowProc(msg->message, msg->wParam, msg->lParam);
    5275     delete msg;
    5276     return mrConsume;
    5277 }
    5278
    5279 /* Post a WM_AWT_HANDLE_EVENT message which invokes HandleEvent
    5280    on the toolkit thread. This method may pre-filter the messages. */
    5281 BOOL AwtComponent::PostHandleEventMessage(MSG *msg, BOOL synthetic)
    5282 {
    5283     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5284     // We should cut off keyboard events to disabled components
    5285     // to avoid the components responding visually to keystrokes when disabled.
    5286     // we shouldn't cut off WM_SYS* messages as they aren't used for normal activity
    5287     // but to activate menus, close windows, etc
    5288     switch(msg->message) {
    5289         case WM_KEYDOWN:
    5290         case WM_KEYUP:
    5291         case WM_CHAR:
    5292         case WM_DEADCHAR:
    5293             {
    5294                 if (!isRecursivelyEnabled()) {
    5295                     goto quit;
    5296                 }
    5297                 break;
    5298             }
    5299     }
    5300     if (PostMessage(GetHWnd(), WM_AWT_HANDLE_EVENT,
    5301         (WPARAM) synthetic, (LPARAM) msg)) {
    5302             return TRUE;
    5303     } else {
    5304         JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
    5305     }
    5306 quit:
    5307     delete msg;
    5308     return FALSE;
    5309 }
    5310
    5311 void AwtComponent::SynthesizeKeyMessage(JNIEnv *env, jobject keyEvent)
    5312 {
    5313     jint id = (env)->GetIntField(keyEvent, AwtAWTEvent::idID);
    5314     UINT message;
    5315     switch (id) {
    5316       case java_awt_event_KeyEvent_KEY_PRESSED:
    5317           message = WM_KEYDOWN;
    5318           break;
    5319       case java_awt_event_KeyEvent_KEY_RELEASED:
    5320           message = WM_KEYUP;
    5321           break;
    5322       case java_awt_event_KeyEvent_KEY_TYPED:
    5323           message = WM_CHAR;
    5324           break;
    5325       default:
    5326           return;
    5327     }
    5328
    5329     /*
    5330      * KeyEvent.modifiers aren't supported -- the Java apppwd must send separate
    5331      * KEY_PRESSED and KEY_RELEASED events for the modifier virtual keys.
    5332      */
    5333     if (id == java_awt_event_KeyEvent_KEY_TYPED) {
    5334         // WM_CHAR message must be posted using WM_AWT_FORWARD_CHAR
    5335         // (for Edit control)
    5336         jchar keyChar = (jchar)
    5337           (env)->GetCharField(keyEvent, AwtKeyEvent::keyCharID);
    5338
    5339         // Bugid 4724007.  If it is a Delete character, don't send the fake
    5340         // KEY_TYPED we created back to the native window: Windows doesn't
    5341         // expect a WM_CHAR for Delete in TextFields, so it tries to enter a
    5342         // character after deleting.
    5343         if (keyChar == '\177') { // the Delete character
    5344             return;
    5345         }
    5346
    5347         // Disable forwarding WM_CHAR messages to disabled components
    5348         if (isRecursivelyEnabled()) {
    5349             if (!::PostMessage(GetHWnd(), WM_AWT_FORWARD_CHAR,
    5350                 MAKEWPARAM(keyChar, TRUE), 0)) {
    5351                 JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
    5352             }
    5353         }
    5354     } else {
    5355         jint keyCode =
    5356           (env)->GetIntField(keyEvent, AwtKeyEvent::keyCodeID);
    5357         UINT key, modifiers;
    5358         AwtComponent::JavaKeyToWindowsKey(keyCode, &key, &modifiers);
    5359         MSG* msg = CreateMessage(message, key, 0);
    5360         PostHandleEventMessage(msg, TRUE);
    5361     }
    5362 }
    5363
    5364 void AwtComponent::SynthesizeMouseMessage(JNIEnv *env, jobject mouseEvent)
    5365 {
    5366     /*    DebugBreak(); */
    5367     jint button = (env)->GetIntField(mouseEvent, AwtMouseEvent::buttonID);
    5368     jint modifiers = (env)->GetIntField(mouseEvent, AwtInputEvent::modifiersID);
    5369
    5370     WPARAM wParam = 0;
    5371     WORD wLow = 0;
    5372     jint wheelAmt = 0;
    5373     jint id = (env)->GetIntField(mouseEvent, AwtAWTEvent::idID);
    5374     UINT message;
    5375     switch (id) {
    5376       case java_awt_event_MouseEvent_MOUSE_PRESSED: {
    5377           switch (button) {
    5378             case java_awt_event_MouseEvent_BUTTON1:
    5379                 message = WM_LBUTTONDOWN; break;
    5380             case java_awt_event_MouseEvent_BUTTON3:
    5381                 message = WM_MBUTTONDOWN; break;
    5382             case java_awt_event_MouseEvent_BUTTON2:
    5383                 message = WM_RBUTTONDOWN; break;
    5384             default:
    5385                 return;
    5386           }
    5387           break;
    5388       }
    5389       case java_awt_event_MouseEvent_MOUSE_RELEASED: {
    5390           switch (button) {
    5391             case java_awt_event_MouseEvent_BUTTON1:
    5392                 message = WM_LBUTTONUP; break;
    5393             case java_awt_event_MouseEvent_BUTTON3:
    5394                 message = WM_MBUTTONUP; break;
    5395             case java_awt_event_MouseEvent_BUTTON2:
    5396                 message = WM_RBUTTONUP; break;
    5397             default:
    5398                 return;
    5399           }
    5400           break;
    5401       }
    5402       case java_awt_event_MouseEvent_MOUSE_MOVED:
    5403           /* MOUSE_DRAGGED events must first have sent a MOUSE_PRESSED event. */
    5404       case java_awt_event_MouseEvent_MOUSE_DRAGGED:
    5405           message = WM_MOUSEMOVE;
    5406           break;
    5407       case java_awt_event_MouseEvent_MOUSE_WHEEL:
    5408           if (modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK) {
    5409               wLow |= MK_CONTROL;
    5410           }
    5411           if (modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) {
    5412               wLow |= MK_SHIFT;
    5413           }
    5414           if (modifiers & java_awt_event_InputEvent_BUTTON1_DOWN_MASK) {
    5415               wLow |= MK_LBUTTON;
    5416           }
    5417           if (modifiers & java_awt_event_InputEvent_BUTTON2_DOWN_MASK) {
    5418               wLow |= MK_RBUTTON;
    5419           }
    5420           if (modifiers & java_awt_event_InputEvent_BUTTON3_DOWN_MASK) {
    5421               wLow |= MK_MBUTTON;
    5422           }
    5423           if (modifiers & X1_BUTTON) {
    5424               wLow |= GetButtonMK(X1_BUTTON);
    5425           }
    5426           if (modifiers & X2_BUTTON) {
    5427               wLow |= GetButtonMK(X2_BUTTON);
    5428           }
    5429
    5430           wheelAmt = (jint)JNU_CallMethodByName(env,
    5431                                                NULL,
    5432                                                mouseEvent,
    5433                                                "getWheelRotation",
    5434                                                "()I").i;
    5435           DASSERT(!safe_ExceptionOccurred(env));
    5436           JNU_CHECK_EXCEPTION(env);
    5437           DTRACE_PRINTLN1("wheelAmt = %i\n", wheelAmt);
    5438
    5439           // convert Java wheel amount value to Win32
    5440           wheelAmt *= -1 * WHEEL_DELTA;
    5441
    5442           message = WM_MOUSEWHEEL;
    5443           wParam = MAKEWPARAM(wLow, wheelAmt);
    5444
    5445           break;
    5446       default:
    5447           return;
    5448     }
    5449     jint x = (env)->GetIntField(mouseEvent, AwtMouseEvent::xID);
    5450     jint y = (env)->GetIntField(mouseEvent, AwtMouseEvent::yID);
    5451     MSG* msg = CreateMessage(message, wParam, MAKELPARAM(x, y), x, y);
    5452     PostHandleEventMessage(msg, TRUE);
    5453 }
    5454
    5455 BOOL AwtComponent::InheritsNativeMouseWheelBehavior() {return false;}
    5456
    5457 void AwtComponent::Invalidate(RECT* r)
    5458 {
    5459     ::InvalidateRect(GetHWnd(), r, FALSE);
    5460 }
    5461
    5462 void AwtComponent::BeginValidate()
    5463 {
    5464     DASSERT(m_validationNestCount >= 0 &&
    5465            m_validationNestCount < 1000); // sanity check
    5466
    5467     if (m_validationNestCount == 0) {
    5468     // begin deferred window positioning if we're not inside
    5469     // another Begin/EndValidate pair
    5470         DASSERT(m_hdwp == NULL);
    5471         m_hdwp = ::BeginDeferWindowPos(32);
    5472     }
    5473
    5474     m_validationNestCount++;
    5475 }
    5476
    5477 void AwtComponent::EndValidate()
    5478 {
    5479     DASSERT(m_validationNestCount > 0 &&
    5480            m_validationNestCount < 1000); // sanity check
    5481     DASSERT(m_hdwp != NULL);
    5482
    5483     m_validationNestCount--;
    5484     if (m_validationNestCount == 0) {
    5485     // if this call to EndValidate is not nested inside another
    5486     // Begin/EndValidate pair, end deferred window positioning
    5487         ::EndDeferWindowPos(m_hdwp);
    5488         m_hdwp = NULL;
    5489     }
    5490 }
    5491
    5492 /**
    5493  * HWND, AwtComponent and Java Peer interaction
    5494  */
    5495
    5496 /*
    5497  *Link the C++, Java peer, and HWNDs together.
    5498  */
    5499 void AwtComponent::LinkObjects(JNIEnv *env, jobject peer)
    5500 {
    5501     /*
    5502      * Bind all three objects together thru this C++ object, two-way to each:
    5503      *     JavaPeer <-> C++ <-> HWND
    5504      *
    5505      * C++ -> JavaPeer
    5506      */
    5507     if (m_peerObject == NULL) {
    5508         // This may have already been set up by CreateHWnd
    5509         // And we don't want to create two references so we
    5510         // will leave the prior one alone
    5511         m_peerObject = env->NewGlobalRef(peer);
    5512     }
    5513     /* JavaPeer -> HWND */
    5514     env->SetLongField(peer, AwtComponent::hwndID, reinterpret_cast<jlong>(m_hwnd));
    5515
    5516     /* JavaPeer -> C++ */
    5517     JNI_SET_PDATA(peer, this);
    5518
    5519     /* HWND -> C++ */
    5520     SetComponentInHWND();
    5521 }
    5522
    5523 /* Cleanup above linking */
    5524 void AwtComponent::UnlinkObjects()
    5525 {
    5526     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5527     if (m_peerObject) {
    5528         env->SetLongField(m_peerObject, AwtComponent::hwndID, 0);
    5529         JNI_SET_PDATA(m_peerObject, static_cast<PDATA>(NULL));
    5530         JNI_SET_DESTROYED(m_peerObject);
    5531         env->DeleteGlobalRef(m_peerObject);
    5532         m_peerObject = NULL;
    5533     }
    5534 }
    5535
    5536 void AwtComponent::Enable(BOOL bEnable)
    5537 {
    5538     if (bEnable && IsTopLevel()) {
    5539         // we should not enable blocked toplevels
    5540         bEnable = !::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()));
    5541     }
    5542     // Shouldn't trigger native focus change
    5543     // (only the proxy may be the native focus owner).
    5544     ::EnableWindow(GetHWnd(), bEnable);
    5545
    5546     CriticalSection::Lock l(GetLock());
    5547     VerifyState();
    5548 }
    5549
    5550 /*
    5551  * associate an AwtDropTarget with this AwtComponent
    5552  */
    5553
    5554 AwtDropTarget* AwtComponent::CreateDropTarget(JNIEnv* env) {
    5555     m_dropTarget = new AwtDropTarget(env, this);
    5556     m_dropTarget->RegisterTarget(TRUE);
    5557     return m_dropTarget;
    5558 }
    5559
    5560 /*
    5561  * disassociate an AwtDropTarget with this AwtComponent
    5562  */
    5563
    5564 void AwtComponent::DestroyDropTarget() {
    5565     if (m_dropTarget != NULL) {
    5566         m_dropTarget->RegisterTarget(FALSE);
    5567         m_dropTarget->Release();
    5568         m_dropTarget = NULL;
    5569     }
    5570 }
    5571
    5572 BOOL AwtComponent::IsFocusingMouseMessage(MSG *pMsg) {
    5573     return pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_LBUTTONDBLCLK;
    5574 }
    5575
    5576 BOOL AwtComponent::IsFocusingKeyMessage(MSG *pMsg) {
    5577     return pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_SPACE;
    5578 }
    5579
    5580 void AwtComponent::_Show(void *param)
    5581 {
    5582     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5583
    5584     jobject self = (jobject)param;
    5585
    5586     AwtComponent *p;
    5587
    5588     PDATA pData;
    5589     JNI_CHECK_PEER_GOTO(self, ret);
    5590     p = (AwtComponent *)pData;
    5591     if (::IsWindow(p->GetHWnd()))
    5592     {
    5593         p->SendMessage(WM_AWT_COMPONENT_SHOW);
    5594     }
    5595 ret:
    5596     env->DeleteGlobalRef(self);
    5597 }
    5598
    5599 void AwtComponent::_Hide(void *param)
    5600 {
    5601     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5602
    5603     jobject self = (jobject)param;
    5604
    5605     AwtComponent *p;
    5606
    5607     PDATA pData;
    5608     JNI_CHECK_PEER_GOTO(self, ret);
    5609     p = (AwtComponent *)pData;
    5610     if (::IsWindow(p->GetHWnd()))
    5611     {
    5612         p->SendMessage(WM_AWT_COMPONENT_HIDE);
    5613     }
    5614 ret:
    5615     env->DeleteGlobalRef(self);
    5616 }
    5617
    5618 void AwtComponent::_Enable(void *param)
    5619 {
    5620     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5621
    5622     jobject self = (jobject)param;
    5623
    5624     AwtComponent *p;
    5625
    5626     PDATA pData;
    5627     JNI_CHECK_PEER_GOTO(self, ret);
    5628     p = (AwtComponent *)pData;
    5629     if (::IsWindow(p->GetHWnd()))
    5630     {
    5631         p->Enable(TRUE);
    5632     }
    5633 ret:
    5634     env->DeleteGlobalRef(self);
    5635 }
    5636
    5637 void AwtComponent::_Disable(void *param)
    5638 {
    5639     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5640
    5641     jobject self = (jobject)param;
    5642
    5643     AwtComponent *p;
    5644
    5645     PDATA pData;
    5646     JNI_CHECK_PEER_GOTO(self, ret);
    5647     p = (AwtComponent *)pData;
    5648     if (::IsWindow(p->GetHWnd()))
    5649     {
    5650         p->Enable(FALSE);
    5651     }
    5652 ret:
    5653     env->DeleteGlobalRef(self);
    5654 }
    5655
    5656 jobject AwtComponent::_GetLocationOnScreen(void *param)
    5657 {
    5658     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5659
    5660     jobject self = (jobject)param;
    5661
    5662     jobject result = NULL;
    5663     AwtComponent *p;
    5664
    5665     PDATA pData;
    5666     JNI_CHECK_PEER_GOTO(self, ret);
    5667     p = (AwtComponent *)pData;
    5668     if (::IsWindow(p->GetHWnd()))
    5669     {
    5670         RECT rect;
    5671         VERIFY(::GetWindowRect(p->GetHWnd(),&rect));
    5672         result = JNU_NewObjectByName(env, "java/awt/Point", "(II)V",
    5673                                      p->ScaleDownX(rect.left),
    5674                                      p->ScaleDownY(rect.top));
    5675     }
    5676 ret:
    5677     env->DeleteGlobalRef(self);
    5678
    5679     if (result != NULL)
    5680     {
    5681         jobject resultGlobalRef = env->NewGlobalRef(result);
    5682         env->DeleteLocalRef(result);
    5683         return resultGlobalRef;
    5684     }
    5685     else
    5686     {
    5687         return NULL;
    5688     }
    5689 }
    5690
    5691 void AwtComponent::_Reshape(void *param)
    5692 {
    5693     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5694
    5695     ReshapeStruct *rs = (ReshapeStruct*)param;
    5696     jobject self = rs->component;
    5697     jint x = rs->x;
    5698     jint y = rs->y;
    5699     jint w = rs->w;
    5700     jint h = rs->h;
    5701
    5702     AwtComponent *p;
    5703
    5704     PDATA pData;
    5705     JNI_CHECK_PEER_GOTO(self, ret);
    5706     p = (AwtComponent *)pData;
    5707     if (::IsWindow(p->GetHWnd()))
    5708     {
    5709         RECT* r = new RECT;
    5710         ::SetRect(r, x, y, x + w, y + h);
    5711         p->SendMessage(WM_AWT_RESHAPE_COMPONENT, CHECK_EMBEDDED, (LPARAM)r);
    5712     }
    5713 ret:
    5714     env->DeleteGlobalRef(self);
    5715
    5716     delete rs;
    5717 }
    5718
    5719 void AwtComponent::_ReshapeNoCheck(void *param)
    5720 {
    5721     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5722
    5723     ReshapeStruct *rs = (ReshapeStruct*)param;
    5724     jobject self = rs->component;
    5725     jint x = rs->x;
    5726     jint y = rs->y;
    5727     jint w = rs->w;
    5728     jint h = rs->h;
    5729
    5730     AwtComponent *p;
    5731
    5732     PDATA pData;
    5733     JNI_CHECK_PEER_GOTO(self, ret);
    5734     p = (AwtComponent *)pData;
    5735     if (::IsWindow(p->GetHWnd()))
    5736     {
    5737         RECT* r = new RECT;
    5738         ::SetRect(r, x, y, x + w, y + h);
    5739         p->SendMessage(WM_AWT_RESHAPE_COMPONENT, DONT_CHECK_EMBEDDED, (LPARAM)r);
    5740     }
    5741 ret:
    5742     env->DeleteGlobalRef(self);
    5743
    5744     delete rs;
    5745 }
    5746
    5747 void AwtComponent::_NativeHandleEvent(void *param)
    5748 {
    5749     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5750
    5751     NativeHandleEventStruct *nhes = (NativeHandleEventStruct *)param;
    5752     jobject self = nhes->component;
    5753     jobject event = nhes->event;
    5754
    5755     AwtComponent *p;
    5756
    5757     PDATA pData;
    5758     JNI_CHECK_NULL_GOTO(self, "peer", ret);
    5759     pData = JNI_GET_PDATA(self);
    5760     if (pData == NULL) {
    5761         env->DeleteGlobalRef(self);
    5762         if (event != NULL) {
    5763             env->DeleteGlobalRef(event);
    5764         }
    5765         delete nhes;
    5766         return;
    5767     }
    5768     JNI_CHECK_NULL_GOTO(event, "null AWTEvent", ret);
    5769
    5770     p = (AwtComponent *)pData;
    5771     if (::IsWindow(p->GetHWnd()))
    5772     {
    5773         if (env->EnsureLocalCapacity(1) < 0) {
    5774             env->DeleteGlobalRef(self);
    5775             env->DeleteGlobalRef(event);
    5776             delete nhes;
    5777             return;
    5778         }
    5779         jbyteArray bdata = (jbyteArray)(env)->GetObjectField(event, AwtAWTEvent::bdataID);
    5780         int id = (env)->GetIntField(event, AwtAWTEvent::idID);
    5781         DASSERT(!safe_ExceptionOccurred(env));
    5782         if (bdata != 0) {
    5783             MSG msg;
    5784             (env)->GetByteArrayRegion(bdata, 0, sizeof(MSG), (jbyte *)&msg);
    5785             (env)->DeleteLocalRef(bdata);
    5786             static BOOL keyDownConsumed = FALSE;
    5787             static BOOL bCharChanged = FALSE;
    5788             static WCHAR modifiedChar;
    5789             WCHAR unicodeChar;
    5790
    5791             /* Remember if a KEY_PRESSED event is consumed, as an old model
    5792              * program won't consume a subsequent KEY_TYPED event.
    5793              */
    5794             jboolean consumed =
    5795                 (env)->GetBooleanField(event, AwtAWTEvent::consumedID);
    5796             DASSERT(!safe_ExceptionOccurred(env));
    5797
    5798             if (consumed) {
    5799                 keyDownConsumed = (id == java_awt_event_KeyEvent_KEY_PRESSED);
    5800                 env->DeleteGlobalRef(self);
    5801                 env->DeleteGlobalRef(event);
    5802                 delete nhes;
    5803                 return;
    5804
    5805             } else if (id == java_awt_event_KeyEvent_KEY_PRESSED) {
    5806                 // Fix for 6637607: reset consuming
    5807                 keyDownConsumed = FALSE;
    5808             }
    5809
    5810             /* Consume a KEY_TYPED event if a KEY_PRESSED had been, to support
    5811              * the old model.
    5812              */
    5813             if ((id == java_awt_event_KeyEvent_KEY_TYPED) && keyDownConsumed) {
    5814                 keyDownConsumed = FALSE;
    5815                 env->DeleteGlobalRef(self);
    5816                 env->DeleteGlobalRef(event);
    5817                 delete nhes;
    5818                 return;
    5819             }
    5820
    5821             /* Modify any event parameters, if necessary. */
    5822             if (self && pData &&
    5823                 id >= java_awt_event_KeyEvent_KEY_FIRST &&
    5824                 id <= java_awt_event_KeyEvent_KEY_LAST) {
    5825
    5826                     AwtComponent* p = (AwtComponent*)pData;
    5827
    5828                     jint keyCode =
    5829                       (env)->GetIntField(event, AwtKeyEvent::keyCodeID);
    5830                     jchar keyChar =
    5831                       (env)->GetCharField(event, AwtKeyEvent::keyCharID);
    5832                     jint modifiers =
    5833                       (env)->GetIntField(event, AwtInputEvent::modifiersID);
    5834
    5835                     DASSERT(!safe_ExceptionOccurred(env));
    5836
    5837                 /* Check to see whether the keyCode or modifiers were changed
    5838                    on the keyPressed event, and tweak the following keyTyped
    5839                    event (if any) accodingly.  */
    5840                 switch (id) {
    5841                 case java_awt_event_KeyEvent_KEY_PRESSED:
    5842                 {
    5843                     UINT winKey = (UINT)msg.wParam;
    5844                     bCharChanged = FALSE;
    5845
    5846                     if (winKey == VK_PROCESSKEY) {
    5847                         // Leave it up to IME
    5848                         break;
    5849                     }
    5850
    5851                     if (keyCode != java_awt_event_KeyEvent_VK_UNDEFINED) {
    5852                         UINT newWinKey, ignored;
    5853                         p->JavaKeyToWindowsKey(keyCode, &newWinKey, &ignored, winKey);
    5854                         if (newWinKey != 0) {
    5855                             winKey = newWinKey;
    5856                         }
    5857                     }
    5858
    5859                     BOOL isDeadKey = FALSE;
    5860                     modifiedChar = p->WindowsKeyToJavaChar(winKey, modifiers, AwtComponent::NONE, isDeadKey);
    5861                     bCharChanged = (keyChar != modifiedChar);
    5862                 }
    5863                 break;
    5864
    5865                 case java_awt_event_KeyEvent_KEY_RELEASED:
    5866                 {
    5867                     keyDownConsumed = FALSE;
    5868                     bCharChanged = FALSE;
    5869                 }
    5870                 break;
    5871
    5872                 case java_awt_event_KeyEvent_KEY_TYPED:
    5873                 {
    5874                     if (bCharChanged)
    5875                     {
    5876                         unicodeChar = modifiedChar;
    5877                     }
    5878                     else
    5879                     {
    5880                         unicodeChar = keyChar;
    5881                     }
    5882                     bCharChanged = FALSE;
    5883
    5884                     // Disable forwarding KEY_TYPED messages to peers of
    5885                     // disabled components
    5886                     if (p->isRecursivelyEnabled()) {
    5887                         // send the character back to the native window for
    5888                         // processing. The WM_AWT_FORWARD_CHAR handler will send
    5889                         // this character to DefWindowProc
    5890                         if (!::PostMessage(p->GetHWnd(), WM_AWT_FORWARD_CHAR,
    5891                             MAKEWPARAM(unicodeChar, FALSE), msg.lParam)) {
    5892                             JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
    5893                         }
    5894                     }
    5895                     env->DeleteGlobalRef(self);
    5896                     env->DeleteGlobalRef(event);
    5897                     delete nhes;
    5898                     return;
    5899                 }
    5900                 break;
    5901
    5902                 default:
    5903                     break;
    5904                 }
    5905             }
    5906
    5907             // ignore all InputMethodEvents
    5908             if (self && (pData = JNI_GET_PDATA(self)) &&
    5909                 id >= java_awt_event_InputMethodEvent_INPUT_METHOD_FIRST &&
    5910                 id <= java_awt_event_InputMethodEvent_INPUT_METHOD_LAST) {
    5911                 env->DeleteGlobalRef(self);
    5912                 env->DeleteGlobalRef(event);
    5913                 delete nhes;
    5914                 return;
    5915             }
    5916
    5917             // Create copy for local msg
    5918             MSG* pCopiedMsg = new MSG;
    5919             memmove(pCopiedMsg, &msg, sizeof(MSG));
    5920             // Event handler deletes msg
    5921             p->PostHandleEventMessage(pCopiedMsg, FALSE);
    5922
    5923             env->DeleteGlobalRef(self);
    5924             env->DeleteGlobalRef(event);
    5925             delete nhes;
    5926             return;
    5927         }
    5928
    5929         /* Forward any valid synthesized events.  Currently only mouse and
    5930          * key events are supported.
    5931          */
    5932         if (self == NULL || (pData = JNI_GET_PDATA(self)) == NULL) {
    5933             env->DeleteGlobalRef(self);
    5934             env->DeleteGlobalRef(event);
    5935             delete nhes;
    5936             return;
    5937         }
    5938
    5939         AwtComponent* p = (AwtComponent*)pData;
    5940         if (id >= java_awt_event_KeyEvent_KEY_FIRST &&
    5941             id <= java_awt_event_KeyEvent_KEY_LAST) {
    5942             p->SynthesizeKeyMessage(env, event);
    5943         } else if (id >= java_awt_event_MouseEvent_MOUSE_FIRST &&
    5944                    id <= java_awt_event_MouseEvent_MOUSE_LAST) {
    5945             p->SynthesizeMouseMessage(env, event);
    5946         }
    5947     }
    5948
    5949 ret:
    5950     if (self != NULL) {
    5951         env->DeleteGlobalRef(self);
    5952     }
    5953     if (event != NULL) {
    5954         env->DeleteGlobalRef(event);
    5955     }
    5956
    5957     delete nhes;
    5958 }
    5959
    5960 void AwtComponent::_SetForeground(void *param)
    5961 {
    5962     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5963
    5964     SetColorStruct *scs = (SetColorStruct *)param;
    5965     jobject self = scs->component;
    5966     jint rgb = scs->rgb;
    5967
    5968     AwtComponent *c = NULL;
    5969
    5970     PDATA pData;
    5971     JNI_CHECK_PEER_GOTO(self, ret);
    5972     c = (AwtComponent *)pData;
    5973     if (::IsWindow(c->GetHWnd()))
    5974     {
    5975         c->SetColor(PALETTERGB((rgb>>16)&0xff,
    5976                                (rgb>>8)&0xff,
    5977                                (rgb)&0xff));
    5978         c->VerifyState();
    5979     }
    5980 ret:
    5981     env->DeleteGlobalRef(self);
    5982
    5983     delete scs;
    5984 }
    5985
    5986 void AwtComponent::_SetBackground(void *param)
    5987 {
    5988     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    5989
    5990     SetColorStruct *scs = (SetColorStruct *)param;
    5991     jobject self = scs->component;
    5992     jint rgb = scs->rgb;
    5993
    5994     AwtComponent *c = NULL;
    5995
    5996     PDATA pData;
    5997     JNI_CHECK_PEER_GOTO(self, ret);
    5998     c = (AwtComponent *)pData;
    5999     if (::IsWindow(c->GetHWnd()))
    6000     {
    6001         c->SetBackgroundColor(PALETTERGB((rgb>>16)&0xff,
    6002                                          (rgb>>8)&0xff,
    6003                                          (rgb)&0xff));
    6004         c->VerifyState();
    6005     }
    6006 ret:
    6007     env->DeleteGlobalRef(self);
    6008
    6009     delete scs;
    6010 }
    6011
    6012 void AwtComponent::_SetFont(void *param)
    6013 {
    6014     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6015
    6016     SetFontStruct *sfs = (SetFontStruct *)param;
    6017     jobject self = sfs->component;
    6018     jobject font = sfs->font;
    6019
    6020     AwtComponent *c = NULL;
    6021
    6022     PDATA pData;
    6023     JNI_CHECK_PEER_GOTO(self, ret);
    6024     JNI_CHECK_NULL_GOTO(font, "null font", ret);
    6025     c = (AwtComponent *)pData;
    6026     if (::IsWindow(c->GetHWnd()))
    6027     {
    6028         AwtFont *awtFont = (AwtFont *)env->GetLongField(font, AwtFont::pDataID);
    6029         if (awtFont == NULL) {
    6030             /*arguments of AwtFont::Create are changed for multifont component */
    6031             awtFont = AwtFont::Create(env, font);
    6032         }
    6033         env->SetLongField(font, AwtFont::pDataID, (jlong)awtFont);
    6034
    6035         c->SetFont(awtFont);
    6036     }
    6037 ret:
    6038     env->DeleteGlobalRef(self);
    6039     env->DeleteGlobalRef(font);
    6040
    6041     delete sfs;
    6042 }
    6043
    6044 // Sets or kills focus for a component.
    6045 void AwtComponent::_SetFocus(void *param)
    6046 {
    6047     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6048
    6049     SetFocusStruct *sfs = (SetFocusStruct *)param;
    6050     jobject self = sfs->component;
    6051     jboolean doSetFocus = sfs->doSetFocus;
    6052
    6053     AwtComponent *c = NULL;
    6054
    6055     PDATA pData;
    6056     JNI_CHECK_NULL_GOTO(self, "peer", ret);
    6057     pData = JNI_GET_PDATA(self);
    6058     if (pData == NULL) {
    6059         // do nothing just return false
    6060         goto ret;
    6061     }
    6062
    6063     c = (AwtComponent *)pData;
    6064     if (::IsWindow(c->GetHWnd())) {
    6065         c->SendMessage(WM_AWT_COMPONENT_SETFOCUS, (WPARAM)doSetFocus, 0);
    6066     }
    6067 ret:
    6068     env->DeleteGlobalRef(self);
    6069
    6070     delete sfs;
    6071 }
    6072
    6073 void AwtComponent::_Start(void *param)
    6074 {
    6075     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6076
    6077     jobject self = (jobject)param;
    6078
    6079     AwtComponent *c = NULL;
    6080
    6081     PDATA pData;
    6082     JNI_CHECK_PEER_GOTO(self, ret);
    6083     c = (AwtComponent *)pData;
    6084     if (::IsWindow(c->GetHWnd()))
    6085     {
    6086         jobject target = c->GetTarget(env);
    6087
    6088         /* Disable window if specified -- windows are enabled by default. */
    6089         jboolean enabled = (jboolean)env->GetBooleanField(target,
    6090                                                           AwtComponent::enabledID);
    6091         if (!enabled) {
    6092             ::EnableWindow(c->GetHWnd(), FALSE);
    6093         }
    6094
    6095         /* The peer is now ready for callbacks, since this is the last
    6096          * initialization call
    6097          */
    6098         c->EnableCallbacks(TRUE);
    6099
    6100         // Fix 4745222: we need to invalidate region since we validated it before initialization.
    6101         ::InvalidateRgn(c->GetHWnd(), NULL, FALSE);
    6102
    6103         // Fix 4530093: WM_PAINT after EnableCallbacks
    6104         ::UpdateWindow(c->GetHWnd());
    6105
    6106         env->DeleteLocalRef(target);
    6107     }
    6108 ret:
    6109     env->DeleteGlobalRef(self);
    6110 }
    6111
    6112 void AwtComponent::_BeginValidate(void *param)
    6113 {
    6114     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6115     if (AwtToolkit::IsMainThread()) {
    6116         jobject self = (jobject)param;
    6117         if (self != NULL) {
    6118             PDATA pData = JNI_GET_PDATA(self);
    6119             if (pData) {
    6120                 AwtComponent *c = (AwtComponent *)pData;
    6121                 if (::IsWindow(c->GetHWnd())) {
    6122                     c->SendMessage(WM_AWT_BEGIN_VALIDATE);
    6123                 }
    6124             }
    6125             env->DeleteGlobalRef(self);
    6126         }
    6127     } else {
    6128         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_BeginValidate, param);
    6129     }
    6130 }
    6131
    6132 void AwtComponent::_EndValidate(void *param)
    6133 {
    6134     if (AwtToolkit::IsMainThread()) {
    6135         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6136         jobject self = (jobject)param;
    6137         if (self != NULL) {
    6138             PDATA pData = JNI_GET_PDATA(self);
    6139             if (pData) {
    6140                 AwtComponent *c = (AwtComponent *)pData;
    6141                 if (::IsWindow(c->GetHWnd())) {
    6142                     c->SendMessage(WM_AWT_END_VALIDATE);
    6143                 }
    6144             }
    6145             env->DeleteGlobalRef(self);
    6146         }
    6147     } else {
    6148         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_EndValidate, param);
    6149     }
    6150 }
    6151
    6152 void AwtComponent::_UpdateWindow(void *param)
    6153 {
    6154     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6155     if (AwtToolkit::IsMainThread()) {
    6156         jobject self = (jobject)param;
    6157         AwtComponent *c = NULL;
    6158         PDATA pData;
    6159         JNI_CHECK_PEER_GOTO(self, ret);
    6160         c = (AwtComponent *)pData;
    6161         if (::IsWindow(c->GetHWnd())) {
    6162             ::UpdateWindow(c->GetHWnd());
    6163         }
    6164 ret:
    6165         env->DeleteGlobalRef(self);
    6166     } else {
    6167         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_UpdateWindow, param);
    6168     }
    6169 }
    6170
    6171 jlong AwtComponent::_AddNativeDropTarget(void *param)
    6172 {
    6173     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6174
    6175     jobject self = (jobject)param;
    6176
    6177     jlong result = 0;
    6178     AwtComponent *c = NULL;
    6179
    6180     PDATA pData;
    6181     JNI_CHECK_PEER_GOTO(self, ret);
    6182     c = (AwtComponent *)pData;
    6183     if (::IsWindow(c->GetHWnd()))
    6184     {
    6185         result = (jlong)(c->CreateDropTarget(env));
    6186     }
    6187 ret:
    6188     env->DeleteGlobalRef(self);
    6189
    6190     return result;
    6191 }
    6192
    6193 void AwtComponent::_RemoveNativeDropTarget(void *param)
    6194 {
    6195     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6196
    6197     jobject self = (jobject)param;
    6198
    6199     AwtComponent *c = NULL;
    6200
    6201     PDATA pData;
    6202     JNI_CHECK_PEER_GOTO(self, ret);
    6203     c = (AwtComponent *)pData;
    6204     if (::IsWindow(c->GetHWnd()))
    6205     {
    6206         c->DestroyDropTarget();
    6207     }
    6208 ret:
    6209     env->DeleteGlobalRef(self);
    6210 }
    6211
    6212 jintArray AwtComponent::_CreatePrintedPixels(void *param)
    6213 {
    6214     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6215
    6216     CreatePrintedPixelsStruct *cpps = (CreatePrintedPixelsStruct *)param;
    6217     jobject self = cpps->component;
    6218
    6219     jintArray result = NULL;
    6220     AwtComponent *c = NULL;
    6221
    6222     PDATA pData;
    6223     JNI_CHECK_PEER_GOTO(self, ret);
    6224     c = (AwtComponent *)pData;
    6225     if (::IsWindow(c->GetHWnd()))
    6226     {
    6227         result = (jintArray)c->SendMessage(WM_AWT_CREATE_PRINTED_PIXELS, (WPARAM)cpps, 0);
    6228     }
    6229 ret:
    6230     env->DeleteGlobalRef(self);
    6231
    6232     delete cpps;
    6233     return result; // this reference is global
    6234 }
    6235
    6236 jboolean AwtComponent::_IsObscured(void *param)
    6237 {
    6238     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6239
    6240     jobject self = (jobject)param;
    6241
    6242     jboolean result = JNI_FALSE;
    6243     AwtComponent *c = NULL;
    6244
    6245     PDATA pData;
    6246     JNI_CHECK_PEER_GOTO(self, ret);
    6247
    6248     c = (AwtComponent *)pData;
    6249
    6250     if (::IsWindow(c->GetHWnd()))
    6251     {
    6252         HWND hWnd = c->GetHWnd();
    6253         HDC hDC = ::GetDC(hWnd);
    6254         RECT clipbox;
    6255         int callresult = ::GetClipBox(hDC, &clipbox);
    6256         switch(callresult) {
    6257             case NULLREGION :
    6258                 result = JNI_FALSE;
    6259                 break;
    6260             case SIMPLEREGION : {
    6261                 RECT windowRect;
    6262                 if (!::GetClientRect(hWnd, &windowRect)) {
    6263                     result = JNI_TRUE;
    6264                 } else {
    6265                     result  = (jboolean)((clipbox.bottom != windowRect.bottom)
    6266                         || (clipbox.left != windowRect.left)
    6267                         || (clipbox.right != windowRect.right)
    6268                         || (clipbox.top != windowRect.top));
    6269                 }
    6270                 break;
    6271             }
    6272             case COMPLEXREGION :
    6273             default :
    6274                 result = JNI_TRUE;
    6275                 break;
    6276         }
    6277         ::ReleaseDC(hWnd, hDC);
    6278     }
    6279 ret:
    6280     env->DeleteGlobalRef(self);
    6281
    6282     return result;
    6283 }
    6284
    6285 jboolean AwtComponent::_NativeHandlesWheelScrolling(void *param)
    6286 {
    6287     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6288
    6289     jobject self = (jobject)param;
    6290
    6291     jboolean result = JNI_FALSE;
    6292     AwtComponent *c = NULL;
    6293
    6294     PDATA pData;
    6295     JNI_CHECK_PEER_GOTO(self, ret);
    6296     c = (AwtComponent *)pData;
    6297     if (::IsWindow(c->GetHWnd()))
    6298     {
    6299         result = JNI_IS_TRUE(c->InheritsNativeMouseWheelBehavior());
    6300     }
    6301 ret:
    6302     env->DeleteGlobalRef(self);
    6303
    6304     return result;
    6305 }
    6306
    6307 void AwtComponent::_SetParent(void * param)
    6308 {
    6309     if (AwtToolkit::IsMainThread()) {
    6310         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6311         SetParentStruct *data = (SetParentStruct*) param;
    6312         jobject self = data->component;
    6313         jobject parent = data->parentComp;
    6314
    6315         AwtComponent *awtComponent = NULL;
    6316         AwtComponent *awtParent = NULL;
    6317
    6318         PDATA pData;
    6319         JNI_CHECK_PEER_GOTO(self, ret);
    6320         awtComponent = (AwtComponent *)pData;
    6321         JNI_CHECK_PEER_GOTO(parent, ret);
    6322         awtParent = (AwtComponent *)pData;
    6323
    6324         HWND selfWnd = awtComponent->GetHWnd();
    6325         HWND parentWnd = awtParent->GetHWnd();
    6326         if (::IsWindow(selfWnd) && ::IsWindow(parentWnd)) {
    6327             // Shouldn't trigger native focus change
    6328             // (only the proxy may be the native focus owner).
    6329             ::SetParent(selfWnd, parentWnd);
    6330         }
    6331 ret:
    6332         env->DeleteGlobalRef(self);
    6333         env->DeleteGlobalRef(parent);
    6334         delete data;
    6335     } else {
    6336         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_SetParent, param);
    6337     }
    6338 }
    6339
    6340 void AwtComponent::_SetRectangularShape(void *param)
    6341 {
    6342     if (!AwtToolkit::IsMainThread()) {
    6343         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_SetRectangularShape, param);
    6344     } else {
    6345         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6346
    6347         SetRectangularShapeStruct *data = (SetRectangularShapeStruct *)param;
    6348         jobject self = data->component;
    6349         jint x1 = data->x1;
    6350         jint x2 = data->x2;
    6351         jint y1 = data->y1;
    6352         jint y2 = data->y2;
    6353         jobject region = data->region;
    6354
    6355         AwtComponent *c = NULL;
    6356
    6357         PDATA pData;
    6358         JNI_CHECK_PEER_GOTO(self, ret);
    6359
    6360         c = (AwtComponent *)pData;
    6361         if (::IsWindow(c->GetHWnd())) {
    6362             HRGN hRgn = NULL;
    6363
    6364             // If all the params are zeros, the shape must be simply reset.
    6365             // Otherwise, convert it into a region.
    6366             if (region || x1 || x2 || y1 || y2) {
    6367                 RECT_T rects[256];
    6368                 RECT_T *pRect = rects;
    6369
    6370                 const int numrects = RegionToYXBandedRectangles(env, x1, y1, x2, y2,
    6371                         region, &pRect, sizeof(rects)/sizeof(rects[0]));
    6372                 if (!pRect) {
    6373                     // RegionToYXBandedRectangles doesn't use safe_Malloc(),
    6374                     // so throw the exception explicitly
    6375                     throw std::bad_alloc();
    6376                 }
    6377
    6378                 RGNDATA *pRgnData = (RGNDATA *) SAFE_SIZE_STRUCT_ALLOC(safe_Malloc,
    6379                         sizeof(RGNDATAHEADER), sizeof(RECT_T), numrects);
    6380                 memcpy((BYTE*)pRgnData + sizeof(RGNDATAHEADER), pRect, sizeof(RECT_T) * numrects);
    6381                 if (pRect != rects) {
    6382                     free(pRect);
    6383                 }
    6384                 pRect = NULL;
    6385
    6386                 RGNDATAHEADER *pRgnHdr = (RGNDATAHEADER *) pRgnData;
    6387                 pRgnHdr->dwSize = sizeof(RGNDATAHEADER);
    6388                 pRgnHdr->iType = RDH_RECTANGLES;
    6389                 pRgnHdr->nRgnSize = 0;
    6390                 pRgnHdr->rcBound.top = 0;
    6391                 pRgnHdr->rcBound.left = 0;
    6392                 pRgnHdr->rcBound.bottom = LONG(y2 - y1);
    6393                 pRgnHdr->rcBound.right = LONG(x2 - x1);
    6394                 pRgnHdr->nCount = numrects;
    6395
    6396                 hRgn = ::ExtCreateRegion(NULL,
    6397                         sizeof(RGNDATAHEADER) + sizeof(RECT_T) * pRgnHdr->nCount, pRgnData);
    6398
    6399                 free(pRgnData);
    6400             }
    6401
    6402             ::SetWindowRgn(c->GetHWnd(), hRgn, TRUE);
    6403         }
    6404
    6405 ret:
    6406         env->DeleteGlobalRef(self);
    6407         if (region) {
    6408             env->DeleteGlobalRef(region);
    6409         }
    6410
    6411         delete data;
    6412     }
    6413 }
    6414
    6415 void AwtComponent::_SetZOrder(void *param) {
    6416     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6417
    6418     SetZOrderStruct *data = (SetZOrderStruct *)param;
    6419     jobject self = data->component;
    6420     HWND above = HWND_TOP;
    6421     if (data->above != 0) {
    6422         above = reinterpret_cast<HWND>(data->above);
    6423     }
    6424
    6425     AwtComponent *c = NULL;
    6426
    6427     PDATA pData;
    6428     JNI_CHECK_PEER_GOTO(self, ret);
    6429
    6430     c = (AwtComponent *)pData;
    6431     if (::IsWindow(c->GetHWnd())) {
    6432         ::SetWindowPos(c->GetHWnd(), above, 0, 0, 0, 0,
    6433                        SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE | SWP_ASYNCWINDOWPOS);
    6434     }
    6435
    6436 ret:
    6437     env->DeleteGlobalRef(self);
    6438
    6439     delete data;
    6440 }
    6441
    6442 void AwtComponent::PostUngrabEvent() {
    6443     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6444     jobject target = GetTarget(env);
    6445     jobject event = JNU_NewObjectByName(env, "sun/awt/UngrabEvent", "(Ljava/awt/Component;)V",
    6446                                         target);
    6447     if (safe_ExceptionOccurred(env)) {
    6448         env->ExceptionDescribe();
    6449         env->ExceptionClear();
    6450     }
    6451     env->DeleteLocalRef(target);
    6452     if (event != NULL) {
    6453         SendEvent(event);
    6454         env->DeleteLocalRef(event);
    6455     }
    6456 }
    6457
    6458 void AwtComponent::SetFocusedWindow(HWND window)
    6459 {
    6460     HWND old = sm_focusedWindow;
    6461     sm_focusedWindow = window;
    6462
    6463     AwtWindow::FocusedWindowChanged(old, window);
    6464 }
    6465
    6466 /************************************************************************
    6467  * Component native methods
    6468  */
    6469
    6470 extern "C" {
    6471
    6472 /**
    6473  * This method is called from the WGL pipeline when it needs to retrieve
    6474  * the HWND associated with a ComponentPeer's C++ level object.
    6475  */
    6476 HWND
    6477 AwtComponent_GetHWnd(JNIEnv *env, jlong pData)
    6478 {
    6479     AwtComponent *p = (AwtComponent *)jlong_to_ptr(pData);
    6480     if (p == NULL) {
    6481         return (HWND)0;
    6482     }
    6483     return p->GetHWnd();
    6484 }
    6485
    6486 static void _GetInsets(void* param)
    6487 {
    6488     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    6489
    6490     GetInsetsStruct *gis = (GetInsetsStruct *)param;
    6491     jobject self = gis->window;
    6492
    6493     gis->insets->left = gis->insets->top =
    6494         gis->insets->right = gis->insets->bottom = 0;
    6495
    6496     PDATA pData;
    6497     JNI_CHECK_PEER_GOTO(self, ret);
    6498     AwtComponent *component = (AwtComponent *)pData;
    6499
    6500     component->GetInsets(gis->insets);
    6501
    6502   ret:
    6503     env->DeleteGlobalRef(self);
    6504     delete gis;
    6505 }
    6506
    6507 /**
    6508  * This method is called from the WGL pipeline when it needs to retrieve
    6509  * the insets associated with a ComponentPeer's C++ level object.
    6510  */
    6511 void AwtComponent_GetInsets(JNIEnv *env, jobject peer, RECT *insets)
    6512 {
    6513     TRY;
    6514
    6515     GetInsetsStruct *gis = new GetInsetsStruct;
    6516     gis->window = env->NewGlobalRef(peer);
    6517     gis->insets = insets;
    6518
    6519     AwtToolkit::GetInstance().InvokeFunction(_GetInsets, gis);
    6520     // global refs and mds are deleted in _UpdateWindow
    6521
    6522     CATCH_BAD_ALLOC;
    6523
    6524 }
    6525
    6526 JNIEXPORT void JNICALL
    6527 Java_java_awt_Component_initIDs(JNIEnv *env, jclass cls)
    6528 {
    6529     TRY;
    6530     jclass inputEventClazz = env->FindClass("java/awt/event/InputEvent");
    6531     CHECK_NULL(inputEventClazz);
    6532     jmethodID getButtonDownMasksID = env->GetStaticMethodID(inputEventClazz, "getButtonDownMasks", "()[I");
    6533     CHECK_NULL(getButtonDownMasksID);
    6534     jintArray obj = (jintArray)env->CallStaticObjectMethod(inputEventClazz, getButtonDownMasksID);
    6535     jint * tmp = env->GetIntArrayElements(obj, JNI_FALSE);
    6536     CHECK_NULL(tmp);
    6537     jsize len = env->GetArrayLength(obj);
    6538     AwtComponent::masks = SAFE_SIZE_NEW_ARRAY(jint, len);
    6539     for (int i = 0; i < len; i++) {
    6540         AwtComponent::masks[i] = tmp[i];
    6541     }
    6542     env->ReleaseIntArrayElements(obj, tmp, 0);
    6543     env->DeleteLocalRef(obj);
    6544
    6545     /* class ids */
    6546     jclass peerCls = env->FindClass("sun/awt/windows/WComponentPeer");
    6547
    6548     DASSERT(peerCls);
    6549     CHECK_NULL(peerCls);
    6550
    6551     /* field ids */
    6552     AwtComponent::peerID =
    6553       env->GetFieldID(cls, "peer", "Ljava/awt/peer/ComponentPeer;");
    6554     DASSERT(AwtComponent::peerID);
    6555     CHECK_NULL(AwtComponent::peerID);
    6556
    6557     AwtComponent::xID = env->GetFieldID(cls, "x", "I");
    6558     DASSERT(AwtComponent::xID);
    6559     CHECK_NULL(AwtComponent::xID);
    6560
    6561     AwtComponent::yID = env->GetFieldID(cls, "y", "I");
    6562     DASSERT(AwtComponent::yID);
    6563     CHECK_NULL(AwtComponent::yID);
    6564
    6565     AwtComponent::heightID = env->GetFieldID(cls, "height", "I");
    6566     DASSERT(AwtComponent::heightID);
    6567     CHECK_NULL(AwtComponent::heightID);
    6568
    6569     AwtComponent::widthID = env->GetFieldID(cls, "width", "I");
    6570     DASSERT(AwtComponent::widthID);
    6571     CHECK_NULL(AwtComponent::widthID);
    6572
    6573     AwtComponent::visibleID = env->GetFieldID(cls, "visible", "Z");
    6574     DASSERT(AwtComponent::visibleID);
    6575     CHECK_NULL(AwtComponent::visibleID);
    6576
    6577     AwtComponent::backgroundID =
    6578         env->GetFieldID(cls, "background", "Ljava/awt/Color;");
    6579     DASSERT(AwtComponent::backgroundID);
    6580     CHECK_NULL(AwtComponent::backgroundID);
    6581
    6582     AwtComponent::foregroundID =
    6583         env->GetFieldID(cls, "foreground", "Ljava/awt/Color;");
    6584     DASSERT(AwtComponent::foregroundID);
    6585     CHECK_NULL(AwtComponent::foregroundID);
    6586
    6587     AwtComponent::enabledID = env->GetFieldID(cls, "enabled", "Z");
    6588     DASSERT(AwtComponent::enabledID);
    6589     CHECK_NULL(AwtComponent::enabledID);
    6590
    6591     AwtComponent::parentID = env->GetFieldID(cls, "parent", "Ljava/awt/Container;");
    6592     DASSERT(AwtComponent::parentID);
    6593     CHECK_NULL(AwtComponent::parentID);
    6594
    6595     AwtComponent::graphicsConfigID =
    6596      env->GetFieldID(cls, "graphicsConfig", "Ljava/awt/GraphicsConfiguration;");
    6597     DASSERT(AwtComponent::graphicsConfigID);
    6598     CHECK_NULL(AwtComponent::graphicsConfigID);
    6599
    6600     AwtComponent::focusableID = env->GetFieldID(cls, "focusable", "Z");
    6601     DASSERT(AwtComponent::focusableID);
    6602     CHECK_NULL(AwtComponent::focusableID);
    6603
    6604     AwtComponent::appContextID = env->GetFieldID(cls, "appContext",
    6605                                                  "Lsun/awt/AppContext;");
    6606     DASSERT(AwtComponent::appContextID);
    6607     CHECK_NULL(AwtComponent::appContextID);
    6608
    6609     AwtComponent::peerGCID = env->GetFieldID(peerCls, "winGraphicsConfig",
    6610                                         "Lsun/awt/Win32GraphicsConfig;");
    6611     DASSERT(AwtComponent::peerGCID);
    6612     CHECK_NULL(AwtComponent::peerGCID);
    6613
    6614     AwtComponent::hwndID = env->GetFieldID(peerCls, "hwnd", "J");
    6615     DASSERT(AwtComponent::hwndID);
    6616     CHECK_NULL(AwtComponent::hwndID);
    6617
    6618     AwtComponent::cursorID = env->GetFieldID(cls, "cursor", "Ljava/awt/Cursor;");
    6619     DASSERT(AwtComponent::cursorID);
    6620     CHECK_NULL(AwtComponent::cursorID);
    6621
    6622     /* method ids */
    6623     AwtComponent::getFontMID =
    6624         env->GetMethodID(cls, "getFont_NoClientCode", "()Ljava/awt/Font;");
    6625     DASSERT(AwtComponent::getFontMID);
    6626     CHECK_NULL(AwtComponent::getFontMID);
    6627
    6628     AwtComponent::getToolkitMID =
    6629         env->GetMethodID(cls, "getToolkitImpl", "()Ljava/awt/Toolkit;");
    6630     DASSERT(AwtComponent::getToolkitMID);
    6631     CHECK_NULL(AwtComponent::getToolkitMID);
    6632
    6633     AwtComponent::isEnabledMID = env->GetMethodID(cls, "isEnabledImpl", "()Z");
    6634     DASSERT(AwtComponent::isEnabledMID);
    6635     CHECK_NULL(AwtComponent::isEnabledMID);
    6636
    6637     AwtComponent::getLocationOnScreenMID =
    6638         env->GetMethodID(cls, "getLocationOnScreen_NoTreeLock", "()Ljava/awt/Point;");
    6639     DASSERT(AwtComponent::getLocationOnScreenMID);
    6640     CHECK_NULL(AwtComponent::getLocationOnScreenMID);
    6641
    6642     AwtComponent::replaceSurfaceDataMID =
    6643         env->GetMethodID(peerCls, "replaceSurfaceData", "()V");
    6644     DASSERT(AwtComponent::replaceSurfaceDataMID);
    6645     CHECK_NULL(AwtComponent::replaceSurfaceDataMID);
    6646
    6647     AwtComponent::replaceSurfaceDataLaterMID =
    6648         env->GetMethodID(peerCls, "replaceSurfaceDataLater", "()V");
    6649     DASSERT(AwtComponent::replaceSurfaceDataLaterMID);
    6650     CHECK_NULL(AwtComponent::replaceSurfaceDataLaterMID);
    6651
    6652     AwtComponent::disposeLaterMID = env->GetMethodID(peerCls, "disposeLater", "()V");
    6653     DASSERT(AwtComponent::disposeLaterMID);
    6654     CHECK_NULL(AwtComponent::disposeLaterMID);
    6655
    6656     CATCH_BAD_ALLOC;
    6657 }
    6658
    6659 } /* extern "C" */
    6660
    6661
    6662 /************************************************************************
    6663  * ComponentPeer native methods
    6664  */
    6665
    6666 extern "C" {
    6667
    6668 /*
    6669  * Class:     sun_awt_windows_WComponentPeer
    6670  * Method:    pShow
    6671  * Signature: ()V
    6672  */
    6673 JNIEXPORT void JNICALL
    6674 Java_sun_awt_windows_WComponentPeer_pShow(JNIEnv *env, jobject self)
    6675 {
    6676     TRY;
    6677
    6678     jobject selfGlobalRef = env->NewGlobalRef(self);
    6679
    6680     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Show, (void *)selfGlobalRef);
    6681     // selfGlobalRef is deleted in _Show
    6682
    6683     CATCH_BAD_ALLOC;
    6684 }
    6685
    6686 /*
    6687  * Class:     sun_awt_windows_WComponentPeer
    6688  * Method:    hide
    6689  * Signature: ()V
    6690  */
    6691 JNIEXPORT void JNICALL
    6692 Java_sun_awt_windows_WComponentPeer_hide(JNIEnv *env, jobject self)
    6693 {
    6694     TRY;
    6695
    6696     jobject selfGlobalRef = env->NewGlobalRef(self);
    6697
    6698     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Hide, (void *)selfGlobalRef);
    6699     // selfGlobalRef is deleted in _Hide
    6700
    6701     CATCH_BAD_ALLOC;
    6702 }
    6703
    6704 /*
    6705  * Class:     sun_awt_windows_WComponentPeer
    6706  * Method:    enable
    6707  * Signature: ()V
    6708  */
    6709 JNIEXPORT void JNICALL
    6710 Java_sun_awt_windows_WComponentPeer_enable(JNIEnv *env, jobject self)
    6711 {
    6712     TRY;
    6713
    6714     jobject selfGlobalRef = env->NewGlobalRef(self);
    6715
    6716     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Enable, (void *)selfGlobalRef);
    6717     // selfGlobalRef is deleted in _Enable
    6718
    6719     CATCH_BAD_ALLOC;
    6720 }
    6721
    6722 /*
    6723  * Class:     sun_awt_windows_WComponentPeer
    6724  * Method:    disable
    6725  * Signature: ()V
    6726  */
    6727 JNIEXPORT void JNICALL
    6728 Java_sun_awt_windows_WComponentPeer_disable(JNIEnv *env, jobject self)
    6729 {
    6730     TRY;
    6731
    6732     jobject selfGlobalRef = env->NewGlobalRef(self);
    6733
    6734     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Disable, (void *)selfGlobalRef);
    6735     // selfGlobalRef is deleted in _Disable
    6736
    6737     CATCH_BAD_ALLOC;
    6738 }
    6739
    6740 /*
    6741  * Class:     sun_awt_windows_WComponentPeer
    6742  * Method:    getLocationOnScreen
    6743  * Signature: ()Ljava/awt/Point;
    6744  */
    6745 JNIEXPORT jobject JNICALL
    6746 Java_sun_awt_windows_WComponentPeer_getLocationOnScreen(JNIEnv *env, jobject self)
    6747 {
    6748     TRY;
    6749
    6750     jobject selfGlobalRef = env->NewGlobalRef(self);
    6751
    6752     jobject resultGlobalRef = (jobject)AwtToolkit::GetInstance().SyncCall(
    6753         (void*(*)(void*))AwtComponent::_GetLocationOnScreen, (void *)selfGlobalRef);
    6754     // selfGlobalRef is deleted in _GetLocationOnScreen
    6755     if (resultGlobalRef != NULL)
    6756     {
    6757         jobject resultLocalRef = env->NewLocalRef(resultGlobalRef);
    6758         env->DeleteGlobalRef(resultGlobalRef);
    6759         return resultLocalRef;
    6760     }
    6761
    6762     return NULL;
    6763
    6764     CATCH_BAD_ALLOC_RET(NULL);
    6765 }
    6766
    6767 /*
    6768  * Class:     sun_awt_windows_WComponentPeer
    6769  * Method:    reshape
    6770  * Signature: (IIII)V
    6771  */
    6772 JNIEXPORT void JNICALL
    6773 Java_sun_awt_windows_WComponentPeer_reshape(JNIEnv *env, jobject self,
    6774                                             jint x, jint y, jint w, jint h)
    6775 {
    6776     TRY;
    6777
    6778     ReshapeStruct *rs = new ReshapeStruct;
    6779     rs->component = env->NewGlobalRef(self);
    6780     rs->x = x;
    6781     rs->y = y;
    6782     rs->w = w;
    6783     rs->h = h;
    6784
    6785     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Reshape, rs);
    6786     // global ref and rs are deleted in _Reshape
    6787
    6788     CATCH_BAD_ALLOC;
    6789 }
    6790
    6791 /*
    6792  * Class:     sun_awt_windows_WComponentPeer
    6793  * Method:    reshape
    6794  * Signature: (IIII)V
    6795  */
    6796 JNIEXPORT void JNICALL
    6797 Java_sun_awt_windows_WComponentPeer_reshapeNoCheck(JNIEnv *env, jobject self,
    6798                                             jint x, jint y, jint w, jint h)
    6799 {
    6800     TRY;
    6801
    6802     ReshapeStruct *rs = new ReshapeStruct;
    6803     rs->component = env->NewGlobalRef(self);
    6804     rs->x = x;
    6805     rs->y = y;
    6806     rs->w = w;
    6807     rs->h = h;
    6808
    6809     AwtToolkit::GetInstance().SyncCall(AwtComponent::_ReshapeNoCheck, rs);
    6810     // global ref and rs are deleted in _ReshapeNoCheck
    6811
    6812     CATCH_BAD_ALLOC;
    6813 }
    6814
    6815
    6816 /*
    6817  * Class:     sun_awt_windows_WComponentPeer
    6818  * Method:    nativeHandleEvent
    6819  * Signature: (Ljava/awt/AWTEvent;)V
    6820  */
    6821 JNIEXPORT void JNICALL
    6822 Java_sun_awt_windows_WComponentPeer_nativeHandleEvent(JNIEnv *env,
    6823                                                       jobject self,
    6824                                                       jobject event)
    6825 {
    6826     TRY;
    6827
    6828     jobject selfGlobalRef = env->NewGlobalRef(self);
    6829     jobject eventGlobalRef = env->NewGlobalRef(event);
    6830
    6831     NativeHandleEventStruct *nhes = new NativeHandleEventStruct;
    6832     nhes->component = selfGlobalRef;
    6833     nhes->event = eventGlobalRef;
    6834
    6835     AwtToolkit::GetInstance().SyncCall(AwtComponent::_NativeHandleEvent, nhes);
    6836     // global refs and nhes are deleted in _NativeHandleEvent
    6837
    6838     CATCH_BAD_ALLOC;
    6839 }
    6840
    6841 /*
    6842  * Class:     sun_awt_windows_WComponentPeer
    6843  * Method:    _dispose
    6844  * Signature: ()V
    6845  */
    6846 JNIEXPORT void JNICALL
    6847 Java_sun_awt_windows_WComponentPeer__1dispose(JNIEnv *env, jobject self)
    6848 {
    6849     TRY_NO_HANG;
    6850
    6851     AwtObject::_Dispose(self);
    6852
    6853     CATCH_BAD_ALLOC;
    6854 }
    6855
    6856 /*
    6857  * Class:     sun_awt_windows_WComponentPeer
    6858  * Method:    _setForeground
    6859  * Signature: (I)V
    6860  */
    6861 JNIEXPORT void JNICALL
    6862 Java_sun_awt_windows_WComponentPeer__1setForeground(JNIEnv *env, jobject self,
    6863                                                     jint rgb)
    6864 {
    6865     TRY;
    6866
    6867     jobject selfGlobalRef = env->NewGlobalRef(self);
    6868
    6869     SetColorStruct *scs = new SetColorStruct;
    6870     scs->component = selfGlobalRef;
    6871     scs->rgb = rgb;
    6872
    6873     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetForeground, scs);
    6874     // selfGlobalRef and scs are deleted in _SetForeground()
    6875
    6876     CATCH_BAD_ALLOC;
    6877 }
    6878
    6879 /*
    6880  * Class:     sun_awt_windows_WComponentPeer
    6881  * Method:    _setBackground
    6882  * Signature: (I)V
    6883  */
    6884 JNIEXPORT void JNICALL
    6885 Java_sun_awt_windows_WComponentPeer__1setBackground(JNIEnv *env, jobject self,
    6886                                                     jint rgb)
    6887 {
    6888     TRY;
    6889
    6890     jobject selfGlobalRef = env->NewGlobalRef(self);
    6891
    6892     SetColorStruct *scs = new SetColorStruct;
    6893     scs->component = selfGlobalRef;
    6894     scs->rgb = rgb;
    6895
    6896     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetBackground, scs);
    6897     // selfGlobalRef and scs are deleted in _SetBackground()
    6898
    6899     CATCH_BAD_ALLOC;
    6900 }
    6901
    6902 /*
    6903  * Class:     sun_awt_windows_WComponentPeer
    6904  * Method:    _setFont
    6905  * Signature: (Ljava/awt/Font;)V
    6906  */
    6907 JNIEXPORT void JNICALL
    6908 Java_sun_awt_windows_WComponentPeer__1setFont(JNIEnv *env, jobject self,
    6909                         jobject font)
    6910 {
    6911     TRY;
    6912
    6913     jobject selfGlobalRef = env->NewGlobalRef(self);
    6914     jobject fontGlobalRef = env->NewGlobalRef(font);
    6915
    6916     SetFontStruct *sfs = new SetFontStruct;
    6917     sfs->component = selfGlobalRef;
    6918     sfs->font = fontGlobalRef;
    6919
    6920     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetFont, sfs);
    6921     // global refs and sfs are deleted in _SetFont()
    6922
    6923     CATCH_BAD_ALLOC;
    6924 }
    6925
    6926 /*
    6927  * Class:     sun_awt_windows_WComponentPeer
    6928  * Method:    focusGained
    6929  * Signature: (Z)
    6930  */
    6931 JNIEXPORT void JNICALL Java_sun_awt_windows_WComponentPeer_setFocus
    6932     (JNIEnv *env, jobject self, jboolean doSetFocus)
    6933 {
    6934     TRY;
    6935
    6936     jobject selfGlobalRef = env->NewGlobalRef(self);
    6937
    6938     SetFocusStruct *sfs = new SetFocusStruct;
    6939     sfs->component = selfGlobalRef;
    6940     sfs->doSetFocus = doSetFocus;
    6941
    6942     AwtToolkit::GetInstance().SyncCall(
    6943         (void*(*)(void*))AwtComponent::_SetFocus, sfs);
    6944     // global refs and self are deleted in _SetFocus
    6945
    6946     CATCH_BAD_ALLOC;
    6947 }
    6948
    6949 /*
    6950  * Class:     sun_awt_windows_WComponentPeer
    6951  * Method:    start
    6952  * Signature: ()V
    6953  */
    6954 JNIEXPORT void JNICALL
    6955 Java_sun_awt_windows_WComponentPeer_start(JNIEnv *env, jobject self)
    6956 {
    6957     TRY;
    6958
    6959     jobject selfGlobalRef = env->NewGlobalRef(self);
    6960
    6961     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Start, (void *)selfGlobalRef);
    6962     // selfGlobalRef is deleted in _Start
    6963
    6964     CATCH_BAD_ALLOC;
    6965 }
    6966
    6967 /*
    6968  * Class:     sun_awt_windows_WComponentPeer
    6969  * Method:    beginValidate
    6970  * Signature: ()V
    6971  */
    6972 JNIEXPORT void JNICALL
    6973 Java_sun_awt_windows_WComponentPeer_beginValidate(JNIEnv *env, jobject self)
    6974 {
    6975     TRY;
    6976
    6977     jobject selfGlobalRef = env->NewGlobalRef(self);
    6978
    6979     AwtToolkit::GetInstance().SyncCall(AwtComponent::_BeginValidate, (void *)selfGlobalRef);
    6980     // selfGlobalRef is deleted in _BeginValidate
    6981
    6982     CATCH_BAD_ALLOC;
    6983 }
    6984
    6985 /*
    6986  * Class:     sun_awt_windows_WComponentPeer
    6987  * Method:    endValidate
    6988  * Signature: ()V
    6989  */
    6990 JNIEXPORT void JNICALL
    6991 Java_sun_awt_windows_WComponentPeer_endValidate(JNIEnv *env, jobject self)
    6992 {
    6993     TRY;
    6994
    6995     jobject selfGlobalRef = env->NewGlobalRef(self);
    6996
    6997     AwtToolkit::GetInstance().SyncCall(AwtComponent::_EndValidate, (void *)selfGlobalRef);
    6998     // selfGlobalRef is deleted in _EndValidate
    6999
    7000     CATCH_BAD_ALLOC;
    7001 }
    7002
    7003 JNIEXPORT void JNICALL
    7004 Java_sun_awt_windows_WComponentPeer_updateWindow(JNIEnv *env, jobject self)
    7005 {
    7006     TRY;
    7007
    7008     jobject selfGlobalRef = env->NewGlobalRef(self);
    7009
    7010     AwtToolkit::GetInstance().SyncCall(AwtComponent::_UpdateWindow, (void *)selfGlobalRef);
    7011     // selfGlobalRef is deleted in _UpdateWindow
    7012
    7013     CATCH_BAD_ALLOC;
    7014 }
    7015
    7016 /*
    7017  * Class:     sun_awt_windows_WComponentPeer
    7018  * Method:    addNativeDropTarget
    7019  * Signature: ()L
    7020  */
    7021
    7022 JNIEXPORT jlong JNICALL
    7023 Java_sun_awt_windows_WComponentPeer_addNativeDropTarget(JNIEnv *env,
    7024                                                         jobject self)
    7025 {
    7026     TRY;
    7027
    7028     jobject selfGlobalRef = env->NewGlobalRef(self);
    7029
    7030     return ptr_to_jlong(AwtToolkit::GetInstance().SyncCall(
    7031         (void*(*)(void*))AwtComponent::_AddNativeDropTarget,
    7032         (void *)selfGlobalRef));
    7033     // selfGlobalRef is deleted in _AddNativeDropTarget
    7034
    7035     CATCH_BAD_ALLOC_RET(0);
    7036 }
    7037
    7038 /*
    7039  * Class:     sun_awt_windows_WComponentPeer
    7040  * Method:    removeNativeDropTarget
    7041  * Signature: ()V
    7042  */
    7043
    7044 JNIEXPORT void JNICALL
    7045 Java_sun_awt_windows_WComponentPeer_removeNativeDropTarget(JNIEnv *env,
    7046                                                            jobject self)
    7047 {
    7048     TRY;
    7049
    7050     jobject selfGlobalRef = env->NewGlobalRef(self);
    7051
    7052     AwtToolkit::GetInstance().SyncCall(
    7053         AwtComponent::_RemoveNativeDropTarget, (void *)selfGlobalRef);
    7054     // selfGlobalRef is deleted in _RemoveNativeDropTarget
    7055
    7056     CATCH_BAD_ALLOC;
    7057 }
    7058
    7059 /*
    7060  * Class:     sun_awt_windows_WComponentPeer
    7061  * Method:    getTargetGC
    7062  * Signature: ()Ljava/awt/GraphicsConfiguration;
    7063  */
    7064 JNIEXPORT jobject JNICALL
    7065 Java_sun_awt_windows_WComponentPeer_getTargetGC(JNIEnv* env, jobject theThis)
    7066 {
    7067     TRY;
    7068
    7069     jobject targetObj;
    7070     jobject gc = 0;
    7071
    7072     targetObj = env->GetObjectField(theThis, AwtObject::targetID);
    7073     DASSERT(targetObj);
    7074
    7075     gc = env->GetObjectField(targetObj, AwtComponent::graphicsConfigID);
    7076     return gc;
    7077
    7078     CATCH_BAD_ALLOC_RET(NULL);
    7079 }
    7080
    7081 /*
    7082  * Class:     sun_awt_windows_WComponentPeer
    7083  * Method:    createPrintedPixels
    7084  * Signature: (IIIIII)I[
    7085  */
    7086 JNIEXPORT jintArray JNICALL
    7087 Java_sun_awt_windows_WComponentPeer_createPrintedPixels(JNIEnv* env,
    7088     jobject self, jint srcX, jint srcY, jint srcW, jint srcH, jint alpha)
    7089 {
    7090     TRY;
    7091
    7092     jobject selfGlobalRef = env->NewGlobalRef(self);
    7093
    7094     CreatePrintedPixelsStruct *cpps = new CreatePrintedPixelsStruct;
    7095     cpps->component = selfGlobalRef;
    7096     cpps->srcx = srcX;
    7097     cpps->srcy = srcY;
    7098     cpps->srcw = srcW;
    7099     cpps->srch = srcH;
    7100     cpps->alpha = alpha;
    7101
    7102     jintArray globalRef = (jintArray)AwtToolkit::GetInstance().SyncCall(
    7103         (void*(*)(void*))AwtComponent::_CreatePrintedPixels, cpps);
    7104     // selfGlobalRef and cpps are deleted in _CreatePrintedPixels
    7105     if (globalRef != NULL)
    7106     {
    7107         jintArray localRef = (jintArray)env->NewLocalRef(globalRef);
    7108         env->DeleteGlobalRef(globalRef);
    7109         return localRef;
    7110     }
    7111     else
    7112     {
    7113         return NULL;
    7114     }
    7115
    7116     CATCH_BAD_ALLOC_RET(NULL);
    7117 }
    7118
    7119 /*
    7120  * Class:     sun_awt_windows_WComponentPeer
    7121  * Method:    nativeHandlesWheelScrolling
    7122  * Signature: ()Z
    7123  */
    7124 JNIEXPORT jboolean JNICALL
    7125 Java_sun_awt_windows_WComponentPeer_nativeHandlesWheelScrolling (JNIEnv* env,
    7126     jobject self)
    7127 {
    7128     TRY;
    7129
    7130     return (jboolean)((intptr_t)AwtToolkit::GetInstance().SyncCall(
    7131         (void *(*)(void *))AwtComponent::_NativeHandlesWheelScrolling,
    7132         env->NewGlobalRef(self)));
    7133     // global ref is deleted in _NativeHandlesWheelScrolling
    7134
    7135     CATCH_BAD_ALLOC_RET(NULL);
    7136 }
    7137
    7138 /*
    7139  * Class:     sun_awt_windows_WComponentPeer
    7140  * Method:    isObscured
    7141  * Signature: ()Z
    7142  */
    7143 JNIEXPORT jboolean JNICALL
    7144 Java_sun_awt_windows_WComponentPeer_isObscured(JNIEnv* env,
    7145     jobject self)
    7146 {
    7147     TRY;
    7148
    7149     jobject selfGlobalRef = env->NewGlobalRef(self);
    7150
    7151     return (jboolean)((intptr_t)AwtToolkit::GetInstance().SyncCall(
    7152         (void*(*)(void*))AwtComponent::_IsObscured,
    7153         (void *)selfGlobalRef));
    7154     // selfGlobalRef is deleted in _IsObscured
    7155
    7156     CATCH_BAD_ALLOC_RET(NULL);
    7157 }
    7158
    7159 JNIEXPORT void JNICALL
    7160 Java_sun_awt_windows_WComponentPeer_pSetParent(JNIEnv* env, jobject self, jobject parent) {
    7161     TRY;
    7162
    7163     SetParentStruct * data = new SetParentStruct;
    7164     data->component = env->NewGlobalRef(self);
    7165     data->parentComp = env->NewGlobalRef(parent);
    7166
    7167     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetParent, data);
    7168     // global refs and data are deleted in SetParent
    7169
    7170     CATCH_BAD_ALLOC;
    7171 }
    7172
    7173 JNIEXPORT void JNICALL
    7174 Java_sun_awt_windows_WComponentPeer_setRectangularShape(JNIEnv* env, jobject self,
    7175         jint x1, jint y1, jint x2, jint y2, jobject region)
    7176 {
    7177     TRY;
    7178
    7179     SetRectangularShapeStruct * data = new SetRectangularShapeStruct;
    7180     data->component = env->NewGlobalRef(self);
    7181     data->x1 = x1;
    7182     data->x2 = x2;
    7183     data->y1 = y1;
    7184     data->y2 = y2;
    7185     if (region) {
    7186         data->region = env->NewGlobalRef(region);
    7187     } else {
    7188         data->region = NULL;
    7189     }
    7190
    7191     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetRectangularShape, data);
    7192     // global refs and data are deleted in _SetRectangularShape
    7193
    7194     CATCH_BAD_ALLOC;
    7195 }
    7196
    7197 JNIEXPORT void JNICALL
    7198 Java_sun_awt_windows_WComponentPeer_setZOrder(JNIEnv* env, jobject self, jlong above)
    7199 {
    7200     TRY;
    7201
    7202     SetZOrderStruct * data = new SetZOrderStruct;
    7203     data->component = env->NewGlobalRef(self);
    7204     data->above = above;
    7205
    7206     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetZOrder, data);
    7207     // global refs and data are deleted in _SetLower
    7208
    7209     CATCH_BAD_ALLOC;
    7210 }
    7211
    7212 } /* extern "C" */
    7213
    7214
    7215 /************************************************************************
    7216  * Diagnostic routines
    7217  */
    7218
    7219 #ifdef DEBUG
    7220
    7221 void AwtComponent::VerifyState()
    7222 {
    7223     if (AwtToolkit::GetInstance().VerifyComponents() == FALSE) {
    7224         return;
    7225     }
    7226
    7227     if (m_callbacksEnabled == FALSE) {
    7228         /* Component is not fully setup yet. */
    7229         return;
    7230     }
    7231
    7232     /* Get target bounds. */
    7233     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
    7234     if (env->PushLocalFrame(10) < 0)
    7235         return;
    7236
    7237     jobject target = GetTarget(env);
    7238
    7239     jint x = env->GetIntField(target, AwtComponent::xID);
    7240     jint y = env->GetIntField(target, AwtComponent::yID);
    7241     jint width = env->GetIntField(target, AwtComponent::widthID);
    7242     jint height = env->GetIntField(target, AwtComponent::heightID);
    7243
    7244     /* Convert target origin to absolute coordinates */
    7245     while (TRUE) {
    7246
    7247         jobject parent = env->GetObjectField(target, AwtComponent::parentID);
    7248         if (parent == NULL) {
    7249             break;
    7250         }
    7251         x += env->GetIntField(parent, AwtComponent::xID);
    7252         y += env->GetIntField(parent, AwtComponent::yID);
    7253
    7254         /* If this component has insets, factor them in, but ignore
    7255          * top-level windows.
    7256          */
    7257         jobject parent2 = env->GetObjectField(parent, AwtComponent::parentID);
    7258         if (parent2 != NULL) {
    7259             jobject peer = GetPeerForTarget(env, parent);
    7260             if (peer != NULL &&
    7261                 JNU_IsInstanceOfByName(env, peer,
    7262                                        "sun/awt/windows/WPanelPeer") > 0) {
    7263                 jobject insets =
    7264                     JNU_CallMethodByName(env, NULL, peer,"insets",
    7265                                          "()Ljava/awt/Insets;").l;
    7266                 x += (env)->GetIntField(insets, AwtInsets::leftID);
    7267                 y += (env)->GetIntField(insets, AwtInsets::topID);
    7268             }
    7269         }
    7270         env->DeleteLocalRef(target);
    7271         target = parent;
    7272     }
    7273
    7274     x = ScaleUpX(x);
    7275     y = ScaleUpY(y);
    7276     width = ScaleUpX(width);
    7277     height = ScaleUpY(height);
    7278
    7279     // Test whether component's bounds match the native window's
    7280     RECT rect;
    7281     VERIFY(::GetWindowRect(GetHWnd(), &rect));
    7282 #if 0
    7283     DASSERT( (x == rect.left) &&
    7284             (y == rect.top) &&
    7285             (width == (rect.right-rect.left)) &&
    7286             (height == (rect.bottom-rect.top)) );
    7287 #else
    7288     BOOL fSizeValid = ( (x == rect.left) &&
    7289             (y == rect.top) &&
    7290             (width == (rect.right-rect.left)) &&
    7291             (height == (rect.bottom-rect.top)) );
    7292 #endif
    7293
    7294     // See if visible state matches
    7295     BOOL wndVisible = ::IsWindowVisible(GetHWnd());
    7296     jboolean targetVisible;
    7297     // To avoid possibly running client code on the toolkit thread, don't
    7298     // do the following check if we're running on the toolkit thread.
    7299     if (AwtToolkit::MainThread() != ::GetCurrentThreadId()) {
    7300         targetVisible = JNU_CallMethodByName(env, NULL, GetTarget(env),
    7301                                                   "isShowing", "()Z").z;
    7302         DASSERT(!safe_ExceptionOccurred(env));
    7303     } else {
    7304         targetVisible = wndVisible ? 1 : 0;
    7305     }
    7306 #if 0
    7307     DASSERT( (targetVisible && wndVisible) ||
    7308             (!targetVisible && !wndVisible) );
    7309 #else
    7310     BOOL fVisibleValid = ( (targetVisible && wndVisible) ||
    7311             (!targetVisible && !wndVisible) );
    7312 #endif
    7313
    7314     // Check enabled state
    7315     BOOL wndEnabled = ::IsWindowEnabled(GetHWnd());
    7316     jboolean enabled = (jboolean)env->GetBooleanField(target,
    7317                                                       AwtComponent::enabledID);
    7318 #if 0
    7319     DASSERT( (enabled && wndEnabled) ||
    7320             (!enabled && !wndEnabled) );
    7321 #else
    7322     BOOL fEnabledValid = ((enabled && wndEnabled) ||
    7323                           (!(enabled && !wndEnabled) ));
    7324
    7325     if (!fSizeValid || !fVisibleValid || !fEnabledValid) {
    7326         printf("AwtComponent::ValidateState() failed:\n");
    7327         // To avoid possibly running client code on the toolkit thread, don't
    7328         // do the following call if we're running on the toolkit thread.
    7329         if (AwtToolkit::MainThread() != ::GetCurrentThreadId()) {
    7330             jstring targetStr =
    7331                 (jstring)JNU_CallMethodByName(env, NULL, GetTarget(env),
    7332                                               "getName",
    7333                                               "()Ljava/lang/String;").l;
    7334             DASSERT(!safe_ExceptionOccurred(env));
    7335             LPCWSTR targetStrW = JNU_GetStringPlatformChars(env, targetStr, NULL);
    7336             printf("\t%S\n", targetStrW);
    7337             JNU_ReleaseStringPlatformChars(env, targetStr, targetStrW);
    7338         }
    7339         printf("\twas:       [%d,%d,%dx%d]\n", x, y, width, height);
    7340         if (!fSizeValid) {
    7341             printf("\tshould be: [%d,%d,%dx%d]\n", rect.left, rect.top,
    7342                    rect.right-rect.left, rect.bottom-rect.top);
    7343         }
    7344         if (!fVisibleValid) {
    7345             printf("\tshould be: %s\n",
    7346                    (targetVisible) ? "visible" : "hidden");
    7347         }
    7348         if (!fEnabledValid) {
    7349             printf("\tshould be: %s\n",
    7350                    enabled ? "enabled" : "disabled");
    7351         }
    7352     }
    7353 #endif
    7354     env->PopLocalFrame(0);
    7355 }
    7356 #endif //DEBUG
    7357
    7358 // Methods for globally managed DC list
    7359
    7360 /**
    7361  * Add a new DC to the DC list for this component.
    7362  */
    7363 void DCList::AddDC(HDC hDC, HWND hWnd)
    7364 {
    7365     DCItem *newItem = new DCItem;
    7366     newItem->hDC = hDC;
    7367     newItem->hWnd = hWnd;
    7368     AddDCItem(newItem);
    7369 }
    7370
    7371 void DCList::AddDCItem(DCItem *newItem)
    7372 {
    7373     listLock.Enter();
    7374     newItem->next = head;
    7375     head = newItem;
    7376     listLock.Leave();
    7377 }
    7378
    7379 /**
    7380  * Given a DC and window handle, remove the DC from the DC list
    7381  * and return TRUE if it exists on the current list.  Otherwise
    7382  * return FALSE.
    7383  * A DC may not exist on the list because it has already
    7384  * been released elsewhere (for example, the window
    7385  * destruction process may release a DC while a rendering
    7386  * thread may also want to release a DC when it notices that
    7387  * its DC is obsolete for the current window).
    7388  */
    7389 DCItem *DCList::RemoveDC(HDC hDC, HWND hWnd)
    7390 {
    7391     listLock.Enter();
    7392     DCItem **prevPtrPtr = &head;
    7393     DCItem *listPtr = head;
    7394     while (listPtr) {
    7395         DCItem *nextPtr = listPtr->next;
    7396         if (listPtr->hDC == hDC && listPtr->hWnd == hWnd) {
    7397             *prevPtrPtr = nextPtr;
    7398             break;
    7399         }
    7400         prevPtrPtr = &listPtr->next;
    7401         listPtr = nextPtr;
    7402     }
    7403     listLock.Leave();
    7404     return listPtr;
    7405 }
    7406
    7407 /**
    7408  * Remove all DCs from the DC list which are associated with
    7409  * the same window as hWnd.  Return the list of those
    7410  * DC's to the caller (which will then probably want to
    7411  * call ReleaseDC() for the returned DCs).
    7412  */
    7413 DCItem *DCList::RemoveAllDCs(HWND hWnd)
    7414 {
    7415     listLock.Enter();
    7416     DCItem **prevPtrPtr = &head;
    7417     DCItem *listPtr = head;
    7418     DCItem *newListPtr = NULL;
    7419     BOOL ret = FALSE;
    7420     while (listPtr) {
    7421         DCItem *nextPtr = listPtr->next;
    7422         if (listPtr->hWnd == hWnd) {
    7423             *prevPtrPtr = nextPtr;
    7424             listPtr->next = newListPtr;
    7425             newListPtr = listPtr;
    7426         } else {
    7427             prevPtrPtr = &listPtr->next;
    7428         }
    7429         listPtr = nextPtr;
    7430     }
    7431     listLock.Leave();
    7432     return newListPtr;
    7433 }
    7434
    7435
    7436 /**
    7437  * Realize palettes of all existing HDC objects
    7438  */
    7439 void DCList::RealizePalettes(int screen)
    7440 {
    7441     listLock.Enter();
    7442     DCItem *listPtr = head;
    7443     while (listPtr) {
    7444         AwtWin32GraphicsDevice::RealizePalette(listPtr->hDC, screen);
    7445         listPtr = listPtr->next;
    7446     }
    7447     listLock.Leave();
    7448 }
    7449
    7450 void MoveDCToPassiveList(HDC hDC, HWND hWnd) {
    7451     DCItem *removedDC;
    7452     if ((removedDC = activeDCList.RemoveDC(hDC, hWnd)) != NULL) {
    7453         passiveDCList.AddDCItem(removedDC);
    7454     }
    7455 }
    7456
    7457 void ReleaseDCList(HWND hwnd, DCList &list) {
    7458     DCItem *removedDCs = list.RemoveAllDCs(hwnd);
    7459     while (removedDCs) {
    7460         DCItem *tmpDCList = removedDCs;
    7461         DASSERT(::GetObjectType(tmpDCList->hDC) == OBJ_DC);
    7462         int retValue = ::ReleaseDC(tmpDCList->hWnd, tmpDCList->hDC);
    7463         VERIFY(retValue != 0);
    7464         if (retValue != 0) {
    7465             // Valid ReleaseDC call; need to decrement GDI object counter
    7466             AwtGDIObject::Decrement();
    7467         }
    7468         removedDCs = removedDCs->next;
    7469         delete tmpDCList;
    7470     }
    7471 }
    --- EOF ---