1 /*
   2  * Copyright (c) 1996, 2014, 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_InputMethodEvent.h>
  64 #include <sun_awt_windows_WInputMethod.h>
  65 #include <java_awt_event_MouseEvent.h>
  66 #include <java_awt_event_MouseWheelEvent.h>
  67 
  68 // Begin -- Win32 SDK include files
  69 #include <imm.h>
  70 #include <ime.h>
  71 // End -- Win32 SDK include files
  72 
  73 #include <awt_DnDDT.h>
  74 
  75 LPCTSTR szAwtComponentClassName = TEXT("SunAwtComponent");
  76 // register a message that no other window in the process (even in a plugin
  77 // scenario) will be using
  78 const UINT AwtComponent::WmAwtIsComponent =
  79     ::RegisterWindowMessage(szAwtComponentClassName);
  80 
  81 static HWND g_hwndDown = NULL;
  82 static DCList activeDCList;
  83 static DCList passiveDCList;
  84 
  85 extern void CheckFontSmoothingSettings(HWND);
  86 
  87 extern "C" {
  88     // Remember the input language has changed by some user's action
  89     // (Alt+Shift or through the language icon on the Taskbar) to control the
  90     // race condition between the toolkit thread and the AWT event thread.
  91     // This flag remains TRUE until the next WInputMethod.getNativeLocale() is
  92     // issued.
  93     BOOL g_bUserHasChangedInputLang = FALSE;
  94 }
  95 
  96 BOOL AwtComponent::sm_suppressFocusAndActivation = FALSE;
  97 BOOL AwtComponent::sm_restoreFocusAndActivation = FALSE;
  98 HWND AwtComponent::sm_focusOwner = NULL;
  99 HWND AwtComponent::sm_focusedWindow = NULL;
 100 BOOL AwtComponent::sm_bMenuLoop = FALSE;
 101 AwtComponent* AwtComponent::sm_getComponentCache = NULL;
 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 /************************************************************************/
 155 
 156 //////////////////////////////////////////////////////////////////////////
 157 
 158 /*************************************************************************
 159  * AwtComponent fields
 160  */
 161 
 162 
 163 jfieldID AwtComponent::peerID;
 164 jfieldID AwtComponent::xID;
 165 jfieldID AwtComponent::yID;
 166 jfieldID AwtComponent::widthID;
 167 jfieldID AwtComponent::heightID;
 168 jfieldID AwtComponent::visibleID;
 169 jfieldID AwtComponent::backgroundID;
 170 jfieldID AwtComponent::foregroundID;
 171 jfieldID AwtComponent::enabledID;
 172 jfieldID AwtComponent::parentID;
 173 jfieldID AwtComponent::graphicsConfigID;
 174 jfieldID AwtComponent::peerGCID;
 175 jfieldID AwtComponent::focusableID;
 176 jfieldID AwtComponent::appContextID;
 177 jfieldID AwtComponent::cursorID;
 178 jfieldID AwtComponent::hwndID;
 179 
 180 jmethodID AwtComponent::getFontMID;
 181 jmethodID AwtComponent::getToolkitMID;
 182 jmethodID AwtComponent::isEnabledMID;
 183 jmethodID AwtComponent::getLocationOnScreenMID;
 184 jmethodID AwtComponent::replaceSurfaceDataMID;
 185 jmethodID AwtComponent::replaceSurfaceDataLaterMID;
 186 jmethodID AwtComponent::disposeLaterMID;
 187 
 188 HKL    AwtComponent::m_hkl = ::GetKeyboardLayout(0);
 189 LANGID AwtComponent::m_idLang = LOWORD(::GetKeyboardLayout(0));
 190 UINT   AwtComponent::m_CodePage
 191                        = AwtComponent::LangToCodePage(m_idLang);
 192 
 193 jint *AwtComponent::masks;
 194 
 195 static BOOL bLeftShiftIsDown = false;
 196 static BOOL bRightShiftIsDown = false;
 197 static UINT lastShiftKeyPressed = 0; // init to safe value
 198 
 199 // Added by waleed to initialize the RTL Flags
 200 BOOL AwtComponent::sm_rtl = PRIMARYLANGID(GetInputLanguage()) == LANG_ARABIC ||
 201                             PRIMARYLANGID(GetInputLanguage()) == LANG_HEBREW;
 202 BOOL AwtComponent::sm_rtlReadingOrder =
 203     PRIMARYLANGID(GetInputLanguage()) == LANG_ARABIC;
 204 
 205 BOOL AwtComponent::sm_PrimaryDynamicTableBuilt = FALSE;
 206 
 207 HWND AwtComponent::sm_cursorOn;
 208 BOOL AwtComponent::m_QueryNewPaletteCalled = FALSE;
 209 
 210 CriticalSection windowMoveLock;
 211 BOOL windowMoveLockHeld = FALSE;
 212 
 213 /************************************************************************
 214  * AwtComponent methods
 215  */
 216 
 217 AwtComponent::AwtComponent()
 218 {
 219     m_mouseButtonClickAllowed = 0;
 220     m_callbacksEnabled = FALSE;
 221     m_hwnd = NULL;
 222 
 223     m_colorForeground = 0;
 224     m_colorBackground = 0;
 225     m_backgroundColorSet = FALSE;
 226     m_penForeground = NULL;
 227     m_brushBackground = NULL;
 228     m_DefWindowProc = NULL;
 229     m_nextControlID = 1;
 230     m_childList = NULL;
 231     m_myControlID = 0;
 232     m_hdwp = NULL;
 233     m_validationNestCount = 0;
 234 
 235     m_dropTarget = NULL;
 236 
 237     m_InputMethod = NULL;
 238     m_useNativeCompWindow = TRUE;
 239     m_PendingLeadByte = 0;
 240     m_bitsCandType = 0;
 241 
 242     windowMoveLockPosX = 0;
 243     windowMoveLockPosY = 0;
 244     windowMoveLockPosCX = 0;
 245     windowMoveLockPosCY = 0;
 246 
 247     m_hCursorCache = NULL;
 248 
 249     m_bSubclassed = FALSE;
 250     m_bPauseDestroy = FALSE;
 251 
 252     m_MessagesProcessing = 0;
 253     m_wheelRotationAmount = 0;
 254     if (!sm_PrimaryDynamicTableBuilt) {
 255         // do it once.
 256         AwtComponent::BuildPrimaryDynamicTable();
 257         sm_PrimaryDynamicTableBuilt = TRUE;
 258     }
 259 }
 260 
 261 AwtComponent::~AwtComponent()
 262 {
 263     DASSERT(AwtToolkit::IsMainThread());
 264 
 265     /* Disconnect all links. */
 266     UnlinkObjects();
 267 
 268     /*
 269      * All the messages for this component are processed, native
 270      * resources are freed, and Java object is not connected to
 271      * the native one anymore. So we can safely destroy component's
 272      * handle.
 273      */
 274     DestroyHWnd();
 275 
 276     if (sm_getComponentCache == this) {
 277         sm_getComponentCache = NULL;
 278     }
 279 }
 280 
 281 void AwtComponent::Dispose()
 282 {
 283     // NOTE: in case the component/toplevel was focused, Java should
 284     // have already taken care of proper transferring it or clearing.
 285 
 286     if (m_hdwp != NULL) {
 287     // end any deferred window positioning, regardless
 288     // of m_validationNestCount
 289         ::EndDeferWindowPos(m_hdwp);
 290     }
 291 
 292     // Send final message to release all DCs associated with this component
 293     SendMessage(WM_AWT_RELEASE_ALL_DCS);
 294 
 295     /* Stop message filtering. */
 296     UnsubclassHWND();
 297 
 298     /* Release global ref to input method */
 299     SetInputMethod(NULL, TRUE);
 300 
 301     if (m_childList != NULL)
 302         delete m_childList;
 303 
 304     DestroyDropTarget();
 305     ReleaseDragCapture(0);
 306 
 307     if (m_myControlID != 0) {
 308         AwtComponent* parent = GetParent();
 309         if (parent != NULL)
 310             parent->RemoveChild(m_myControlID);
 311     }
 312 
 313     ::RemoveProp(GetHWnd(), DrawingStateProp);
 314 
 315     /* Release any allocated resources. */
 316     if (m_penForeground != NULL) {
 317         m_penForeground->Release();
 318         m_penForeground = NULL;
 319     }
 320     if (m_brushBackground != NULL) {
 321         m_brushBackground->Release();
 322         m_brushBackground = NULL;
 323     }
 324 
 325     if (m_bPauseDestroy) {
 326         // AwtComponent::WmNcDestroy could be released now
 327         m_bPauseDestroy = FALSE;
 328         m_hwnd = NULL;
 329     }
 330 
 331     // The component instance is deleted using AwtObject::Dispose() method
 332     AwtObject::Dispose();
 333 }
 334 
 335 /* store component pointer in window extra bytes */
 336 void AwtComponent::SetComponentInHWND() {
 337     DASSERT(::GetWindowLongPtr(GetHWnd(), GWLP_USERDATA) == NULL);
 338     ::SetWindowLongPtr(GetHWnd(), GWLP_USERDATA, (LONG_PTR)this);
 339 }
 340 
 341 /*
 342  * static function to get AwtComponent pointer from hWnd --
 343  * you don't want to call this from inside a wndproc to avoid
 344  * infinite recursion
 345  */
 346 AwtComponent* AwtComponent::GetComponent(HWND hWnd) {
 347     // Requests for Toolkit hwnd resolution happen pretty often. Check first.
 348     if (hWnd == AwtToolkit::GetInstance().GetHWnd()) {
 349         return NULL;
 350     }
 351     if (sm_getComponentCache && sm_getComponentCache->GetHWnd() == hWnd) {
 352         return sm_getComponentCache;
 353     }
 354 
 355     // check that it's an AWT component from the same toolkit as the caller
 356     if (::IsWindow(hWnd) &&
 357         AwtToolkit::MainThread() == ::GetWindowThreadProcessId(hWnd, NULL))
 358     {
 359         DASSERT(WmAwtIsComponent != 0);
 360         if (::SendMessage(hWnd, WmAwtIsComponent, 0, 0L)) {
 361             return sm_getComponentCache = GetComponentImpl(hWnd);
 362         }
 363     }
 364     return NULL;
 365 }
 366 
 367 /*
 368  * static function to get AwtComponent pointer from hWnd--
 369  * different from GetComponent because caller knows the
 370  * hwnd is an AWT component hwnd
 371  */
 372 AwtComponent* AwtComponent::GetComponentImpl(HWND hWnd) {
 373     AwtComponent *component =
 374         (AwtComponent *)::GetWindowLongPtr(hWnd, GWLP_USERDATA);
 375     DASSERT(!component || !IsBadReadPtr(component, sizeof(AwtComponent)) );
 376     DASSERT(!component || component->GetHWnd() == hWnd );
 377     return component;
 378 }
 379 
 380 /*
 381  * Single window proc for all the components. Delegates real work to
 382  * the component's WindowProc() member function.
 383  */
 384 LRESULT CALLBACK AwtComponent::WndProc(HWND hWnd, UINT message,
 385                                        WPARAM wParam, LPARAM lParam)
 386 {
 387     TRY;
 388 
 389     AwtComponent * self = AwtComponent::GetComponentImpl(hWnd);
 390     if (self == NULL || self->GetHWnd() != hWnd ||
 391         message == WM_UNDOCUMENTED_CLIENTSHUTDOWN) // handle log-off gracefully
 392     {
 393         return ComCtl32Util::GetInstance().DefWindowProc(NULL, hWnd, message, wParam, lParam);
 394     } else {
 395         return self->WindowProc(message, wParam, lParam);
 396     }
 397 
 398     CATCH_BAD_ALLOC_RET(0);
 399 }
 400 
 401 BOOL AwtComponent::IsFocusable() {
 402     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 403     jobject peer = GetPeer(env);
 404     jobject target = env->GetObjectField(peer, AwtObject::targetID);
 405     BOOL res = env->GetBooleanField(target, focusableID);
 406     AwtWindow *pCont = GetContainer();
 407     if (pCont) {
 408         res &= pCont->IsFocusableWindow();
 409     }
 410     env->DeleteLocalRef(target);
 411     return res;
 412 }
 413 
 414 /************************************************************************
 415  * AwtComponent dynamic methods
 416  *
 417  * Window class registration routines
 418  */
 419 
 420 /*
 421  * Fix for 4964237: Win XP: Changing theme changes java dialogs title icon
 422  */
 423 void AwtComponent::FillClassInfo(WNDCLASSEX *lpwc)
 424 {
 425     lpwc->cbSize        = sizeof(WNDCLASSEX);
 426     lpwc->style         = 0L;//CS_OWNDC;
 427     lpwc->lpfnWndProc   = (WNDPROC)::DefWindowProc;
 428     lpwc->cbClsExtra    = 0;
 429     lpwc->cbWndExtra    = 0;
 430     lpwc->hInstance     = AwtToolkit::GetInstance().GetModuleHandle(),
 431     lpwc->hIcon         = AwtToolkit::GetInstance().GetAwtIcon();
 432     lpwc->hCursor       = NULL;
 433     lpwc->hbrBackground = NULL;
 434     lpwc->lpszMenuName  = NULL;
 435     lpwc->lpszClassName = GetClassName();
 436     //Fixed 6233560: PIT: Java Cup Logo on the title bar of top-level windows look blurred, Win32
 437     lpwc->hIconSm       = AwtToolkit::GetInstance().GetAwtIconSm();
 438 }
 439 
 440 void AwtComponent::RegisterClass()
 441 {
 442     WNDCLASSEX wc;
 443     if (!::GetClassInfoEx(AwtToolkit::GetInstance().GetModuleHandle(), GetClassName(), &wc)) {
 444         FillClassInfo(&wc);
 445         ATOM ret = ::RegisterClassEx(&wc);
 446         DASSERT(ret != 0);
 447     }
 448 }
 449 
 450 void AwtComponent::UnregisterClass()
 451 {
 452     ::UnregisterClass(GetClassName(), AwtToolkit::GetInstance().GetModuleHandle());
 453 }
 454 
 455 /*
 456  * Copy the graphicsConfig reference from Component into WComponentPeer
 457  */
 458 void AwtComponent::InitPeerGraphicsConfig(JNIEnv *env, jobject peer)
 459 {
 460     jobject target = env->GetObjectField(peer, AwtObject::targetID);
 461     //Get graphicsConfig object ref from Component
 462     jobject compGC = env->GetObjectField(target,
 463                       AwtComponent::graphicsConfigID);
 464 
 465     //Set peer's graphicsConfig to Component's graphicsConfig
 466     if (compGC != NULL) {
 467         jclass win32GCCls = env->FindClass("sun/awt/Win32GraphicsConfig");
 468         DASSERT(win32GCCls != NULL);
 469         DASSERT(env->IsInstanceOf(compGC, win32GCCls));
 470         if (win32GCCls == NULL) {
 471             throw std::bad_alloc();
 472         }
 473         env->SetObjectField(peer, AwtComponent::peerGCID, compGC);
 474     }
 475 }
 476 
 477 void
 478 AwtComponent::CreateHWnd(JNIEnv *env, LPCWSTR title,
 479                          DWORD windowStyle,
 480                          DWORD windowExStyle,
 481                          int x, int y, int w, int h,
 482                          HWND hWndParent, HMENU hMenu,
 483                          COLORREF colorForeground,
 484                          COLORREF colorBackground,
 485                          jobject peer)
 486 {
 487     if (env->EnsureLocalCapacity(2) < 0) {
 488         return;
 489     }
 490 
 491     /*
 492      * The window class of multifont label must be "BUTTON" because
 493      * "STATIC" class can't get WM_DRAWITEM message, and m_peerObject
 494      * member is referred in the GetClassName method of AwtLabel class.
 495      * So m_peerObject member must be set here.
 496      */
 497     if (m_peerObject == NULL) {
 498         m_peerObject = env->NewGlobalRef(peer);
 499     } else {
 500         assert(env->IsSameObject(m_peerObject, peer));
 501     }
 502 
 503     RegisterClass();
 504 
 505     jobject target = env->GetObjectField(peer, AwtObject::targetID);
 506     jboolean visible = env->GetBooleanField(target, AwtComponent::visibleID);
 507     m_visible = visible;
 508 
 509     if (visible) {
 510         windowStyle |= WS_VISIBLE;
 511     } else {
 512         windowStyle &= ~WS_VISIBLE;
 513     }
 514 
 515     InitPeerGraphicsConfig(env, peer);
 516 
 517     SetLastError(0);
 518     HWND hwnd = ::CreateWindowEx(windowExStyle,
 519                                  GetClassName(),
 520                                  title,
 521                                  windowStyle,
 522                                  x, y, w, h,
 523                                  hWndParent,
 524                                  hMenu,
 525                                  AwtToolkit::GetInstance().GetModuleHandle(),
 526                                  NULL);
 527 
 528     // fix for 5088782
 529     // check if CreateWindowsEx() returns not null value and if it does -
 530     //   create an InternalError or OutOfMemoryError based on GetLastError().
 531     //   This error is set to createError field of WObjectPeer and then
 532     //   checked and thrown in WComponentPeer constructor. We can't throw an
 533     //   error here because this code is invoked on Toolkit thread
 534     if (hwnd == NULL)
 535     {
 536         DWORD dw = ::GetLastError();
 537         jobject createError = NULL;
 538         if (dw == ERROR_OUTOFMEMORY)
 539         {
 540             jstring errorMsg = JNU_NewStringPlatform(env, L"too many window handles");
 541             if (errorMsg == NULL || env->ExceptionCheck()) {
 542                 env->ExceptionClear();
 543                 createError = JNU_NewObjectByName(env, "java/lang/OutOfMemoryError", "()V");
 544             } else {
 545                 createError = JNU_NewObjectByName(env, "java/lang/OutOfMemoryError",
 546                                                       "(Ljava/lang/String;)V",
 547                                                       errorMsg);
 548                 env->DeleteLocalRef(errorMsg);
 549             }
 550         }
 551         else
 552         {
 553             TCHAR *buf;
 554             FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 555                 NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 556                 (LPTSTR)&buf, 0, NULL);
 557             jstring s = JNU_NewStringPlatform(env, buf);
 558             if (s == NULL || env->ExceptionCheck()) {
 559                 env->ExceptionClear();
 560                 createError = JNU_NewObjectByName(env, "java/lang/InternalError", "()V");
 561             } else {
 562                 createError = JNU_NewObjectByName(env, "java/lang/InternalError",
 563                                                                   "(Ljava/lang/String;)V", s);
 564                 env->DeleteLocalRef(s);
 565             }
 566             LocalFree(buf);
 567         }
 568         if (createError != NULL) {
 569             env->SetObjectField(peer, AwtObject::createErrorID, createError);
 570             env->DeleteLocalRef(createError);
 571         }
 572         env->DeleteLocalRef(target);
 573         return;
 574     }
 575 
 576     m_hwnd = hwnd;
 577 
 578     ::ImmAssociateContext(m_hwnd, NULL);
 579 
 580     SetDrawState((jint)JAWT_LOCK_SURFACE_CHANGED |
 581         (jint)JAWT_LOCK_BOUNDS_CHANGED |
 582         (jint)JAWT_LOCK_CLIP_CHANGED);
 583 
 584     LinkObjects(env, peer);
 585 
 586     /* Subclass the window now so that we can snoop on its messages */
 587     SubclassHWND();
 588 
 589     /*
 590       * Fix for 4046446.
 591       */
 592     SetWindowPos(GetHWnd(), 0, x, y, w, h, SWP_NOZORDER | SWP_NOCOPYBITS | SWP_NOACTIVATE);
 593 
 594     /* Set default colors. */
 595     m_colorForeground = colorForeground;
 596     m_colorBackground = colorBackground;
 597 
 598     /*
 599      * Only set background color if the color is actually set on the
 600      * target -- this avoids inheriting a parent's color unnecessarily,
 601      * and has to be done here because there isn't an API to get the
 602      * real background color from outside the AWT package.
 603      */
 604     jobject bkgrd = env->GetObjectField(target, AwtComponent::backgroundID) ;
 605     if (bkgrd != NULL) {
 606         JNU_CallMethodByName(env, NULL, peer, "setBackground",
 607                              "(Ljava/awt/Color;)V", bkgrd);
 608         DASSERT(!safe_ExceptionOccurred(env));
 609     }
 610     env->DeleteLocalRef(target);
 611     env->DeleteLocalRef(bkgrd);
 612 }
 613 
 614 /*
 615  * Destroy this window's HWND
 616  */
 617 void AwtComponent::DestroyHWnd() {
 618     if (m_hwnd != NULL) {
 619         AwtToolkit::DestroyComponentHWND(m_hwnd);
 620         //AwtToolkit::DestroyComponent(this);
 621         m_hwnd = NULL;
 622     }
 623 }
 624 
 625 /*
 626  * Returns hwnd for target on non Toolkit thread
 627  */
 628 HWND
 629 AwtComponent::GetHWnd(JNIEnv* env, jobject target) {
 630     if (JNU_IsNull(env, target)) {
 631         return 0;
 632     }
 633     jobject peer = env->GetObjectField(target, AwtComponent::peerID);
 634     if (JNU_IsNull(env, peer)) {
 635         return 0;
 636     }
 637     HWND hwnd = reinterpret_cast<HWND>(static_cast<LONG_PTR> (
 638         env->GetLongField(peer, AwtComponent::hwndID)));
 639     env->DeleteLocalRef(peer);
 640     return hwnd;
 641 }
 642 //
 643 // Propagate the background color to synchronize Java field and peer's field.
 644 // This is needed to fix 4148334
 645 //
 646 void AwtComponent::UpdateBackground(JNIEnv *env, jobject target)
 647 {
 648     if (env->EnsureLocalCapacity(1) < 0) {
 649         return;
 650     }
 651 
 652     jobject bkgrnd = env->GetObjectField(target, AwtComponent::backgroundID);
 653 
 654     if (bkgrnd == NULL) {
 655         bkgrnd = JNU_NewObjectByName(env, "java/awt/Color", "(III)V",
 656                                      GetRValue(m_colorBackground),
 657                                      GetGValue(m_colorBackground),
 658                                      GetBValue(m_colorBackground));
 659         if (bkgrnd != NULL) {
 660             env->SetObjectField(target, AwtComponent::backgroundID, bkgrnd);
 661         }
 662     }
 663     env->DeleteLocalRef(bkgrnd);
 664 }
 665 
 666 /*
 667  * Install our window proc as the proc for our HWND, and save off the
 668  * previous proc as the default
 669  */
 670 void AwtComponent::SubclassHWND()
 671 {
 672     if (m_bSubclassed) {
 673         return;
 674     }
 675     const WNDPROC wndproc = WndProc; // let compiler type check WndProc
 676     m_DefWindowProc = ComCtl32Util::GetInstance().SubclassHWND(GetHWnd(), wndproc);
 677     m_bSubclassed = TRUE;
 678 }
 679 
 680 /*
 681  * Reinstall the original window proc as the proc for our HWND
 682  */
 683 void AwtComponent::UnsubclassHWND()
 684 {
 685     if (!m_bSubclassed) {
 686         return;
 687     }
 688     ComCtl32Util::GetInstance().UnsubclassHWND(GetHWnd(), WndProc, m_DefWindowProc);
 689     m_bSubclassed = FALSE;
 690 }
 691 
 692 /////////////////////////////////////
 693 // (static method)
 694 // Determines the top-level ancestor for a given window. If the given
 695 // window is a top-level window, return itself.
 696 //
 697 // 'Top-level' includes dialogs as well.
 698 //
 699 HWND AwtComponent::GetTopLevelParentForWindow(HWND hwndDescendant) {
 700     if (hwndDescendant == NULL) {
 701         return NULL;
 702     }
 703 
 704     DASSERT(IsWindow(hwndDescendant));
 705     HWND hwnd = hwndDescendant;
 706     for(;;) {
 707         DWORD style = ::GetWindowLong(hwnd, GWL_STYLE);
 708         // a) found a non-child window so terminate
 709         // b) found real toplevel window (e.g. EmbeddedFrame
 710         //    that is child though)
 711         if ( (style & WS_CHILD) == 0 ||
 712              AwtComponent::IsTopLevelHWnd(hwnd) )
 713         {
 714             break;
 715         }
 716         hwnd = ::GetParent(hwnd);
 717     }
 718 
 719     return hwnd;
 720 }
 721 ////////////////////
 722 
 723 jobject AwtComponent::FindHeavyweightUnderCursor(BOOL useCache) {
 724     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 725     if (env->EnsureLocalCapacity(1) < 0) {
 726         return NULL;
 727     }
 728 
 729     HWND hit = NULL;
 730     POINT p = { 0, 0 };
 731     AwtComponent *comp = NULL;
 732 
 733     if (useCache) {
 734         if (sm_cursorOn == NULL) {
 735             return NULL;
 736         }
 737 
 738 
 739         DASSERT(::IsWindow(sm_cursorOn));
 740         VERIFY(::GetCursorPos(&p));
 741         /*
 742          * Fix for BugTraq ID 4304024.
 743          * Allow a non-default cursor only for the client area.
 744          */
 745         comp = AwtComponent::GetComponent(sm_cursorOn);
 746         if (comp != NULL &&
 747             ::SendMessage(sm_cursorOn, WM_NCHITTEST, 0,
 748                           MAKELPARAM(p.x, p.y)) == HTCLIENT) {
 749             goto found;
 750         }
 751     }
 752 
 753     ::GetCursorPos(&p);
 754     hit = ::WindowFromPoint(p);
 755     while (hit != NULL) {
 756         comp = AwtComponent::GetComponent(hit);
 757 
 758         if (comp != NULL) {
 759             INT nHittest = (INT)::SendMessage(hit, WM_NCHITTEST,
 760                                           0, MAKELPARAM(p.x, p.y));
 761             /*
 762              * Fix for BugTraq ID 4304024.
 763              * Allow a non-default cursor only for the client area.
 764              */
 765             if (nHittest != HTCLIENT) {
 766                 /*
 767                  * When over the non-client area, send WM_SETCURSOR
 768                  * to revert the cursor to an arrow.
 769                  */
 770                 ::SendMessage(hit, WM_SETCURSOR, (WPARAM)hit,
 771                               MAKELPARAM(nHittest, WM_MOUSEMOVE));
 772                 return NULL;
 773             } else {
 774               sm_cursorOn = hit;
 775               goto found;
 776             }
 777         }
 778 
 779         if ((::GetWindowLong(hit, GWL_STYLE) & WS_CHILD) == 0) {
 780             return NULL;
 781         }
 782         hit = ::GetParent(hit);
 783     }
 784 
 785     return NULL;
 786 
 787 found:
 788     jobject localRef = comp->GetTarget(env);
 789     jobject globalRef = env->NewGlobalRef(localRef);
 790     env->DeleteLocalRef(localRef);
 791     return globalRef;
 792 }
 793 
 794 void AwtComponent::SetColor(COLORREF c)
 795 {
 796     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
 797     int grayscale = AwtWin32GraphicsDevice::GetGrayness(screen);
 798     if (grayscale != GS_NOTGRAY) {
 799         int g;
 800 
 801         g = (int) (.299 * (c & 0xFF) + .587 * ((c >> 8) & 0xFF) +
 802             .114 * ((c >> 16) & 0xFF) + 0.5);
 803         // c = g | (g << 8) | (g << 16);
 804         c = PALETTERGB(g, g, g);
 805     }
 806 
 807     if (m_colorForeground == c) {
 808         return;
 809     }
 810 
 811     m_colorForeground = c;
 812     if (m_penForeground != NULL) {
 813         m_penForeground->Release();
 814         m_penForeground = NULL;
 815     }
 816     VERIFY(::InvalidateRect(GetHWnd(), NULL, FALSE));
 817 }
 818 
 819 void AwtComponent::SetBackgroundColor(COLORREF c)
 820 {
 821     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
 822     int grayscale = AwtWin32GraphicsDevice::GetGrayness(screen);
 823     if (grayscale != GS_NOTGRAY) {
 824         int g;
 825 
 826         g = (int) (.299 * (c & 0xFF) + .587 * ((c >> 8) & 0xFF) +
 827             .114 * ((c >> 16) & 0xFF) + 0.5);
 828         // c = g | (g << 8) | (g << 16);
 829         c = PALETTERGB(g, g, g);
 830     }
 831 
 832     if (m_colorBackground == c) {
 833         return;
 834     }
 835     m_colorBackground = c;
 836     m_backgroundColorSet = TRUE;
 837     if (m_brushBackground != NULL) {
 838         m_brushBackground->Release();
 839         m_brushBackground = NULL;
 840     }
 841     VERIFY(::InvalidateRect(GetHWnd(), NULL, TRUE));
 842 }
 843 
 844 HPEN AwtComponent::GetForegroundPen()
 845 {
 846     if (m_penForeground == NULL) {
 847         m_penForeground = AwtPen::Get(m_colorForeground);
 848     }
 849     return (HPEN)m_penForeground->GetHandle();
 850 }
 851 
 852 COLORREF AwtComponent::GetBackgroundColor()
 853 {
 854     if (m_backgroundColorSet == FALSE) {
 855         AwtComponent* c = this;
 856         while ((c = c->GetParent()) != NULL) {
 857             if (c->IsBackgroundColorSet()) {
 858                 return c->GetBackgroundColor();
 859             }
 860         }
 861     }
 862     return m_colorBackground;
 863 }
 864 
 865 HBRUSH AwtComponent::GetBackgroundBrush()
 866 {
 867     if (m_backgroundColorSet == FALSE) {
 868         if (m_brushBackground != NULL) {
 869             m_brushBackground->Release();
 870             m_brushBackground = NULL;
 871         }
 872           AwtComponent* c = this;
 873           while ((c = c->GetParent()) != NULL) {
 874               if (c->IsBackgroundColorSet()) {
 875                   m_brushBackground =
 876                       AwtBrush::Get(c->GetBackgroundColor());
 877                   break;
 878               }
 879           }
 880     }
 881     if (m_brushBackground == NULL) {
 882         m_brushBackground = AwtBrush::Get(m_colorBackground);
 883     }
 884     return (HBRUSH)m_brushBackground->GetHandle();
 885 }
 886 
 887 void AwtComponent::SetFont(AwtFont* font)
 888 {
 889     DASSERT(font != NULL);
 890     if (font->GetAscent() < 0) {
 891         AwtFont::SetupAscent(font);
 892     }
 893     SendMessage(WM_SETFONT, (WPARAM)font->GetHFont(), MAKELPARAM(FALSE, 0));
 894     VERIFY(::InvalidateRect(GetHWnd(), NULL, TRUE));
 895 }
 896 
 897 AwtComponent* AwtComponent::GetParent()
 898 {
 899     HWND hwnd = ::GetParent(GetHWnd());
 900     if (hwnd == NULL) {
 901         return NULL;
 902     }
 903     return GetComponent(hwnd);
 904 }
 905 
 906 AwtWindow* AwtComponent::GetContainer()
 907 {
 908     AwtComponent* comp = this;
 909     while (comp != NULL) {
 910         if (comp->IsContainer()) {
 911             return (AwtWindow*)comp;
 912         }
 913         comp = comp->GetParent();
 914     }
 915     return NULL;
 916 }
 917 
 918 void AwtComponent::Show()
 919 {
 920     m_visible = true;
 921     ::ShowWindow(GetHWnd(), SW_SHOWNA);
 922 }
 923 
 924 void AwtComponent::Hide()
 925 {
 926     m_visible = false;
 927     ::ShowWindow(GetHWnd(), SW_HIDE);
 928 }
 929 
 930 BOOL
 931 AwtComponent::SetWindowPos(HWND wnd, HWND after,
 932                            int x, int y, int w, int h, UINT flags)
 933 {
 934     // Conditions we shouldn't handle:
 935     // z-order changes, correct window dimensions
 936     if (after != NULL || (w < 32767 && h < 32767)
 937         || ((::GetWindowLong(wnd, GWL_STYLE) & WS_CHILD) == 0))
 938     {
 939         return ::SetWindowPos(wnd, after, x, y, w, h, flags);
 940     }
 941     WINDOWPLACEMENT wp;
 942     ::ZeroMemory(&wp, sizeof(wp));
 943 
 944     wp.length = sizeof(wp);
 945     ::GetWindowPlacement(wnd, &wp);
 946     wp.rcNormalPosition.left = x;
 947     wp.rcNormalPosition.top = y;
 948     wp.rcNormalPosition.right = x + w;
 949     wp.rcNormalPosition.bottom = y + h;
 950     if ( flags & SWP_NOACTIVATE ) {
 951         wp.showCmd = SW_SHOWNOACTIVATE;
 952     }
 953     ::SetWindowPlacement(wnd, &wp);
 954     return 1;
 955 }
 956 
 957 
 958 void AwtComponent::Reshape(int x, int y, int w, int h)
 959 {
 960 #if defined(DEBUG)
 961     RECT        rc;
 962     ::GetWindowRect(GetHWnd(), &rc);
 963     ::MapWindowPoints(HWND_DESKTOP, ::GetParent(GetHWnd()), (LPPOINT)&rc, 2);
 964     DTRACE_PRINTLN4("AwtComponent::Reshape from %d, %d, %d, %d", rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top);
 965 #endif
 966     AwtWindow* container = GetContainer();
 967     AwtComponent* parent = GetParent();
 968     if (container != NULL && container == parent) {
 969         container->SubtractInsetPoint(x, y);
 970     }
 971     DTRACE_PRINTLN4("AwtComponent::Reshape to %d, %d, %d, %d", x, y, w, h);
 972     UINT flags = SWP_NOACTIVATE | SWP_NOZORDER;
 973 
 974     RECT        r;
 975 
 976     ::GetWindowRect(GetHWnd(), &r);
 977     // if the component size is changing , don't copy window bits
 978     if (r.right - r.left != w || r.bottom - r.top != h) {
 979         flags |= SWP_NOCOPYBITS;
 980     }
 981 
 982     if (parent && _tcscmp(parent->GetClassName(), TEXT("SunAwtScrollPane")) == 0) {
 983         if (x > 0) {
 984             x = 0;
 985         }
 986         if (y > 0) {
 987             y = 0;
 988         }
 989     }
 990     if (m_hdwp != NULL) {
 991         m_hdwp = ::DeferWindowPos(m_hdwp, GetHWnd(), 0, x, y, w, h, flags);
 992         DASSERT(m_hdwp != NULL);
 993     } else {
 994         /*
 995          * Fox for 4046446
 996          * If window has dimensions above the short int limit, ::SetWindowPos doesn't work.
 997          * We should use SetWindowPlacement instead.
 998          */
 999         SetWindowPos(GetHWnd(), 0, x, y, w, h, flags);
1000     }
1001 }
1002 
1003 void AwtComponent::SetScrollValues(UINT bar, int min, int value, int max)
1004 {
1005     int minTmp, maxTmp;
1006 
1007     ::GetScrollRange(GetHWnd(), bar, &minTmp, &maxTmp);
1008     if (min == INT_MAX) {
1009         min = minTmp;
1010     }
1011     if (value == INT_MAX) {
1012         value = ::GetScrollPos(GetHWnd(), bar);
1013     }
1014     if (max == INT_MAX) {
1015         max = maxTmp;
1016     }
1017     if (min == max) {
1018         max++;
1019     }
1020     ::SetScrollRange(GetHWnd(), bar, min, max, FALSE);
1021     ::SetScrollPos(GetHWnd(), bar, value, TRUE);
1022 }
1023 
1024 /*
1025  * Save Global Reference of sun.awt.windows.WInputMethod object
1026  */
1027 void AwtComponent::SetInputMethod(jobject im, BOOL useNativeCompWindow)
1028 {
1029     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1030 
1031     if (m_InputMethod!=NULL)
1032         env->DeleteGlobalRef(m_InputMethod);
1033 
1034     if (im!=NULL){
1035         m_InputMethod = env->NewGlobalRef(im);
1036         m_useNativeCompWindow = useNativeCompWindow;
1037     } else {
1038         m_InputMethod = NULL;
1039         m_useNativeCompWindow = TRUE;
1040     }
1041 
1042 }
1043 
1044 /*
1045  * Opportunity to process and/or eat a message before it is dispatched
1046  */
1047 MsgRouting AwtComponent::PreProcessMsg(MSG& msg)
1048 {
1049     return mrPassAlong;
1050 }
1051 
1052 static UINT lastMessage = WM_NULL;
1053 
1054 #ifndef SPY_MESSAGES
1055 #define SpyWinMessage(hwin,msg,str)
1056 #else
1057 
1058 #define FMT_MSG(x,y) case x: _stprintf(szBuf, \
1059     "0x%8.8x(%s):%s\n", hwnd, szComment, y); break;
1060 #define WIN_MSG(x) FMT_MSG(x,#x)
1061 
1062 void SpyWinMessage(HWND hwnd, UINT message, LPCTSTR szComment) {
1063 
1064     TCHAR szBuf[256];
1065 
1066     switch (message) {
1067         WIN_MSG(WM_NULL)
1068         WIN_MSG(WM_CREATE)
1069         WIN_MSG(WM_DESTROY)
1070         WIN_MSG(WM_MOVE)
1071         WIN_MSG(WM_SIZE)
1072         WIN_MSG(WM_ACTIVATE)
1073         WIN_MSG(WM_SETFOCUS)
1074         WIN_MSG(WM_KILLFOCUS)
1075         WIN_MSG(WM_ENABLE)
1076         WIN_MSG(WM_SETREDRAW)
1077         WIN_MSG(WM_SETTEXT)
1078         WIN_MSG(WM_GETTEXT)
1079         WIN_MSG(WM_GETTEXTLENGTH)
1080         WIN_MSG(WM_PAINT)
1081         WIN_MSG(WM_CLOSE)
1082         WIN_MSG(WM_QUERYENDSESSION)
1083         WIN_MSG(WM_QUIT)
1084         WIN_MSG(WM_QUERYOPEN)
1085         WIN_MSG(WM_ERASEBKGND)
1086         WIN_MSG(WM_SYSCOLORCHANGE)
1087         WIN_MSG(WM_ENDSESSION)
1088         WIN_MSG(WM_SHOWWINDOW)
1089         FMT_MSG(WM_WININICHANGE,"WM_WININICHANGE/WM_SETTINGCHANGE")
1090         WIN_MSG(WM_DEVMODECHANGE)
1091         WIN_MSG(WM_ACTIVATEAPP)
1092         WIN_MSG(WM_FONTCHANGE)
1093         WIN_MSG(WM_TIMECHANGE)
1094         WIN_MSG(WM_CANCELMODE)
1095         WIN_MSG(WM_SETCURSOR)
1096         WIN_MSG(WM_MOUSEACTIVATE)
1097         WIN_MSG(WM_CHILDACTIVATE)
1098         WIN_MSG(WM_QUEUESYNC)
1099         WIN_MSG(WM_GETMINMAXINFO)
1100         WIN_MSG(WM_PAINTICON)
1101         WIN_MSG(WM_ICONERASEBKGND)
1102         WIN_MSG(WM_NEXTDLGCTL)
1103         WIN_MSG(WM_SPOOLERSTATUS)
1104         WIN_MSG(WM_DRAWITEM)
1105         WIN_MSG(WM_MEASUREITEM)
1106         WIN_MSG(WM_DELETEITEM)
1107         WIN_MSG(WM_VKEYTOITEM)
1108         WIN_MSG(WM_CHARTOITEM)
1109         WIN_MSG(WM_SETFONT)
1110         WIN_MSG(WM_GETFONT)
1111         WIN_MSG(WM_SETHOTKEY)
1112         WIN_MSG(WM_GETHOTKEY)
1113         WIN_MSG(WM_QUERYDRAGICON)
1114         WIN_MSG(WM_COMPAREITEM)
1115         FMT_MSG(0x003D, "WM_GETOBJECT")
1116         WIN_MSG(WM_COMPACTING)
1117         WIN_MSG(WM_COMMNOTIFY)
1118         WIN_MSG(WM_WINDOWPOSCHANGING)
1119         WIN_MSG(WM_WINDOWPOSCHANGED)
1120         WIN_MSG(WM_POWER)
1121         WIN_MSG(WM_COPYDATA)
1122         WIN_MSG(WM_CANCELJOURNAL)
1123         WIN_MSG(WM_NOTIFY)
1124         WIN_MSG(WM_INPUTLANGCHANGEREQUEST)
1125         WIN_MSG(WM_INPUTLANGCHANGE)
1126         WIN_MSG(WM_TCARD)
1127         WIN_MSG(WM_HELP)
1128         WIN_MSG(WM_USERCHANGED)
1129         WIN_MSG(WM_NOTIFYFORMAT)
1130         WIN_MSG(WM_CONTEXTMENU)
1131         WIN_MSG(WM_STYLECHANGING)
1132         WIN_MSG(WM_STYLECHANGED)
1133         WIN_MSG(WM_DISPLAYCHANGE)
1134         WIN_MSG(WM_GETICON)
1135         WIN_MSG(WM_SETICON)
1136         WIN_MSG(WM_NCCREATE)
1137         WIN_MSG(WM_NCDESTROY)
1138         WIN_MSG(WM_NCCALCSIZE)
1139         WIN_MSG(WM_NCHITTEST)
1140         WIN_MSG(WM_NCPAINT)
1141         WIN_MSG(WM_NCACTIVATE)
1142         WIN_MSG(WM_GETDLGCODE)
1143         WIN_MSG(WM_SYNCPAINT)
1144         WIN_MSG(WM_NCMOUSEMOVE)
1145         WIN_MSG(WM_NCLBUTTONDOWN)
1146         WIN_MSG(WM_NCLBUTTONUP)
1147         WIN_MSG(WM_NCLBUTTONDBLCLK)
1148         WIN_MSG(WM_NCRBUTTONDOWN)
1149         WIN_MSG(WM_NCRBUTTONUP)
1150         WIN_MSG(WM_NCRBUTTONDBLCLK)
1151         WIN_MSG(WM_NCMBUTTONDOWN)
1152         WIN_MSG(WM_NCMBUTTONUP)
1153         WIN_MSG(WM_NCMBUTTONDBLCLK)
1154         WIN_MSG(WM_KEYDOWN)
1155         WIN_MSG(WM_KEYUP)
1156         WIN_MSG(WM_CHAR)
1157         WIN_MSG(WM_DEADCHAR)
1158         WIN_MSG(WM_SYSKEYDOWN)
1159         WIN_MSG(WM_SYSKEYUP)
1160         WIN_MSG(WM_SYSCHAR)
1161         WIN_MSG(WM_SYSDEADCHAR)
1162         WIN_MSG(WM_IME_STARTCOMPOSITION)
1163         WIN_MSG(WM_IME_ENDCOMPOSITION)
1164         WIN_MSG(WM_IME_COMPOSITION)
1165         WIN_MSG(WM_INITDIALOG)
1166         WIN_MSG(WM_COMMAND)
1167         WIN_MSG(WM_SYSCOMMAND)
1168         WIN_MSG(WM_TIMER)
1169         WIN_MSG(WM_HSCROLL)
1170         WIN_MSG(WM_VSCROLL)
1171         WIN_MSG(WM_INITMENU)
1172         WIN_MSG(WM_INITMENUPOPUP)
1173         WIN_MSG(WM_MENUSELECT)
1174         WIN_MSG(WM_MENUCHAR)
1175         WIN_MSG(WM_ENTERIDLE)
1176         FMT_MSG(0x0122, "WM_MENURBUTTONUP")
1177         FMT_MSG(0x0123, "WM_MENUDRAG")
1178         FMT_MSG(0x0124, "WM_MENUGETOBJECT")
1179         FMT_MSG(0x0125, "WM_UNINITMENUPOPUP")
1180         FMT_MSG(0x0126, "WM_MENUCOMMAND")
1181         WIN_MSG(WM_CTLCOLORMSGBOX)
1182         WIN_MSG(WM_CTLCOLOREDIT)
1183         WIN_MSG(WM_CTLCOLORLISTBOX)
1184         WIN_MSG(WM_CTLCOLORBTN)
1185         WIN_MSG(WM_CTLCOLORDLG)
1186         WIN_MSG(WM_CTLCOLORSCROLLBAR)
1187         WIN_MSG(WM_CTLCOLORSTATIC)
1188         WIN_MSG(WM_MOUSEMOVE)
1189         WIN_MSG(WM_LBUTTONDOWN)
1190         WIN_MSG(WM_LBUTTONUP)
1191         WIN_MSG(WM_LBUTTONDBLCLK)
1192         WIN_MSG(WM_RBUTTONDOWN)
1193         WIN_MSG(WM_RBUTTONUP)
1194         WIN_MSG(WM_RBUTTONDBLCLK)
1195         WIN_MSG(WM_MBUTTONDOWN)
1196         WIN_MSG(WM_MBUTTONUP)
1197         WIN_MSG(WM_MBUTTONDBLCLK)
1198         WIN_MSG(WM_XBUTTONDBLCLK)
1199         WIN_MSG(WM_XBUTTONDOWN)
1200         WIN_MSG(WM_XBUTTONUP)
1201         WIN_MSG(WM_MOUSEWHEEL)
1202         WIN_MSG(WM_PARENTNOTIFY)
1203         WIN_MSG(WM_ENTERMENULOOP)
1204         WIN_MSG(WM_EXITMENULOOP)
1205         WIN_MSG(WM_NEXTMENU)
1206         WIN_MSG(WM_SIZING)
1207         WIN_MSG(WM_CAPTURECHANGED)
1208         WIN_MSG(WM_MOVING)
1209         WIN_MSG(WM_POWERBROADCAST)
1210         WIN_MSG(WM_DEVICECHANGE)
1211         WIN_MSG(WM_MDICREATE)
1212         WIN_MSG(WM_MDIDESTROY)
1213         WIN_MSG(WM_MDIACTIVATE)
1214         WIN_MSG(WM_MDIRESTORE)
1215         WIN_MSG(WM_MDINEXT)
1216         WIN_MSG(WM_MDIMAXIMIZE)
1217         WIN_MSG(WM_MDITILE)
1218         WIN_MSG(WM_MDICASCADE)
1219         WIN_MSG(WM_MDIICONARRANGE)
1220         WIN_MSG(WM_MDIGETACTIVE)
1221         WIN_MSG(WM_MDISETMENU)
1222         WIN_MSG(WM_ENTERSIZEMOVE)
1223         WIN_MSG(WM_EXITSIZEMOVE)
1224         WIN_MSG(WM_DROPFILES)
1225         WIN_MSG(WM_MDIREFRESHMENU)
1226         WIN_MSG(WM_IME_SETCONTEXT)
1227         WIN_MSG(WM_IME_NOTIFY)
1228         WIN_MSG(WM_IME_CONTROL)
1229         WIN_MSG(WM_IME_COMPOSITIONFULL)
1230         WIN_MSG(WM_IME_SELECT)
1231         WIN_MSG(WM_IME_CHAR)
1232         FMT_MSG(WM_IME_REQUEST)
1233         WIN_MSG(WM_IME_KEYDOWN)
1234         WIN_MSG(WM_IME_KEYUP)
1235         FMT_MSG(0x02A1, "WM_MOUSEHOVER")
1236         FMT_MSG(0x02A3, "WM_MOUSELEAVE")
1237         WIN_MSG(WM_CUT)
1238         WIN_MSG(WM_COPY)
1239         WIN_MSG(WM_PASTE)
1240         WIN_MSG(WM_CLEAR)
1241         WIN_MSG(WM_UNDO)
1242         WIN_MSG(WM_RENDERFORMAT)
1243         WIN_MSG(WM_RENDERALLFORMATS)
1244         WIN_MSG(WM_DESTROYCLIPBOARD)
1245         WIN_MSG(WM_DRAWCLIPBOARD)
1246         WIN_MSG(WM_PAINTCLIPBOARD)
1247         WIN_MSG(WM_VSCROLLCLIPBOARD)
1248         WIN_MSG(WM_SIZECLIPBOARD)
1249         WIN_MSG(WM_ASKCBFORMATNAME)
1250         WIN_MSG(WM_CHANGECBCHAIN)
1251         WIN_MSG(WM_HSCROLLCLIPBOARD)
1252         WIN_MSG(WM_QUERYNEWPALETTE)
1253         WIN_MSG(WM_PALETTEISCHANGING)
1254         WIN_MSG(WM_PALETTECHANGED)
1255         WIN_MSG(WM_HOTKEY)
1256         WIN_MSG(WM_PRINT)
1257         WIN_MSG(WM_PRINTCLIENT)
1258         WIN_MSG(WM_HANDHELDFIRST)
1259         WIN_MSG(WM_HANDHELDLAST)
1260         WIN_MSG(WM_AFXFIRST)
1261         WIN_MSG(WM_AFXLAST)
1262         WIN_MSG(WM_PENWINFIRST)
1263         WIN_MSG(WM_PENWINLAST)
1264         WIN_MSG(WM_AWT_COMPONENT_CREATE)
1265         WIN_MSG(WM_AWT_DESTROY_WINDOW)
1266         WIN_MSG(WM_AWT_MOUSEENTER)
1267         WIN_MSG(WM_AWT_MOUSEEXIT)
1268         WIN_MSG(WM_AWT_COMPONENT_SHOW)
1269         WIN_MSG(WM_AWT_COMPONENT_HIDE)
1270         WIN_MSG(WM_AWT_COMPONENT_SETFOCUS)
1271         WIN_MSG(WM_AWT_WINDOW_SETACTIVE)
1272         WIN_MSG(WM_AWT_LIST_SETMULTISELECT)
1273         WIN_MSG(WM_AWT_HANDLE_EVENT)
1274         WIN_MSG(WM_AWT_PRINT_COMPONENT)
1275         WIN_MSG(WM_AWT_RESHAPE_COMPONENT)
1276         WIN_MSG(WM_AWT_SETALWAYSONTOP)
1277         WIN_MSG(WM_AWT_BEGIN_VALIDATE)
1278         WIN_MSG(WM_AWT_END_VALIDATE)
1279         WIN_MSG(WM_AWT_FORWARD_CHAR)
1280         WIN_MSG(WM_AWT_FORWARD_BYTE)
1281         WIN_MSG(WM_AWT_SET_SCROLL_INFO)
1282         WIN_MSG(WM_AWT_CREATECONTEXT)
1283         WIN_MSG(WM_AWT_DESTROYCONTEXT)
1284         WIN_MSG(WM_AWT_ASSOCIATECONTEXT)
1285         WIN_MSG(WM_AWT_GET_DEFAULT_IME_HANDLER)
1286         WIN_MSG(WM_AWT_HANDLE_NATIVE_IME_EVENT)
1287         WIN_MSG(WM_AWT_PRE_KEYDOWN)
1288         WIN_MSG(WM_AWT_PRE_KEYUP)
1289         WIN_MSG(WM_AWT_PRE_SYSKEYDOWN)
1290         WIN_MSG(WM_AWT_PRE_SYSKEYUP)
1291         WIN_MSG(WM_AWT_ENDCOMPOSITION,)
1292         WIN_MSG(WM_AWT_DISPOSE,)
1293         WIN_MSG(WM_AWT_DELETEOBJECT,)
1294         WIN_MSG(WM_AWT_SETCONVERSIONSTATUS,)
1295         WIN_MSG(WM_AWT_GETCONVERSIONSTATUS,)
1296         WIN_MSG(WM_AWT_SETOPENSTATUS,)
1297         WIN_MSG(WM_AWT_GETOPENSTATUS)
1298         WIN_MSG(WM_AWT_ACTIVATEKEYBOARDLAYOUT)
1299         WIN_MSG(WM_AWT_OPENCANDIDATEWINDOW)
1300         WIN_MSG(WM_AWT_DLG_SHOWMODAL,)
1301         WIN_MSG(WM_AWT_DLG_ENDMODAL,)
1302         WIN_MSG(WM_AWT_SETCURSOR,)
1303         WIN_MSG(WM_AWT_WAIT_FOR_SINGLE_OBJECT,)
1304         WIN_MSG(WM_AWT_INVOKE_METHOD,)
1305         WIN_MSG(WM_AWT_INVOKE_VOID_METHOD,)
1306         WIN_MSG(WM_AWT_EXECUTE_SYNC,)
1307         WIN_MSG(WM_AWT_CURSOR_SYNC)
1308         WIN_MSG(WM_AWT_GETDC)
1309         WIN_MSG(WM_AWT_RELEASEDC)
1310         WIN_MSG(WM_AWT_RELEASE_ALL_DCS)
1311         WIN_MSG(WM_AWT_SHOWCURSOR)
1312         WIN_MSG(WM_AWT_HIDECURSOR)
1313         WIN_MSG(WM_AWT_CREATE_PRINTED_PIXELS)
1314         WIN_MSG(WM_AWT_OBJECTLISTCLEANUP)
1315         default:
1316             sprintf(szBuf, "0x%8.8x(%s):Unknown message 0x%8.8x\n",
1317                 hwnd, szComment, message);
1318             break;
1319     }
1320     printf(szBuf);
1321 }
1322 
1323 #endif /* SPY_MESSAGES */
1324 
1325 /*
1326  * Dispatch messages for this window class--general component
1327  */
1328 LRESULT AwtComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
1329 {
1330     CounterHelper ch(&m_MessagesProcessing);
1331 
1332     JNILocalFrame lframe(AwtToolkit::GetEnv(), 10);
1333     SpyWinMessage(GetHWnd(), message,
1334         (message == WM_AWT_RELEASE_ALL_DCS) ? TEXT("Disposed Component") : GetClassName());
1335 
1336     LRESULT retValue = 0;
1337     MsgRouting mr = mrDoDefault;
1338     AwtToolkit::GetInstance().eventNumber++;
1339 
1340     static BOOL ignoreNextLBTNUP = FALSE; //Ignore next LBUTTONUP msg?
1341 
1342     lastMessage = message;
1343 
1344     if (message == WmAwtIsComponent) {
1345     // special message to identify AWT HWND's without using
1346     // resource hogging ::SetProp
1347         return (LRESULT)TRUE;
1348     }
1349 
1350     DWORD curPos = 0;
1351 
1352     UINT switchMessage = message;
1353     switch (switchMessage) {
1354       case WM_AWT_GETDC:
1355       {
1356             HDC hDC;
1357             // First, release the DCs scheduled for deletion
1358             ReleaseDCList(GetHWnd(), passiveDCList);
1359 
1360             GetDCReturnStruct *returnStruct = new GetDCReturnStruct;
1361             returnStruct->gdiLimitReached = FALSE;
1362             if (AwtGDIObject::IncrementIfAvailable()) {
1363                 hDC = ::GetDCEx(GetHWnd(), NULL,
1364                                 DCX_CACHE | DCX_CLIPCHILDREN |
1365                                 DCX_CLIPSIBLINGS);
1366                 if (hDC != NULL) {
1367                     // Add new DC to list of DC's associated with this Component
1368                     activeDCList.AddDC(hDC, GetHWnd());
1369                 } else {
1370                     // Creation failed; decrement counter in AwtGDIObject
1371                     AwtGDIObject::Decrement();
1372                 }
1373             } else {
1374                 hDC = NULL;
1375                 returnStruct->gdiLimitReached = TRUE;
1376             }
1377             returnStruct->hDC = hDC;
1378             retValue = (LRESULT)returnStruct;
1379             mr = mrConsume;
1380             break;
1381       }
1382       case WM_AWT_RELEASEDC:
1383       {
1384             HDC hDC = (HDC)wParam;
1385             MoveDCToPassiveList(hDC);
1386             ReleaseDCList(GetHWnd(), passiveDCList);
1387             mr = mrConsume;
1388             break;
1389       }
1390       case WM_AWT_RELEASE_ALL_DCS:
1391       {
1392             // Called during Component destruction.  Gets current list of
1393             // DC's associated with Component and releases each DC.
1394             ReleaseDCList(GetHWnd(), activeDCList);
1395             ReleaseDCList(GetHWnd(), passiveDCList);
1396             mr = mrConsume;
1397             break;
1398       }
1399       case WM_AWT_SHOWCURSOR:
1400           ::ShowCursor(TRUE);
1401           break;
1402       case WM_AWT_HIDECURSOR:
1403           ::ShowCursor(FALSE);
1404           break;
1405       case WM_CREATE: mr = WmCreate(); break;
1406       case WM_CLOSE:      mr = WmClose(); break;
1407       case WM_DESTROY:    mr = WmDestroy(); break;
1408       case WM_NCDESTROY:  mr = WmNcDestroy(); break;
1409 
1410       case WM_ERASEBKGND:
1411           mr = WmEraseBkgnd((HDC)wParam, *(BOOL*)&retValue); break;
1412       case WM_PAINT:
1413           CheckFontSmoothingSettings(GetHWnd());
1414           /* Set draw state */
1415           SetDrawState(GetDrawState() | JAWT_LOCK_CLIP_CHANGED);
1416           mr = WmPaint((HDC)wParam);
1417           break;
1418 
1419       case WM_GETMINMAXINFO:
1420           mr = WmGetMinMaxInfo((LPMINMAXINFO)lParam);
1421           break;
1422 
1423       case WM_WINDOWPOSCHANGING:
1424       {
1425           // We process this message so that we can synchronize access to
1426           // a moving window.  The Scale/Blt functions in Win32BlitLoops
1427           // take the same windowMoveLock to ensure that a window is not
1428           // moving while we are trying to copy pixels into it.
1429           WINDOWPOS *lpPosInfo = (WINDOWPOS *)lParam;
1430           if ((lpPosInfo->flags & (SWP_NOMOVE | SWP_NOSIZE)) !=
1431               (SWP_NOMOVE | SWP_NOSIZE))
1432           {
1433               // Move or Size command.
1434               // Windows tends to send erroneous events that the window
1435               // is about to move when the coordinates are exactly the
1436               // same as the last time.  This can cause problems with
1437               // our windowMoveLock CriticalSection because we enter it
1438               // here and never get to WM_WINDOWPOSCHANGED to release it.
1439               // So make sure this is a real move/size event before bothering
1440               // to grab the critical section.
1441               BOOL takeLock = FALSE;
1442               if (!(lpPosInfo->flags & SWP_NOMOVE) &&
1443                   ((windowMoveLockPosX != lpPosInfo->x) ||
1444                    (windowMoveLockPosY != lpPosInfo->y)))
1445               {
1446                   // Real move event
1447                   takeLock = TRUE;
1448                   windowMoveLockPosX = lpPosInfo->x;
1449                   windowMoveLockPosY = lpPosInfo->y;
1450               }
1451               if (!(lpPosInfo->flags & SWP_NOSIZE) &&
1452                   ((windowMoveLockPosCX != lpPosInfo->cx) ||
1453                    (windowMoveLockPosCY != lpPosInfo->cy)))
1454               {
1455                   // Real size event
1456                   takeLock = TRUE;
1457                   windowMoveLockPosCX = lpPosInfo->cx;
1458                   windowMoveLockPosCY = lpPosInfo->cy;
1459               }
1460               if (takeLock) {
1461                   if (!windowMoveLockHeld) {
1462                       windowMoveLock.Enter();
1463                       windowMoveLockHeld = TRUE;
1464                   }
1465               }
1466           }
1467           mr = WmWindowPosChanging(lParam);
1468           break;
1469       }
1470       case WM_WINDOWPOSCHANGED:
1471       {
1472           // Release lock grabbed in the POSCHANGING message
1473           if (windowMoveLockHeld) {
1474               windowMoveLockHeld = FALSE;
1475               windowMoveLock.Leave();
1476           }
1477           mr = WmWindowPosChanged(lParam);
1478           break;
1479       }
1480       case WM_MOVE: {
1481           RECT r;
1482           ::GetWindowRect(GetHWnd(), &r);
1483           mr = WmMove(r.left, r.top);
1484           break;
1485       }
1486       case WM_SIZE:
1487       {
1488           RECT r;
1489           // fix 4128317 : use GetClientRect for full 32-bit int precision and
1490           // to avoid negative client area dimensions overflowing 16-bit params - robi
1491           ::GetClientRect( GetHWnd(), &r );
1492           mr = WmSize(static_cast<UINT>(wParam), r.right - r.left, r.bottom - r.top);
1493           //mr = WmSize(wParam, LOWORD(lParam), HIWORD(lParam));
1494           SetCompositionWindow(r);
1495           break;
1496       }
1497       case WM_SIZING:
1498           mr = WmSizing();
1499           break;
1500       case WM_SHOWWINDOW:
1501           mr = WmShowWindow(static_cast<BOOL>(wParam),
1502                             static_cast<UINT>(lParam)); break;
1503       case WM_SYSCOMMAND:
1504           mr = WmSysCommand(static_cast<UINT>(wParam & 0xFFF0),
1505                             GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
1506           break;
1507       case WM_EXITSIZEMOVE:
1508           mr = WmExitSizeMove();
1509           break;
1510       // Bug #4039858 (Selecting menu item causes bogus mouse click event)
1511       case WM_ENTERMENULOOP:
1512           mr = WmEnterMenuLoop((BOOL)wParam);
1513           sm_bMenuLoop = TRUE;
1514           // we need to release grab if menu is shown
1515           if (AwtWindow::GetGrabbedWindow() != NULL) {
1516               AwtWindow::GetGrabbedWindow()->Ungrab();
1517           }
1518           break;
1519       case WM_EXITMENULOOP:
1520           mr = WmExitMenuLoop((BOOL)wParam);
1521           sm_bMenuLoop = FALSE;
1522           break;
1523 
1524       // We don't expect any focus messages on non-proxy component,
1525       // except those that came from Java.
1526       case WM_SETFOCUS:
1527           if (sm_inSynthesizeFocus) {
1528               mr = WmSetFocus((HWND)wParam);
1529           } else {
1530               mr = mrConsume;
1531           }
1532           break;
1533       case WM_KILLFOCUS:
1534           if (sm_inSynthesizeFocus) {
1535               mr = WmKillFocus((HWND)wParam);
1536           } else {
1537               mr = mrConsume;
1538           }
1539           break;
1540       case WM_ACTIVATE: {
1541           UINT nState = LOWORD(wParam);
1542           BOOL fMinimized = (BOOL)HIWORD(wParam);
1543           mr = mrConsume;
1544 
1545           if (!sm_suppressFocusAndActivation &&
1546               (!fMinimized || (nState == WA_INACTIVE)))
1547           {
1548               mr = WmActivate(nState, fMinimized, (HWND)lParam);
1549 
1550               // When the window is deactivated, send WM_IME_ENDCOMPOSITION
1551               // message to deactivate the composition window so that
1552               // it won't receive keyboard input focus.
1553               HIMC hIMC;
1554               HWND hwnd = ImmGetHWnd();
1555               if ((hIMC = ImmGetContext(hwnd)) != NULL) {
1556                   ImmReleaseContext(hwnd, hIMC);
1557                   DefWindowProc(WM_IME_ENDCOMPOSITION, 0, 0);
1558               }
1559           }
1560           break;
1561       }
1562       case WM_MOUSEACTIVATE: {
1563           AwtWindow *window = GetContainer();
1564           if (window && window->IsFocusableWindow()) {
1565               // AWT/Swing will later request focus to a proper component
1566               // on handling the Java mouse event. Anyway, we have to
1567               // activate the window here as it works both for AWT & Swing.
1568               // Do it in our own fassion,
1569               window->AwtSetActiveWindow(TRUE, LOWORD(lParam)/*hittest*/);
1570           }
1571           mr = mrConsume;
1572           retValue = MA_NOACTIVATE;
1573           break;
1574       }
1575       case WM_CTLCOLORMSGBOX:
1576       case WM_CTLCOLOREDIT:
1577       case WM_CTLCOLORLISTBOX:
1578       case WM_CTLCOLORBTN:
1579       case WM_CTLCOLORDLG:
1580       case WM_CTLCOLORSCROLLBAR:
1581       case WM_CTLCOLORSTATIC:
1582           mr = WmCtlColor((HDC)wParam, (HWND)lParam,
1583                           message-WM_CTLCOLORMSGBOX+CTLCOLOR_MSGBOX,
1584                           *(HBRUSH*)&retValue);
1585           break;
1586       case WM_HSCROLL:
1587           mr = WmHScroll(LOWORD(wParam), HIWORD(wParam), (HWND)lParam);
1588           break;
1589       case WM_VSCROLL:
1590           mr = WmVScroll(LOWORD(wParam), HIWORD(wParam), (HWND)lParam);
1591           break;
1592       // 4664415: We're seeing a WM_LBUTTONUP when the user releases the
1593       // mouse button after a WM_NCLBUTTONDBLCLK.  We want to ignore this
1594       // WM_LBUTTONUP, so we set a flag in WM_NCLBUTTONDBLCLK and look for the
1595       // flag on a WM_LBUTTONUP.  -bchristi
1596       case WM_NCLBUTTONDBLCLK:
1597           mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON | DBL_CLICK);
1598           if (mr == mrDoDefault) {
1599               ignoreNextLBTNUP = TRUE;
1600           }
1601           break;
1602       case WM_NCLBUTTONDOWN:
1603           mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON);
1604           ignoreNextLBTNUP = FALSE;
1605           break;
1606       case WM_NCLBUTTONUP:
1607           mr = WmNcMouseUp(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON);
1608           break;
1609       case WM_NCRBUTTONDOWN:
1610            mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), RIGHT_BUTTON);
1611            break;
1612       case WM_LBUTTONUP:
1613           if (ignoreNextLBTNUP) {
1614               ignoreNextLBTNUP = FALSE;
1615               return mrDoDefault;
1616           }
1617           //fall-through
1618       case WM_LBUTTONDOWN:
1619           ignoreNextLBTNUP = FALSE;
1620           //fall-through
1621       case WM_LBUTTONDBLCLK:
1622       case WM_RBUTTONDOWN:
1623       case WM_RBUTTONDBLCLK:
1624       case WM_RBUTTONUP:
1625       case WM_MBUTTONDOWN:
1626       case WM_MBUTTONDBLCLK:
1627       case WM_MBUTTONUP:
1628       case WM_XBUTTONDBLCLK:
1629       case WM_XBUTTONDOWN:
1630       case WM_XBUTTONUP:
1631       case WM_MOUSEMOVE:
1632       case WM_MOUSEWHEEL:
1633       case WM_AWT_MOUSEENTER:
1634       case WM_AWT_MOUSEEXIT:
1635           curPos = ::GetMessagePos();
1636           POINT myPos;
1637           myPos.x = GET_X_LPARAM(curPos);
1638           myPos.y = GET_Y_LPARAM(curPos);
1639           ::ScreenToClient(GetHWnd(), &myPos);
1640           switch(switchMessage) {
1641           case WM_AWT_MOUSEENTER:
1642               mr = WmMouseEnter(static_cast<UINT>(wParam), myPos.x, myPos.y);
1643               break;
1644           case WM_LBUTTONDOWN:
1645           case WM_LBUTTONDBLCLK:
1646               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1647                                LEFT_BUTTON);
1648               break;
1649           case WM_LBUTTONUP:
1650               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1651                              LEFT_BUTTON);
1652               break;
1653           case WM_MOUSEMOVE:
1654               mr = WmMouseMove(static_cast<UINT>(wParam), myPos.x, myPos.y);
1655               break;
1656           case WM_MBUTTONDOWN:
1657           case WM_MBUTTONDBLCLK:
1658               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1659                                MIDDLE_BUTTON);
1660               break;
1661           case WM_XBUTTONDOWN:
1662           case WM_XBUTTONDBLCLK:
1663               if (AwtToolkit::GetInstance().areExtraMouseButtonsEnabled()) {
1664                   if (HIWORD(wParam) == 1) {
1665                       mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1666                                        X1_BUTTON);
1667                   }
1668                   if (HIWORD(wParam) == 2) {
1669                       mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1670                                        X2_BUTTON);
1671                   }
1672               }
1673               break;
1674           case WM_XBUTTONUP:
1675               if (AwtToolkit::GetInstance().areExtraMouseButtonsEnabled()) {
1676                   if (HIWORD(wParam) == 1) {
1677                       mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1678                                      X1_BUTTON);
1679                   }
1680                   if (HIWORD(wParam) == 2) {
1681                       mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1682                                      X2_BUTTON);
1683                   }
1684               }
1685               break;
1686           case WM_RBUTTONDOWN:
1687           case WM_RBUTTONDBLCLK:
1688               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1689                                RIGHT_BUTTON);
1690               break;
1691           case WM_RBUTTONUP:
1692               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1693                              RIGHT_BUTTON);
1694               break;
1695           case WM_MBUTTONUP:
1696               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1697                              MIDDLE_BUTTON);
1698               break;
1699           case WM_AWT_MOUSEEXIT:
1700               mr = WmMouseExit(static_cast<UINT>(wParam), myPos.x, myPos.y);
1701               break;
1702           case  WM_MOUSEWHEEL:
1703               mr = WmMouseWheel(GET_KEYSTATE_WPARAM(wParam),
1704                                 GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
1705                                 GET_WHEEL_DELTA_WPARAM(wParam));
1706               break;
1707           }
1708           break;
1709       case WM_SETCURSOR:
1710           mr = mrDoDefault;
1711           if (LOWORD(lParam) == HTCLIENT) {
1712               if (AwtComponent* comp =
1713                                     AwtComponent::GetComponent((HWND)wParam)) {
1714                   AwtCursor::UpdateCursor(comp);
1715                   mr = mrConsume;
1716               }
1717           }
1718           break;
1719 
1720       case WM_KEYDOWN:
1721           mr = WmKeyDown(static_cast<UINT>(wParam),
1722                          LOWORD(lParam), HIWORD(lParam), FALSE);
1723           break;
1724       case WM_KEYUP:
1725           mr = WmKeyUp(static_cast<UINT>(wParam),
1726                        LOWORD(lParam), HIWORD(lParam), FALSE);
1727           break;
1728       case WM_SYSKEYDOWN:
1729           mr = WmKeyDown(static_cast<UINT>(wParam),
1730                          LOWORD(lParam), HIWORD(lParam), TRUE);
1731           break;
1732       case WM_SYSKEYUP:
1733           mr = WmKeyUp(static_cast<UINT>(wParam),
1734                        LOWORD(lParam), HIWORD(lParam), TRUE);
1735           break;
1736       case WM_IME_SETCONTEXT:
1737           // lParam is passed as pointer and it can be modified.
1738           mr = WmImeSetContext(static_cast<BOOL>(wParam), &lParam);
1739           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1740           break;
1741       case WM_IME_NOTIFY:
1742           mr = WmImeNotify(wParam, lParam);
1743           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1744           break;
1745       case WM_IME_STARTCOMPOSITION:
1746           mr = WmImeStartComposition();
1747           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1748           break;
1749       case WM_IME_ENDCOMPOSITION:
1750           mr = WmImeEndComposition();
1751           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1752           break;
1753       case WM_IME_COMPOSITION: {
1754           WORD dbcschar = static_cast<WORD>(wParam);
1755           mr = WmImeComposition(dbcschar, lParam);
1756           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1757           break;
1758       }
1759       case WM_IME_CONTROL:
1760       case WM_IME_COMPOSITIONFULL:
1761       case WM_IME_SELECT:
1762       case WM_IME_KEYUP:
1763       case WM_IME_KEYDOWN:
1764       case WM_IME_REQUEST:
1765           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1766           break;
1767       case WM_CHAR:
1768           mr = WmChar(static_cast<UINT>(wParam),
1769                       LOWORD(lParam), HIWORD(lParam), FALSE);
1770           break;
1771       case WM_SYSCHAR:
1772           mr = WmChar(static_cast<UINT>(wParam),
1773                       LOWORD(lParam), HIWORD(lParam), TRUE);
1774           break;
1775       case WM_IME_CHAR:
1776           mr = WmIMEChar(static_cast<UINT>(wParam),
1777                          LOWORD(lParam), HIWORD(lParam), FALSE);
1778           break;
1779 
1780       case WM_INPUTLANGCHANGEREQUEST: {
1781           DTRACE_PRINTLN4("WM_INPUTLANGCHANGEREQUEST: hwnd = 0x%X (%s);"//
1782                           "0x%08X -> 0x%08X",
1783                           GetHWnd(), GetClassName(),
1784                           (UINT_PTR)GetKeyboardLayout(), (UINT_PTR)lParam);
1785           // 4267428: make sure keyboard layout is turned undead.
1786           static BYTE keyboardState[AwtToolkit::KB_STATE_SIZE];
1787           AwtToolkit::GetKeyboardState(keyboardState);
1788           WORD ignored;
1789           ::ToAsciiEx(VK_SPACE, ::MapVirtualKey(VK_SPACE, 0),
1790                       keyboardState, &ignored, 0, GetKeyboardLayout());
1791 
1792           // Set this flag to block ActivateKeyboardLayout from
1793           // WInputMethod.activate()
1794           g_bUserHasChangedInputLang = TRUE;
1795           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1796           break;
1797       }
1798       case WM_INPUTLANGCHANGE:
1799           DTRACE_PRINTLN3("WM_INPUTLANGCHANGE: hwnd = 0x%X (%s);"//
1800                           "new = 0x%08X",
1801                           GetHWnd(), GetClassName(), (UINT)lParam);
1802           mr = WmInputLangChange(static_cast<UINT>(wParam), reinterpret_cast<HKL>(lParam));
1803           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1804           // should return non-zero if we process this message
1805           retValue = 1;
1806           break;
1807 
1808       case WM_AWT_FORWARD_CHAR:
1809           mr = WmForwardChar(LOWORD(wParam), lParam, HIWORD(wParam));
1810           break;
1811 
1812       case WM_AWT_FORWARD_BYTE:
1813           mr = HandleEvent( (MSG *) lParam, (BOOL) wParam);
1814           break;
1815 
1816       case WM_PASTE:
1817           mr = WmPaste();
1818           break;
1819       case WM_TIMER:
1820           mr = WmTimer(wParam);
1821           break;
1822 
1823       case WM_COMMAND:
1824           mr = WmCommand(LOWORD(wParam), (HWND)lParam, HIWORD(wParam));
1825           break;
1826       case WM_COMPAREITEM:
1827           mr = WmCompareItem(static_cast<UINT>(wParam),
1828                              *(COMPAREITEMSTRUCT*)lParam, retValue);
1829           break;
1830       case WM_DELETEITEM:
1831           mr = WmDeleteItem(static_cast<UINT>(wParam),
1832                             *(DELETEITEMSTRUCT*)lParam);
1833           break;
1834       case WM_DRAWITEM:
1835           mr = WmDrawItem(static_cast<UINT>(wParam),
1836                           *(DRAWITEMSTRUCT*)lParam);
1837           break;
1838       case WM_MEASUREITEM:
1839           mr = WmMeasureItem(static_cast<UINT>(wParam),
1840                              *(MEASUREITEMSTRUCT*)lParam);
1841           break;
1842 
1843       case WM_AWT_HANDLE_EVENT:
1844           mr = HandleEvent( (MSG *) lParam, (BOOL) wParam);
1845           break;
1846 
1847       case WM_PRINT:
1848           mr = WmPrint((HDC)wParam, lParam);
1849           break;
1850       case WM_PRINTCLIENT:
1851           mr = WmPrintClient((HDC)wParam, lParam);
1852           break;
1853 
1854       case WM_NCCALCSIZE:
1855           mr = WmNcCalcSize((BOOL)wParam, (LPNCCALCSIZE_PARAMS)lParam,
1856                             retValue);
1857           break;
1858       case WM_NCPAINT:
1859           mr = WmNcPaint((HRGN)wParam);
1860           break;
1861       case WM_NCHITTEST:
1862           mr = WmNcHitTest(LOWORD(lParam), HIWORD(lParam), retValue);
1863           break;
1864 
1865       case WM_AWT_RESHAPE_COMPONENT: {
1866           RECT* r = (RECT*)lParam;
1867           WPARAM checkEmbedded = wParam;
1868           if (checkEmbedded == CHECK_EMBEDDED && IsEmbeddedFrame()) {
1869               ::OffsetRect(r, -r->left, -r->top);
1870           }
1871           Reshape(r->left, r->top, r->right - r->left, r->bottom - r->top);
1872           delete r;
1873           mr = mrConsume;
1874           break;
1875       }
1876 
1877       case WM_AWT_SETALWAYSONTOP: {
1878         AwtWindow* w = (AwtWindow*)lParam;
1879         BOOL value = (BOOL)wParam;
1880         UINT flags = SWP_NOMOVE | SWP_NOSIZE;
1881         // transient windows shouldn't change the owner window's position in the z-order
1882         if (w->IsRetainingHierarchyZOrder()) {
1883             flags |= SWP_NOOWNERZORDER;
1884         }
1885         ::SetWindowPos(w->GetHWnd(), (value != 0 ? HWND_TOPMOST : HWND_NOTOPMOST),
1886                        0,0,0,0, flags);
1887         break;
1888       }
1889 
1890       case WM_AWT_BEGIN_VALIDATE:
1891           BeginValidate();
1892           mr = mrConsume;
1893           break;
1894       case WM_AWT_END_VALIDATE:
1895           EndValidate();
1896           mr = mrConsume;
1897           break;
1898 
1899       case WM_PALETTEISCHANGING:
1900           mr = WmPaletteIsChanging((HWND)wParam);
1901           mr = mrDoDefault;
1902           break;
1903       case WM_QUERYNEWPALETTE:
1904           mr = WmQueryNewPalette(retValue);
1905           break;
1906       case WM_PALETTECHANGED:
1907           mr = WmPaletteChanged((HWND)wParam);
1908           break;
1909       case WM_STYLECHANGED:
1910           mr = WmStyleChanged(static_cast<int>(wParam), (LPSTYLESTRUCT)lParam);
1911           break;
1912       case WM_SETTINGCHANGE:
1913           CheckFontSmoothingSettings(NULL);
1914           mr = WmSettingChange(static_cast<UINT>(wParam), (LPCTSTR)lParam);
1915           break;
1916       case WM_CONTEXTMENU:
1917           mr = WmContextMenu((HWND)wParam,
1918                              GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
1919           break;
1920 
1921           /*
1922            * These messages are used to route Win32 calls to the
1923            * creating thread, since these calls fail unless executed
1924            * there.
1925            */
1926       case WM_AWT_COMPONENT_SHOW:
1927           Show();
1928           mr = mrConsume;
1929           break;
1930       case WM_AWT_COMPONENT_HIDE:
1931           Hide();
1932           mr = mrConsume;
1933           break;
1934 
1935       case WM_AWT_COMPONENT_SETFOCUS:
1936           if ((BOOL)wParam) {
1937               retValue = SynthesizeWmSetFocus(GetHWnd(), NULL);
1938           } else {
1939               retValue = SynthesizeWmKillFocus(GetHWnd(), NULL);
1940           }
1941           mr = mrConsume;
1942           break;
1943       case WM_AWT_WINDOW_SETACTIVE:
1944           retValue = (LRESULT)((AwtWindow*)this)->AwtSetActiveWindow((BOOL)wParam);
1945           mr = mrConsume;
1946           break;
1947 
1948       case WM_AWT_SET_SCROLL_INFO: {
1949           SCROLLINFO *si = (SCROLLINFO *) lParam;
1950           ::SetScrollInfo(GetHWnd(), (int) wParam, si, TRUE);
1951           delete si;
1952           mr = mrConsume;
1953           break;
1954       }
1955       case WM_AWT_CREATE_PRINTED_PIXELS: {
1956           CreatePrintedPixelsStruct* cpps = (CreatePrintedPixelsStruct*)wParam;
1957           SIZE loc = { cpps->srcx, cpps->srcy };
1958           SIZE size = { cpps->srcw, cpps->srch };
1959           retValue = (LRESULT)CreatePrintedPixels(loc, size, cpps->alpha);
1960           mr = mrConsume;
1961           break;
1962       }
1963       case WM_UNDOCUMENTED_CLICKMENUBAR:
1964       {
1965           if (::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()))) {
1966               mr = mrConsume;
1967           }
1968       }
1969     }
1970 
1971     /*
1972      * If not a specific Consume, it was a specific DoDefault, or a
1973      * PassAlong (since the default is the next in chain), then call the
1974      * default proc.
1975      */
1976     if (mr != mrConsume) {
1977         retValue = DefWindowProc(message, wParam, lParam);
1978     }
1979 
1980     return retValue;
1981 }
1982 /*
1983  * Call this instance's default window proc, or if none set, call the stock
1984  * Window's one.
1985  */
1986 LRESULT AwtComponent::DefWindowProc(UINT msg, WPARAM wParam, LPARAM lParam)
1987 {
1988     return ComCtl32Util::GetInstance().DefWindowProc(m_DefWindowProc, GetHWnd(), msg, wParam, lParam);
1989 }
1990 
1991 /*
1992  * This message should only be received when a window is destroyed by
1993  * Windows, and not Java.  Window termination has been reworked so
1994  * this method should never be called during termination.
1995  */
1996 MsgRouting AwtComponent::WmDestroy()
1997 {
1998     return mrConsume;
1999 }
2000 
2001 /*
2002  * This message should only be received when a window is destroyed by
2003  * Windows, and not Java. It is sent only after child windows were destroyed.
2004  */
2005 MsgRouting AwtComponent::WmNcDestroy()
2006 {
2007     if (m_peerObject != NULL) { // is not being terminating
2008         // Stay in this handler until AwtComponent::Dispose is called.
2009         m_bPauseDestroy = TRUE;
2010 
2011         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2012         // Post invocation event for WObjectPeer.dispose to EDT
2013         env->CallVoidMethod(m_peerObject, AwtComponent::disposeLaterMID);
2014         // Wait until AwtComponent::Dispose is called
2015         AwtToolkit::GetInstance().PumpToDestroy(this);
2016     }
2017 
2018     return mrConsume;
2019 }
2020 
2021 MsgRouting AwtComponent::WmGetMinMaxInfo(LPMINMAXINFO lpmmi)
2022 {
2023     return mrDoDefault;
2024 }
2025 
2026 MsgRouting AwtComponent::WmMove(int x, int y)
2027 {
2028     SetDrawState(GetDrawState() | static_cast<jint>(JAWT_LOCK_BOUNDS_CHANGED)
2029         | static_cast<jint>(JAWT_LOCK_CLIP_CHANGED));
2030     return mrDoDefault;
2031 }
2032 
2033 MsgRouting AwtComponent::WmSize(UINT type, int w, int h)
2034 {
2035     SetDrawState(GetDrawState() | static_cast<jint>(JAWT_LOCK_BOUNDS_CHANGED)
2036         | static_cast<jint>(JAWT_LOCK_CLIP_CHANGED));
2037     return mrDoDefault;
2038 }
2039 
2040 MsgRouting AwtComponent::WmSizing()
2041 {
2042     return mrDoDefault;
2043 }
2044 
2045 MsgRouting AwtComponent::WmSysCommand(UINT uCmdType, int xPos, int yPos)
2046 {
2047     return mrDoDefault;
2048 }
2049 
2050 MsgRouting AwtComponent::WmExitSizeMove()
2051 {
2052     return mrDoDefault;
2053 }
2054 
2055 MsgRouting AwtComponent::WmEnterMenuLoop(BOOL isTrackPopupMenu)
2056 {
2057     return mrDoDefault;
2058 }
2059 
2060 MsgRouting AwtComponent::WmExitMenuLoop(BOOL isTrackPopupMenu)
2061 {
2062     return mrDoDefault;
2063 }
2064 
2065 MsgRouting AwtComponent::WmShowWindow(BOOL show, UINT status)
2066 {
2067     return mrDoDefault;
2068 }
2069 
2070 MsgRouting AwtComponent::WmSetFocus(HWND hWndLostFocus)
2071 {
2072     m_wheelRotationAmount = 0;
2073     return mrDoDefault;
2074 }
2075 
2076 MsgRouting AwtComponent::WmKillFocus(HWND hWndGotFocus)
2077 {
2078     m_wheelRotationAmount = 0;
2079     return mrDoDefault;
2080 }
2081 
2082 MsgRouting AwtComponent::WmCtlColor(HDC hDC, HWND hCtrl,
2083                                     UINT ctlColor, HBRUSH& retBrush)
2084 {
2085     AwtComponent* child = AwtComponent::GetComponent(hCtrl);
2086     if (child) {
2087         ::SetBkColor(hDC, child->GetBackgroundColor());
2088         ::SetTextColor(hDC, child->GetColor());
2089         retBrush = child->GetBackgroundBrush();
2090         return mrConsume;
2091     }
2092     return mrDoDefault;
2093 /*
2094     switch (ctlColor) {
2095         case CTLCOLOR_MSGBOX:
2096         case CTLCOLOR_EDIT:
2097         case CTLCOLOR_LISTBOX:
2098         case CTLCOLOR_BTN:
2099         case CTLCOLOR_DLG:
2100         case CTLCOLOR_SCROLLBAR:
2101         case CTLCOLOR_STATIC:
2102     }
2103 */
2104 }
2105 
2106 MsgRouting AwtComponent::WmHScroll(UINT scrollCode, UINT pos,
2107                                    HWND hScrollbar) {
2108     if (hScrollbar && hScrollbar != GetHWnd()) {
2109         /* the last test should never happen */
2110         AwtComponent* sb = GetComponent(hScrollbar);
2111         if (sb) {
2112             sb->WmHScroll(scrollCode, pos, hScrollbar);
2113         }
2114     }
2115     return mrDoDefault;
2116 }
2117 
2118 MsgRouting AwtComponent::WmVScroll(UINT scrollCode, UINT pos, HWND hScrollbar)
2119 {
2120     if (hScrollbar && hScrollbar != GetHWnd()) {
2121         /* the last test should never happen */
2122         AwtComponent* sb = GetComponent(hScrollbar);
2123         if (sb) {
2124             sb->WmVScroll(scrollCode, pos, hScrollbar);
2125         }
2126     }
2127     return mrDoDefault;
2128 }
2129 
2130 
2131 MsgRouting AwtComponent::WmPaint(HDC)
2132 {
2133     /* Get the rectangle that covers all update regions, if any exist. */
2134     RECT r;
2135     if (::GetUpdateRect(GetHWnd(), &r, FALSE)) {
2136         if ((r.right-r.left) > 0 && (r.bottom-r.top) > 0 &&
2137             m_peerObject != NULL && m_callbacksEnabled) {
2138             /*
2139              * Always call handlePaint, because the underlying control
2140              * will have painted itself (the "background") before any
2141              * paint method is called.
2142              */
2143             DoCallback("handlePaint", "(IIII)V",
2144                        r.left, r.top, r.right-r.left, r.bottom-r.top);
2145         }
2146     }
2147     return mrDoDefault;
2148 }
2149 
2150 void AwtComponent::PaintUpdateRgn(const RECT *insets)
2151 {
2152     // Fix 4530093: Don't Validate if can't actually paint
2153     if (m_peerObject == NULL || !m_callbacksEnabled) {
2154 
2155         // Fix 4745222: If we don't ValidateRgn,  windows will keep sending
2156         // WM_PAINT messages until we do. This causes java to go into
2157         // a tight loop that increases CPU to 100% and starves main
2158         // thread which needs to complete initialization, but cant.
2159         ::ValidateRgn(GetHWnd(), NULL);
2160 
2161         return;
2162     }
2163 
2164     HRGN rgn = ::CreateRectRgn(0,0,1,1);
2165     int updated = ::GetUpdateRgn(GetHWnd(), rgn, FALSE);
2166     /*
2167      * Now remove all update regions from this window -- do it
2168      * here instead of after the Java upcall, in case any new
2169      * updating is requested.
2170      */
2171     ::ValidateRgn(GetHWnd(), NULL);
2172 
2173     if (updated == COMPLEXREGION || updated == SIMPLEREGION) {
2174         if (insets != NULL) {
2175             ::OffsetRgn(rgn, insets->left, insets->top);
2176         }
2177         DWORD size = ::GetRegionData(rgn, 0, NULL);
2178         if (size == 0) {
2179             ::DeleteObject((HGDIOBJ)rgn);
2180             return;
2181         }
2182         char* buffer = new char[size]; // safe because sizeof(char)==1
2183         memset(buffer, 0, size);
2184         LPRGNDATA rgndata = (LPRGNDATA)buffer;
2185         rgndata->rdh.dwSize = sizeof(RGNDATAHEADER);
2186         rgndata->rdh.iType = RDH_RECTANGLES;
2187         int retCode = ::GetRegionData(rgn, size, rgndata);
2188         VERIFY(retCode);
2189         if (retCode == 0) {
2190             delete [] buffer;
2191             ::DeleteObject((HGDIOBJ)rgn);
2192             return;
2193         }
2194         /*
2195          * Updating rects are divided into mostly vertical and mostly horizontal
2196          * Each group is united together and if not empty painted separately
2197          */
2198         RECT* r = (RECT*)(buffer + rgndata->rdh.dwSize);
2199         RECT* un[2] = {0, 0};
2200     DWORD i;
2201     for (i = 0; i < rgndata->rdh.nCount; i++, r++) {
2202             int width = r->right-r->left;
2203             int height = r->bottom-r->top;
2204             if (width > 0 && height > 0) {
2205                 int toAdd = (width > height) ? 0: 1;
2206                 if (un[toAdd] != 0) {
2207                     ::UnionRect(un[toAdd], un[toAdd], r);
2208                 } else {
2209                     un[toAdd] = r;
2210                 }
2211             }
2212         }
2213         for(i = 0; i < 2; i++) {
2214             if (un[i] != 0) {
2215                 DoCallback("handleExpose", "(IIII)V", un[i]->left, un[i]->top,
2216                     un[i]->right-un[i]->left, un[i]->bottom-un[i]->top);
2217             }
2218         }
2219         delete [] buffer;
2220     }
2221     ::DeleteObject((HGDIOBJ)rgn);
2222 }
2223 
2224 MsgRouting AwtComponent::WmMouseEnter(UINT flags, int x, int y)
2225 {
2226     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_ENTERED,
2227                    ::JVM_CurrentTimeMillis(NULL, 0), x, y, GetJavaModifiers(), 0, JNI_FALSE);
2228     if ((flags & ALL_MK_BUTTONS) == 0) {
2229         AwtCursor::UpdateCursor(this);
2230     }
2231     sm_cursorOn = GetHWnd();
2232     return mrConsume;   /* Don't pass our synthetic event on! */
2233 }
2234 
2235 MSG*
2236 AwtComponent::CreateMessage(UINT message, WPARAM wParam, LPARAM lParam,
2237                             int x = 0, int y = 0)
2238 {
2239     MSG* pMsg = new MSG;
2240     InitMessage(pMsg, message, wParam, lParam, x, y);
2241     return pMsg;
2242 }
2243 
2244 
2245 jint
2246 AwtComponent::GetDrawState(HWND hwnd) {
2247     return (jint)(INT_PTR)(::GetProp(hwnd, DrawingStateProp));
2248 }
2249 
2250 void
2251 AwtComponent::SetDrawState(HWND hwnd, jint state) {
2252     ::SetProp(hwnd, DrawingStateProp, (HANDLE)(INT_PTR)state);
2253 }
2254 
2255 void
2256 AwtComponent::InitMessage(MSG* msg, UINT message, WPARAM wParam, LPARAM lParam,
2257                             int x = 0, int y = 0)
2258 {
2259     msg->message = message;
2260     msg->wParam = wParam;
2261     msg->lParam = lParam;
2262     msg->time = ::GetMessageTime();
2263     msg->pt.x = x;
2264     msg->pt.y = y;
2265 }
2266 
2267 MsgRouting AwtComponent::WmNcMouseDown(WPARAM hitTest, int x, int y, int button) {
2268     return mrDoDefault;
2269 }
2270 MsgRouting AwtComponent::WmNcMouseUp(WPARAM hitTest, int x, int y, int button) {
2271     return mrDoDefault;
2272 }
2273 
2274 MsgRouting AwtComponent::WmWindowPosChanging(LPARAM windowPos) {
2275     return mrDoDefault;
2276 }
2277 MsgRouting AwtComponent::WmWindowPosChanged(LPARAM windowPos) {
2278     return mrDoDefault;
2279 }
2280 
2281 /* Double-click variables. */
2282 static jlong multiClickTime = ::GetDoubleClickTime();
2283 static int multiClickMaxX = ::GetSystemMetrics(SM_CXDOUBLECLK);
2284 static int multiClickMaxY = ::GetSystemMetrics(SM_CYDOUBLECLK);
2285 static AwtComponent* lastClickWnd = NULL;
2286 static jlong lastTime = 0;
2287 static int lastClickX = 0;
2288 static int lastClickY = 0;
2289 static int lastButton = 0;
2290 static int clickCount = 0;
2291 
2292 // A static method that makes the clickCount available in the derived classes
2293 // overriding WmMouseDown().
2294 int AwtComponent::GetClickCount()
2295 {
2296     return clickCount;
2297 }
2298 
2299 MsgRouting AwtComponent::WmMouseDown(UINT flags, int x, int y, int button)
2300 {
2301     jlong now = ::JVM_CurrentTimeMillis(NULL, 0);
2302 
2303     if (lastClickWnd == this &&
2304         lastButton == button &&
2305         (now - lastTime) <= multiClickTime &&
2306         abs(x - lastClickX) <= multiClickMaxX &&
2307         abs(y - lastClickY) <= multiClickMaxY)
2308     {
2309         clickCount++;
2310     } else {
2311         clickCount = 1;
2312         lastClickWnd = this;
2313         lastButton = button;
2314         lastClickX = x;
2315         lastClickY = y;
2316     }
2317     /*
2318      *Set appropriate bit of the mask on WM_MOUSE_DOWN message.
2319      */
2320     m_mouseButtonClickAllowed |= GetButtonMK(button);
2321     lastTime = now;
2322 
2323     MSG msg;
2324     InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2325 
2326     AwtWindow *toplevel = GetContainer();
2327     if (toplevel && !toplevel->IsSimpleWindow()) {
2328         /*
2329          * The frame should be focused by click in case it is
2330          * the active window but not the focused window. See 6886678.
2331          */
2332         if (toplevel->GetHWnd() == ::GetActiveWindow() &&
2333             toplevel->GetHWnd() != AwtComponent::GetFocusedWindow())
2334         {
2335             toplevel->AwtSetActiveWindow();
2336         }
2337     }
2338 
2339     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_PRESSED, now, x, y,
2340                    GetJavaModifiers(), clickCount, JNI_FALSE,
2341                    GetButton(button), &msg);
2342     /*
2343      * NOTE: this call is intentionally placed after all other code,
2344      * since AwtComponent::WmMouseDown() assumes that the cached id of the
2345      * latest retrieved message (see lastMessage in awt_Component.cpp)
2346      * matches the mouse message being processed.
2347      * SetCapture() sends WM_CAPTURECHANGED and breaks that
2348      * assumption.
2349      */
2350     SetDragCapture(flags);
2351 
2352     AwtWindow * owner = (AwtWindow*)GetComponent(GetTopLevelParentForWindow(GetHWnd()));
2353     if (AwtWindow::GetGrabbedWindow() != NULL && owner != NULL) {
2354         if (!AwtWindow::GetGrabbedWindow()->IsOneOfOwnersOf(owner)) {
2355             AwtWindow::GetGrabbedWindow()->Ungrab();
2356         }
2357     }
2358     return mrConsume;
2359 }
2360 
2361 MsgRouting AwtComponent::WmMouseUp(UINT flags, int x, int y, int button)
2362 {
2363     MSG msg;
2364     InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2365 
2366     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_RELEASED, ::JVM_CurrentTimeMillis(NULL, 0),
2367                    x, y, GetJavaModifiers(), clickCount,
2368                    (GetButton(button) == java_awt_event_MouseEvent_BUTTON3 ?
2369                     TRUE : FALSE), GetButton(button), &msg);
2370     /*
2371      * If no movement, then report a click following the button release.
2372      * When WM_MOUSEUP comes to a window without previous WM_MOUSEDOWN,
2373      * spurous MOUSE_CLICK is about to happen. See 6430553.
2374      */
2375     if ((m_mouseButtonClickAllowed & GetButtonMK(button)) != 0) { //CLICK allowed
2376         SendMouseEvent(java_awt_event_MouseEvent_MOUSE_CLICKED,
2377                        ::JVM_CurrentTimeMillis(NULL, 0), x, y, GetJavaModifiers(),
2378                        clickCount, JNI_FALSE, GetButton(button));
2379     }
2380     // Exclude button from allowed to generate CLICK messages
2381     m_mouseButtonClickAllowed &= ~GetButtonMK(button);
2382 
2383     if ((flags & ALL_MK_BUTTONS) == 0) {
2384         // only update if all buttons have been released
2385         AwtCursor::UpdateCursor(this);
2386     }
2387     /*
2388      * NOTE: this call is intentionally placed after all other code,
2389      * since AwtComponent::WmMouseUp() assumes that the cached id of the
2390      * latest retrieved message (see lastMessage in awt_Component.cpp)
2391      * matches the mouse message being processed.
2392      * ReleaseCapture() sends WM_CAPTURECHANGED and breaks that
2393      * assumption.
2394      */
2395     ReleaseDragCapture(flags);
2396 
2397     return mrConsume;
2398 }
2399 
2400 MsgRouting AwtComponent::WmMouseMove(UINT flags, int x, int y)
2401 {
2402     static AwtComponent* lastComp = NULL;
2403     static int lastX = 0;
2404     static int lastY = 0;
2405 
2406     /*
2407      * Only report mouse move and drag events if a move or drag
2408      * actually happened -- Windows sends a WM_MOUSEMOVE in case the
2409      * app wants to modify the cursor.
2410      */
2411     if (lastComp != this || x != lastX || y != lastY) {
2412         lastComp = this;
2413         lastX = x;
2414         lastY = y;
2415         BOOL extraButtonsEnabled = AwtToolkit::GetInstance().areExtraMouseButtonsEnabled();
2416         if (((flags & (ALL_MK_BUTTONS)) != 0) ||
2417             (extraButtonsEnabled && (flags & (X_BUTTONS)) != 0))
2418 //        if (( extraButtonsEnabled && ( (flags & (ALL_MK_BUTTONS | X_BUTTONS)) != 0 )) ||
2419 //            ( !extraButtonsEnabled && (((flags & (ALL_MK_BUTTONS)) != 0 )) && ((flags & (X_BUTTONS)) == 0) ))
2420         {
2421             // 6404008 : if Dragged event fired we shouldn't fire
2422             // Clicked event: m_firstDragSent set to TRUE.
2423             // This is a partial backout of 5039416 fix.
2424             MSG msg;
2425             InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2426             SendMouseEvent(java_awt_event_MouseEvent_MOUSE_DRAGGED, ::JVM_CurrentTimeMillis(NULL, 0), x, y,
2427                            GetJavaModifiers(), 0, JNI_FALSE,
2428                            java_awt_event_MouseEvent_NOBUTTON, &msg);
2429             //dragging means no more CLICKs until next WM_MOUSE_DOWN/WM_MOUSE_UP message sequence
2430             m_mouseButtonClickAllowed = 0;
2431         } else {
2432             MSG msg;
2433             InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2434             SendMouseEvent(java_awt_event_MouseEvent_MOUSE_MOVED, ::JVM_CurrentTimeMillis(NULL, 0), x, y,
2435                            GetJavaModifiers(), 0, JNI_FALSE,
2436                            java_awt_event_MouseEvent_NOBUTTON, &msg);
2437         }
2438     }
2439 
2440     return mrConsume;
2441 }
2442 
2443 MsgRouting AwtComponent::WmMouseExit(UINT flags, int x, int y)
2444 {
2445     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_EXITED, ::JVM_CurrentTimeMillis(NULL, 0), x,
2446                    y, GetJavaModifiers(), 0, JNI_FALSE);
2447     sm_cursorOn = NULL;
2448     return mrConsume;   /* Don't pass our synthetic event on! */
2449 }
2450 
2451 MsgRouting AwtComponent::WmMouseWheel(UINT flags, int x, int y,
2452                                       int wheelRotation)
2453 {
2454     // convert coordinates to be Component-relative, not screen relative
2455     // for wheeling when outside the window, this works similar to
2456     // coordinates during a drag
2457     POINT eventPt;
2458     eventPt.x = x;
2459     eventPt.y = y;
2460     DTRACE_PRINT2("  original coords: %i,%i\n", x, y);
2461     ::ScreenToClient(GetHWnd(), &eventPt);
2462     DTRACE_PRINT2("  new coords: %i,%i\n\n", eventPt.x, eventPt.y);
2463 
2464     // set some defaults
2465     jint scrollType = java_awt_event_MouseWheelEvent_WHEEL_UNIT_SCROLL;
2466     jint scrollLines = 3;
2467 
2468     BOOL result;
2469     UINT platformLines;
2470 
2471     m_wheelRotationAmount += wheelRotation;
2472 
2473     // AWT interprets wheel rotation differently than win32, so we need to
2474     // decode wheel amount.
2475     jint roundedWheelRotation = m_wheelRotationAmount / (-1 * WHEEL_DELTA);
2476     jdouble preciseWheelRotation = (jdouble) wheelRotation / (-1 * WHEEL_DELTA);
2477 
2478     MSG msg;
2479     result = ::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
2480                                     &platformLines, 0);
2481     InitMessage(&msg, lastMessage, MAKEWPARAM(flags, wheelRotation),
2482                 MAKELPARAM(x, y));
2483 
2484     if (result) {
2485         if (platformLines == WHEEL_PAGESCROLL) {
2486             scrollType = java_awt_event_MouseWheelEvent_WHEEL_BLOCK_SCROLL;
2487             scrollLines = 1;
2488         }
2489         else {
2490             scrollType = java_awt_event_MouseWheelEvent_WHEEL_UNIT_SCROLL;
2491             scrollLines = platformLines;
2492         }
2493     }
2494 
2495     DTRACE_PRINTLN("calling SendMouseWheelEvent");
2496 
2497     SendMouseWheelEvent(java_awt_event_MouseEvent_MOUSE_WHEEL, ::JVM_CurrentTimeMillis(NULL, 0),
2498                         eventPt.x, eventPt.y, GetJavaModifiers(), 0, 0, scrollType,
2499                         scrollLines, roundedWheelRotation, preciseWheelRotation, &msg);
2500 
2501     m_wheelRotationAmount %= WHEEL_DELTA;
2502     // this message could be propagated up to the parent chain
2503     // by the mouse message post processors
2504     return mrConsume;
2505 }
2506 
2507 jint AwtComponent::GetKeyLocation(UINT wkey, UINT flags) {
2508     // Rector+Newcomer page 413
2509     // The extended keys are the Alt and Control on the right of
2510     // the space bar, the non-Numpad arrow keys, the non-Numpad
2511     // Insert, PageUp, etc. keys, and the Numpad Divide and Enter keys.
2512     // Note that neither Shift key is extended.
2513     // Although not listed in Rector+Newcomer, both Windows keys
2514     // (91 and 92) are extended keys, the Context Menu key
2515     // (property key or application key - 93) is extended,
2516     // and so is the NumLock key.
2517 
2518     // wkey is the wParam, flags is the HIWORD of the lParam
2519 
2520     // "Extended" bit is 24th in lParam, so it's 8th in flags = HIWORD(lParam)
2521     BOOL extended = ((1<<8) & flags);
2522 
2523     if (IsNumPadKey(wkey, extended)) {
2524         return java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD;
2525     }
2526 
2527     switch (wkey) {
2528       case VK_SHIFT:
2529         return AwtComponent::GetShiftKeyLocation(wkey, flags);
2530       case VK_CONTROL: // fall through
2531       case VK_MENU:
2532         if (extended) {
2533             return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
2534         } else {
2535             return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2536         }
2537       case VK_LWIN:
2538         return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2539       case VK_RWIN:
2540         return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
2541       default:
2542         break;
2543     }
2544 
2545     // REMIND: if we add keycodes for the windows keys, we'll have to
2546     // include left/right discrimination code for them.
2547 
2548     return java_awt_event_KeyEvent_KEY_LOCATION_STANDARD;
2549 }
2550 
2551 jint AwtComponent::GetShiftKeyLocation(UINT vkey, UINT flags)
2552 {
2553     // init scancodes to safe values
2554     UINT leftShiftScancode = 0;
2555     UINT rightShiftScancode = 0;
2556 
2557     // First 8 bits of flags is the scancode
2558     UINT keyScanCode = flags & 0xFF;
2559 
2560     DTRACE_PRINTLN3(
2561       "AwtComponent::GetShiftKeyLocation  vkey = %d = 0x%x  scan = %d",
2562       vkey, vkey, keyScanCode);
2563 
2564     leftShiftScancode = ::MapVirtualKey(VK_LSHIFT, 0);
2565     rightShiftScancode = ::MapVirtualKey(VK_RSHIFT, 0);
2566 
2567     if (keyScanCode == leftShiftScancode) {
2568         return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2569     }
2570     if (keyScanCode == rightShiftScancode) {
2571         return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
2572     }
2573 
2574     DASSERT(false);
2575     // Note: the above should not fail on NT (or 2000)
2576 
2577     // default value
2578     return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2579 }
2580 
2581 /* Returns Java extended InputEvent modifieres.
2582  * Since ::GetKeyState returns current state and Java modifiers represent
2583  * state before event, modifier on changed key are inverted.
2584  */
2585 jint
2586 AwtComponent::GetJavaModifiers()
2587 {
2588     jint modifiers = 0;
2589 
2590     if (HIBYTE(::GetKeyState(VK_CONTROL)) != 0) {
2591         modifiers |= java_awt_event_InputEvent_CTRL_DOWN_MASK;
2592     }
2593     if (HIBYTE(::GetKeyState(VK_SHIFT)) != 0) {
2594         modifiers |= java_awt_event_InputEvent_SHIFT_DOWN_MASK;
2595     }
2596     if (HIBYTE(::GetKeyState(VK_MENU)) != 0) {
2597         modifiers |= java_awt_event_InputEvent_ALT_DOWN_MASK;
2598     }
2599     if (HIBYTE(::GetKeyState(VK_MBUTTON)) != 0) {
2600        modifiers |= java_awt_event_InputEvent_BUTTON2_DOWN_MASK;
2601     }
2602     if (HIBYTE(::GetKeyState(VK_RBUTTON)) != 0) {
2603         modifiers |= java_awt_event_InputEvent_BUTTON3_DOWN_MASK;
2604     }
2605     if (HIBYTE(::GetKeyState(VK_LBUTTON)) != 0) {
2606         modifiers |= java_awt_event_InputEvent_BUTTON1_DOWN_MASK;
2607     }
2608 
2609     if (HIBYTE(::GetKeyState(VK_XBUTTON1)) != 0) {
2610         modifiers |= masks[3];
2611     }
2612     if (HIBYTE(::GetKeyState(VK_XBUTTON2)) != 0) {
2613         modifiers |= masks[4];
2614     }
2615     return modifiers;
2616 }
2617 
2618 jint
2619 AwtComponent::GetButton(int mouseButton)
2620 {
2621     /* Mouse buttons are already set correctly for left/right handedness */
2622     switch(mouseButton) {
2623     case LEFT_BUTTON:
2624         return java_awt_event_MouseEvent_BUTTON1;
2625     case MIDDLE_BUTTON:
2626         return java_awt_event_MouseEvent_BUTTON2;
2627     case RIGHT_BUTTON:
2628         return java_awt_event_MouseEvent_BUTTON3;
2629     case X1_BUTTON: //16 :
2630         //just assign 4 and 5 numbers because MouseEvent class doesn't contain const identifier for them now
2631         return 4;
2632     case X2_BUTTON: //32
2633         return 5;
2634     }
2635     return java_awt_event_MouseEvent_NOBUTTON;
2636 }
2637 
2638 UINT
2639 AwtComponent::GetButtonMK(int mouseButton)
2640 {
2641     switch(mouseButton) {
2642     case LEFT_BUTTON:
2643         return MK_LBUTTON;
2644     case MIDDLE_BUTTON:
2645         return MK_MBUTTON;
2646     case RIGHT_BUTTON:
2647         return MK_RBUTTON;
2648     case X1_BUTTON:
2649         return MK_XBUTTON1;
2650     case X2_BUTTON:
2651         return MK_XBUTTON2;
2652     }
2653     return 0;
2654 }
2655 
2656 // FIXME: Keyboard related stuff has grown so big and hairy that we
2657 // really need to move it into a class of its own.  And, since
2658 // keyboard is a shared resource, AwtComponent is a bad place for it.
2659 
2660 // These constants are defined in the Japanese version of VC++5.0,
2661 // but not the US version
2662 #ifndef VK_CONVERT
2663 #define VK_KANA           0x15
2664 #define VK_KANJI          0x19
2665 #define VK_CONVERT        0x1C
2666 #define VK_NONCONVERT     0x1D
2667 #endif
2668 
2669 #ifndef VK_XBUTTON1
2670 #define VK_XBUTTON1      0x05
2671 #endif
2672 
2673 #ifndef VK_XBUTTON2
2674 #define VK_XBUTTON2      0x06
2675 #endif
2676 
2677 typedef struct {
2678     UINT javaKey;
2679     UINT windowsKey;
2680 } KeyMapEntry;
2681 
2682 // Static table, arranged more or less spatially.
2683 KeyMapEntry keyMapTable[] = {
2684     // Modifier keys
2685     {java_awt_event_KeyEvent_VK_CAPS_LOCK,        VK_CAPITAL},
2686     {java_awt_event_KeyEvent_VK_SHIFT,            VK_SHIFT},
2687     {java_awt_event_KeyEvent_VK_CONTROL,          VK_CONTROL},
2688     {java_awt_event_KeyEvent_VK_ALT,              VK_MENU},
2689     {java_awt_event_KeyEvent_VK_NUM_LOCK,         VK_NUMLOCK},
2690 
2691     // Miscellaneous Windows keys
2692     {java_awt_event_KeyEvent_VK_WINDOWS,          VK_LWIN},
2693     {java_awt_event_KeyEvent_VK_WINDOWS,          VK_RWIN},
2694     {java_awt_event_KeyEvent_VK_CONTEXT_MENU,     VK_APPS},
2695 
2696     // Alphabet
2697     {java_awt_event_KeyEvent_VK_A,                'A'},
2698     {java_awt_event_KeyEvent_VK_B,                'B'},
2699     {java_awt_event_KeyEvent_VK_C,                'C'},
2700     {java_awt_event_KeyEvent_VK_D,                'D'},
2701     {java_awt_event_KeyEvent_VK_E,                'E'},
2702     {java_awt_event_KeyEvent_VK_F,                'F'},
2703     {java_awt_event_KeyEvent_VK_G,                'G'},
2704     {java_awt_event_KeyEvent_VK_H,                'H'},
2705     {java_awt_event_KeyEvent_VK_I,                'I'},
2706     {java_awt_event_KeyEvent_VK_J,                'J'},
2707     {java_awt_event_KeyEvent_VK_K,                'K'},
2708     {java_awt_event_KeyEvent_VK_L,                'L'},
2709     {java_awt_event_KeyEvent_VK_M,                'M'},
2710     {java_awt_event_KeyEvent_VK_N,                'N'},
2711     {java_awt_event_KeyEvent_VK_O,                'O'},
2712     {java_awt_event_KeyEvent_VK_P,                'P'},
2713     {java_awt_event_KeyEvent_VK_Q,                'Q'},
2714     {java_awt_event_KeyEvent_VK_R,                'R'},
2715     {java_awt_event_KeyEvent_VK_S,                'S'},
2716     {java_awt_event_KeyEvent_VK_T,                'T'},
2717     {java_awt_event_KeyEvent_VK_U,                'U'},
2718     {java_awt_event_KeyEvent_VK_V,                'V'},
2719     {java_awt_event_KeyEvent_VK_W,                'W'},
2720     {java_awt_event_KeyEvent_VK_X,                'X'},
2721     {java_awt_event_KeyEvent_VK_Y,                'Y'},
2722     {java_awt_event_KeyEvent_VK_Z,                'Z'},
2723 
2724     // Standard numeric row
2725     {java_awt_event_KeyEvent_VK_0,                '0'},
2726     {java_awt_event_KeyEvent_VK_1,                '1'},
2727     {java_awt_event_KeyEvent_VK_2,                '2'},
2728     {java_awt_event_KeyEvent_VK_3,                '3'},
2729     {java_awt_event_KeyEvent_VK_4,                '4'},
2730     {java_awt_event_KeyEvent_VK_5,                '5'},
2731     {java_awt_event_KeyEvent_VK_6,                '6'},
2732     {java_awt_event_KeyEvent_VK_7,                '7'},
2733     {java_awt_event_KeyEvent_VK_8,                '8'},
2734     {java_awt_event_KeyEvent_VK_9,                '9'},
2735 
2736     // Misc key from main block
2737     {java_awt_event_KeyEvent_VK_ENTER,            VK_RETURN},
2738     {java_awt_event_KeyEvent_VK_SPACE,            VK_SPACE},
2739     {java_awt_event_KeyEvent_VK_BACK_SPACE,       VK_BACK},
2740     {java_awt_event_KeyEvent_VK_TAB,              VK_TAB},
2741     {java_awt_event_KeyEvent_VK_ESCAPE,           VK_ESCAPE},
2742 
2743     // NumPad with NumLock off & extended block (rectangular)
2744     {java_awt_event_KeyEvent_VK_INSERT,           VK_INSERT},
2745     {java_awt_event_KeyEvent_VK_DELETE,           VK_DELETE},
2746     {java_awt_event_KeyEvent_VK_HOME,             VK_HOME},
2747     {java_awt_event_KeyEvent_VK_END,              VK_END},
2748     {java_awt_event_KeyEvent_VK_PAGE_UP,          VK_PRIOR},
2749     {java_awt_event_KeyEvent_VK_PAGE_DOWN,        VK_NEXT},
2750     {java_awt_event_KeyEvent_VK_CLEAR,            VK_CLEAR}, // NumPad 5
2751 
2752     // NumPad with NumLock off & extended arrows block (triangular)
2753     {java_awt_event_KeyEvent_VK_LEFT,             VK_LEFT},
2754     {java_awt_event_KeyEvent_VK_RIGHT,            VK_RIGHT},
2755     {java_awt_event_KeyEvent_VK_UP,               VK_UP},
2756     {java_awt_event_KeyEvent_VK_DOWN,             VK_DOWN},
2757 
2758     // NumPad with NumLock on: numbers
2759     {java_awt_event_KeyEvent_VK_NUMPAD0,          VK_NUMPAD0},
2760     {java_awt_event_KeyEvent_VK_NUMPAD1,          VK_NUMPAD1},
2761     {java_awt_event_KeyEvent_VK_NUMPAD2,          VK_NUMPAD2},
2762     {java_awt_event_KeyEvent_VK_NUMPAD3,          VK_NUMPAD3},
2763     {java_awt_event_KeyEvent_VK_NUMPAD4,          VK_NUMPAD4},
2764     {java_awt_event_KeyEvent_VK_NUMPAD5,          VK_NUMPAD5},
2765     {java_awt_event_KeyEvent_VK_NUMPAD6,          VK_NUMPAD6},
2766     {java_awt_event_KeyEvent_VK_NUMPAD7,          VK_NUMPAD7},
2767     {java_awt_event_KeyEvent_VK_NUMPAD8,          VK_NUMPAD8},
2768     {java_awt_event_KeyEvent_VK_NUMPAD9,          VK_NUMPAD9},
2769 
2770     // NumPad with NumLock on
2771     {java_awt_event_KeyEvent_VK_MULTIPLY,         VK_MULTIPLY},
2772     {java_awt_event_KeyEvent_VK_ADD,              VK_ADD},
2773     {java_awt_event_KeyEvent_VK_SEPARATOR,        VK_SEPARATOR},
2774     {java_awt_event_KeyEvent_VK_SUBTRACT,         VK_SUBTRACT},
2775     {java_awt_event_KeyEvent_VK_DECIMAL,          VK_DECIMAL},
2776     {java_awt_event_KeyEvent_VK_DIVIDE,           VK_DIVIDE},
2777 
2778     // Functional keys
2779     {java_awt_event_KeyEvent_VK_F1,               VK_F1},
2780     {java_awt_event_KeyEvent_VK_F2,               VK_F2},
2781     {java_awt_event_KeyEvent_VK_F3,               VK_F3},
2782     {java_awt_event_KeyEvent_VK_F4,               VK_F4},
2783     {java_awt_event_KeyEvent_VK_F5,               VK_F5},
2784     {java_awt_event_KeyEvent_VK_F6,               VK_F6},
2785     {java_awt_event_KeyEvent_VK_F7,               VK_F7},
2786     {java_awt_event_KeyEvent_VK_F8,               VK_F8},
2787     {java_awt_event_KeyEvent_VK_F9,               VK_F9},
2788     {java_awt_event_KeyEvent_VK_F10,              VK_F10},
2789     {java_awt_event_KeyEvent_VK_F11,              VK_F11},
2790     {java_awt_event_KeyEvent_VK_F12,              VK_F12},
2791     {java_awt_event_KeyEvent_VK_F13,              VK_F13},
2792     {java_awt_event_KeyEvent_VK_F14,              VK_F14},
2793     {java_awt_event_KeyEvent_VK_F15,              VK_F15},
2794     {java_awt_event_KeyEvent_VK_F16,              VK_F16},
2795     {java_awt_event_KeyEvent_VK_F17,              VK_F17},
2796     {java_awt_event_KeyEvent_VK_F18,              VK_F18},
2797     {java_awt_event_KeyEvent_VK_F19,              VK_F19},
2798     {java_awt_event_KeyEvent_VK_F20,              VK_F20},
2799     {java_awt_event_KeyEvent_VK_F21,              VK_F21},
2800     {java_awt_event_KeyEvent_VK_F22,              VK_F22},
2801     {java_awt_event_KeyEvent_VK_F23,              VK_F23},
2802     {java_awt_event_KeyEvent_VK_F24,              VK_F24},
2803 
2804     {java_awt_event_KeyEvent_VK_PRINTSCREEN,      VK_SNAPSHOT},
2805     {java_awt_event_KeyEvent_VK_SCROLL_LOCK,      VK_SCROLL},
2806     {java_awt_event_KeyEvent_VK_PAUSE,            VK_PAUSE},
2807     {java_awt_event_KeyEvent_VK_CANCEL,           VK_CANCEL},
2808     {java_awt_event_KeyEvent_VK_HELP,             VK_HELP},
2809 
2810     // Japanese
2811     {java_awt_event_KeyEvent_VK_CONVERT,          VK_CONVERT},
2812     {java_awt_event_KeyEvent_VK_NONCONVERT,       VK_NONCONVERT},
2813     {java_awt_event_KeyEvent_VK_INPUT_METHOD_ON_OFF, VK_KANJI},
2814     {java_awt_event_KeyEvent_VK_ALPHANUMERIC,     VK_DBE_ALPHANUMERIC},
2815     {java_awt_event_KeyEvent_VK_KATAKANA,         VK_DBE_KATAKANA},
2816     {java_awt_event_KeyEvent_VK_HIRAGANA,         VK_DBE_HIRAGANA},
2817     {java_awt_event_KeyEvent_VK_FULL_WIDTH,       VK_DBE_DBCSCHAR},
2818     {java_awt_event_KeyEvent_VK_HALF_WIDTH,       VK_DBE_SBCSCHAR},
2819     {java_awt_event_KeyEvent_VK_ROMAN_CHARACTERS, VK_DBE_ROMAN},
2820 
2821     {java_awt_event_KeyEvent_VK_UNDEFINED,        0}
2822 };
2823 
2824 
2825 // Dynamic mapping table for OEM VK codes.  This table is refilled
2826 // by BuildDynamicKeyMapTable when keyboard layout is switched.
2827 // (see NT4 DDK src/input/inc/vkoem.h for OEM VK_ values).
2828 struct DynamicKeyMapEntry {
2829     UINT windowsKey;            // OEM VK codes known in advance
2830     UINT javaKey;               // depends on input langauge (kbd layout)
2831 };
2832 
2833 static DynamicKeyMapEntry dynamicKeyMapTable[] = {
2834     {0x00BA,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_1
2835     {0x00BB,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_PLUS
2836     {0x00BC,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_COMMA
2837     {0x00BD,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_MINUS
2838     {0x00BE,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_PERIOD
2839     {0x00BF,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_2
2840     {0x00C0,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_3
2841     {0x00DB,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_4
2842     {0x00DC,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_5
2843     {0x00DD,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_6
2844     {0x00DE,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_7
2845     {0x00DF,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_8
2846     {0x00E2,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_102
2847     {0, 0}
2848 };
2849 
2850 
2851 
2852 // Auxiliary tables used to fill the above dynamic table.  We first
2853 // find the character for the OEM VK code using ::MapVirtualKey and
2854 // then go through these auxiliary tables to map it to Java VK code.
2855 
2856 struct CharToVKEntry {
2857     WCHAR c;
2858     UINT  javaKey;
2859 };
2860 
2861 static const CharToVKEntry charToVKTable[] = {
2862     {L'!',   java_awt_event_KeyEvent_VK_EXCLAMATION_MARK},
2863     {L'"',   java_awt_event_KeyEvent_VK_QUOTEDBL},
2864     {L'#',   java_awt_event_KeyEvent_VK_NUMBER_SIGN},
2865     {L'$',   java_awt_event_KeyEvent_VK_DOLLAR},
2866     {L'&',   java_awt_event_KeyEvent_VK_AMPERSAND},
2867     {L'\'',  java_awt_event_KeyEvent_VK_QUOTE},
2868     {L'(',   java_awt_event_KeyEvent_VK_LEFT_PARENTHESIS},
2869     {L')',   java_awt_event_KeyEvent_VK_RIGHT_PARENTHESIS},
2870     {L'*',   java_awt_event_KeyEvent_VK_ASTERISK},
2871     {L'+',   java_awt_event_KeyEvent_VK_PLUS},
2872     {L',',   java_awt_event_KeyEvent_VK_COMMA},
2873     {L'-',   java_awt_event_KeyEvent_VK_MINUS},
2874     {L'.',   java_awt_event_KeyEvent_VK_PERIOD},
2875     {L'/',   java_awt_event_KeyEvent_VK_SLASH},
2876     {L':',   java_awt_event_KeyEvent_VK_COLON},
2877     {L';',   java_awt_event_KeyEvent_VK_SEMICOLON},
2878     {L'<',   java_awt_event_KeyEvent_VK_LESS},
2879     {L'=',   java_awt_event_KeyEvent_VK_EQUALS},
2880     {L'>',   java_awt_event_KeyEvent_VK_GREATER},
2881     {L'@',   java_awt_event_KeyEvent_VK_AT},
2882     {L'[',   java_awt_event_KeyEvent_VK_OPEN_BRACKET},
2883     {L'\\',  java_awt_event_KeyEvent_VK_BACK_SLASH},
2884     {L']',   java_awt_event_KeyEvent_VK_CLOSE_BRACKET},
2885     {L'^',   java_awt_event_KeyEvent_VK_CIRCUMFLEX},
2886     {L'_',   java_awt_event_KeyEvent_VK_UNDERSCORE},
2887     {L'`',   java_awt_event_KeyEvent_VK_BACK_QUOTE},
2888     {L'{',   java_awt_event_KeyEvent_VK_BRACELEFT},
2889     {L'}',   java_awt_event_KeyEvent_VK_BRACERIGHT},
2890     {0x00A1, java_awt_event_KeyEvent_VK_INVERTED_EXCLAMATION_MARK},
2891     {0x20A0, java_awt_event_KeyEvent_VK_EURO_SIGN}, // ????
2892     {0,0}
2893 };
2894 
2895 // For dead accents some layouts return ASCII punctuation, while some
2896 // return spacing accent chars, so both should be listed.  NB: MS docs
2897 // say that conversion routings return spacing accent character, not
2898 // combining.
2899 static const CharToVKEntry charToDeadVKTable[] = {
2900     {L'`',   java_awt_event_KeyEvent_VK_DEAD_GRAVE},
2901     {L'\'',  java_awt_event_KeyEvent_VK_DEAD_ACUTE},
2902     {0x00B4, java_awt_event_KeyEvent_VK_DEAD_ACUTE},
2903     {L'^',   java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX},
2904     {L'~',   java_awt_event_KeyEvent_VK_DEAD_TILDE},
2905     {0x02DC, java_awt_event_KeyEvent_VK_DEAD_TILDE},
2906     {0x00AF, java_awt_event_KeyEvent_VK_DEAD_MACRON},
2907     {0x02D8, java_awt_event_KeyEvent_VK_DEAD_BREVE},
2908     {0x02D9, java_awt_event_KeyEvent_VK_DEAD_ABOVEDOT},
2909     {L'"',   java_awt_event_KeyEvent_VK_DEAD_DIAERESIS},
2910     {0x00A8, java_awt_event_KeyEvent_VK_DEAD_DIAERESIS},
2911     {0x02DA, java_awt_event_KeyEvent_VK_DEAD_ABOVERING},
2912     {0x02DD, java_awt_event_KeyEvent_VK_DEAD_DOUBLEACUTE},
2913     {0x02C7, java_awt_event_KeyEvent_VK_DEAD_CARON},            // aka hacek
2914     {L',',   java_awt_event_KeyEvent_VK_DEAD_CEDILLA},
2915     {0x00B8, java_awt_event_KeyEvent_VK_DEAD_CEDILLA},
2916     {0x02DB, java_awt_event_KeyEvent_VK_DEAD_OGONEK},
2917     {0x037A, java_awt_event_KeyEvent_VK_DEAD_IOTA},             // ASCII ???
2918     {0x309B, java_awt_event_KeyEvent_VK_DEAD_VOICED_SOUND},
2919     {0x309C, java_awt_event_KeyEvent_VK_DEAD_SEMIVOICED_SOUND},
2920     {0,0}
2921 };
2922 
2923 // The full map of the current keyboard state including
2924 // windows virtual key, scancode, java virtual key, and unicode
2925 // for this key sans modifiers.
2926 // All but first element may be 0.
2927 // XXX in the update releases this is an addition to the unchanged existing code
2928 struct DynPrimaryKeymapEntry {
2929     UINT wkey;
2930     UINT scancode;
2931     UINT jkey;
2932     WCHAR unicode;
2933 };
2934 
2935 static DynPrimaryKeymapEntry dynPrimaryKeymap[256];
2936 
2937 void
2938 AwtComponent::InitDynamicKeyMapTable()
2939 {
2940     static BOOL kbdinited = FALSE;
2941 
2942     if (!kbdinited) {
2943         AwtComponent::BuildDynamicKeyMapTable();
2944         // We cannot build it here since JNI is not available yet:
2945         //AwtComponent::BuildPrimaryDynamicTable();
2946         kbdinited = TRUE;
2947     }
2948 }
2949 
2950 void
2951 AwtComponent::BuildDynamicKeyMapTable()
2952 {
2953     HKL hkl = GetKeyboardLayout();
2954 
2955     DTRACE_PRINTLN2("Building dynamic VK mapping tables: HKL = %08X (CP%d)",
2956                     hkl, AwtComponent::GetCodePage());
2957 
2958     // Will need this to reset layout after dead keys.
2959     UINT spaceScanCode = ::MapVirtualKeyEx(VK_SPACE, 0, hkl);
2960 
2961     // Entries in dynamic table that maps between Java VK and Windows
2962     // VK are built in three steps:
2963     //   1. Map windows VK to ANSI character (cannot map to unicode
2964     //      directly, since ::ToUnicode is not implemented on win9x)
2965     //   2. Convert ANSI char to Unicode char
2966     //   3. Map Unicode char to Java VK via two auxilary tables.
2967 
2968     for (DynamicKeyMapEntry *dynamic = dynamicKeyMapTable;
2969          dynamic->windowsKey != 0;
2970          ++dynamic)
2971     {
2972         // Defaults to VK_UNDEFINED
2973         dynamic->javaKey = java_awt_event_KeyEvent_VK_UNDEFINED;
2974 
2975         BYTE kbdState[AwtToolkit::KB_STATE_SIZE];
2976         AwtToolkit::GetKeyboardState(kbdState);
2977 
2978         kbdState[dynamic->windowsKey] |=  0x80; // Press the key.
2979 
2980         // Unpress modifiers, since they are most likely pressed as
2981         // part of the keyboard switching shortcut.
2982         kbdState[VK_CONTROL] &= ~0x80;
2983         kbdState[VK_SHIFT]   &= ~0x80;
2984         kbdState[VK_MENU]    &= ~0x80;
2985 
2986         char cbuf[2] = { '\0', '\0'};
2987         UINT scancode = ::MapVirtualKeyEx(dynamic->windowsKey, 0, hkl);
2988         int nchars = ::ToAsciiEx(dynamic->windowsKey, scancode, kbdState,
2989                                  (WORD*)cbuf, 0, hkl);
2990 
2991         // Auxiliary table used to map Unicode character to Java VK.
2992         // Will assign a different table for dead keys (below).
2993         const CharToVKEntry *charMap = charToVKTable;
2994 
2995         if (nchars < 0) { // Dead key
2996             // Use a different table for dead chars since different layouts
2997             // return different characters for the same dead key.
2998             charMap = charToDeadVKTable;
2999 
3000             // We also need to reset layout so that next translation
3001             // is unaffected by the dead status.  We do this by
3002             // translating <SPACE> key.
3003             kbdState[dynamic->windowsKey] &= ~0x80;
3004             kbdState[VK_SPACE] |= 0x80;
3005 
3006             char junkbuf[2] = { '\0', '\0'};
3007             ::ToAsciiEx(VK_SPACE, spaceScanCode, kbdState,
3008                         (WORD*)junkbuf, 0, hkl);
3009         }
3010 
3011 #ifdef DEBUG
3012         if (nchars == 0) {
3013             DTRACE_PRINTLN1("VK 0x%02X -> cannot convert to ANSI char",
3014                             dynamic->windowsKey);
3015             continue;
3016         }
3017         else if (nchars > 1) {  // can't happen, see reset code below
3018             DTRACE_PRINTLN3("VK 0x%02X -> converted to <0x%02X,0x%02X>",
3019                             dynamic->windowsKey,
3020                             (UCHAR)cbuf[0], (UCHAR)cbuf[1]);
3021             continue;
3022         }
3023 #endif
3024 
3025         WCHAR ucbuf[2] = { L'\0', L'\0' };
3026         int nconverted = ::MultiByteToWideChar(AwtComponent::GetCodePage(), 0,
3027                                                cbuf, 1, ucbuf, 2);
3028 #ifdef DEBUG
3029         if (nconverted < 0) {
3030             DTRACE_PRINTLN3("VK 0x%02X -> ANSI 0x%02X -> MultiByteToWideChar failed (0x%X)",
3031                             dynamic->windowsKey, (UCHAR)cbuf[0],
3032                             ::GetLastError());
3033             continue;
3034         }
3035 #endif
3036 
3037         WCHAR uc = ucbuf[0];
3038         for (const CharToVKEntry *map = charMap;  map->c != 0;  ++map) {
3039             if (uc == map->c) {
3040                 dynamic->javaKey = map->javaKey;
3041                 break;
3042             }
3043         }
3044 
3045         DTRACE_PRINTLN4("VK 0x%02X -> ANSI 0x%02X -> U+%04X -> Java VK 0x%X",
3046                         dynamic->windowsKey, (UCHAR)cbuf[0], (UINT)ucbuf[0],
3047                         dynamic->javaKey);
3048     } // for each VK_OEM_*
3049 }
3050 
3051 
3052 static BOOL isKanaLockAvailable()
3053 {
3054     // This method is to determine whether the Kana Lock feature is
3055     // available on the attached keyboard.  Kana Lock feature does not
3056     // necessarily require that the real KANA keytop is available on
3057     // keyboard, so using MapVirtualKey(VK_KANA) is not sufficient for testing.
3058     // Instead of that we regard it as Japanese keyboard (w/ Kana Lock) if :-
3059     //
3060     // - the keyboard layout is Japanese (VK_KANA has the same value as VK_HANGUL)
3061     // - the keyboard is Japanese keyboard (keyboard type == 7).
3062     return (LOWORD(GetKeyboardLayout(0)) == MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT))
3063         && (GetKeyboardType(0) == 7);
3064 }
3065 
3066 void AwtComponent::JavaKeyToWindowsKey(UINT javaKey,
3067                                        UINT *windowsKey, UINT *modifiers, UINT originalWindowsKey)
3068 {
3069     // Handle the few cases where a Java VK code corresponds to a Windows
3070     // key/modifier combination or applies only to specific keyboard layouts
3071     switch (javaKey) {
3072         case java_awt_event_KeyEvent_VK_ALL_CANDIDATES:
3073             *windowsKey = VK_CONVERT;
3074             *modifiers = java_awt_event_InputEvent_ALT_DOWN_MASK;
3075             return;
3076         case java_awt_event_KeyEvent_VK_PREVIOUS_CANDIDATE:
3077             *windowsKey = VK_CONVERT;
3078             *modifiers = java_awt_event_InputEvent_SHIFT_DOWN_MASK;
3079             return;
3080         case java_awt_event_KeyEvent_VK_CODE_INPUT:
3081             *windowsKey = VK_DBE_ALPHANUMERIC;
3082             *modifiers = java_awt_event_InputEvent_ALT_DOWN_MASK;
3083             return;
3084         case java_awt_event_KeyEvent_VK_KANA_LOCK:
3085             if (isKanaLockAvailable()) {
3086                 *windowsKey = VK_KANA;
3087                 *modifiers = java_awt_event_InputEvent_CTRL_DOWN_MASK;
3088                 return;
3089             }
3090     }
3091 
3092     // for the general case, use a bi-directional table
3093     for (int i = 0; keyMapTable[i].windowsKey != 0; i++) {
3094         if (keyMapTable[i].javaKey == javaKey) {
3095             *windowsKey = keyMapTable[i].windowsKey;
3096             *modifiers = 0;
3097             return;
3098         }
3099     }
3100 
3101     // Bug 4766655
3102     // Two Windows keys could map to the same Java key, so
3103     // give preference to the originalWindowsKey if it is
3104     // specified (not IGNORE_KEY).
3105     if (originalWindowsKey == IGNORE_KEY) {
3106         for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
3107             if (dynamicKeyMapTable[j].javaKey == javaKey) {
3108                 *windowsKey = dynamicKeyMapTable[j].windowsKey;
3109                 *modifiers = 0;
3110                 return;
3111             }
3112         }
3113     } else {
3114         BOOL found = false;
3115         for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
3116             if (dynamicKeyMapTable[j].javaKey == javaKey) {
3117                 *windowsKey = dynamicKeyMapTable[j].windowsKey;
3118                 *modifiers = 0;
3119                 found = true;
3120                 if (*windowsKey == originalWindowsKey) {
3121                     return;   /* if ideal case found return, else keep looking */
3122                 }
3123             }
3124         }
3125         if (found) {
3126             return;
3127         }
3128     }
3129 
3130     *windowsKey = 0;
3131     *modifiers = 0;
3132     return;
3133 }
3134 
3135 UINT AwtComponent::WindowsKeyToJavaKey(UINT windowsKey, UINT modifiers, UINT character, BOOL isDeadKey)
3136 
3137 {
3138     // Handle the few cases where we need to take the modifier into
3139     // consideration for the Java VK code or where we have to take the keyboard
3140     // layout into consideration so that function keys can get
3141     // recognized in a platform-independent way.
3142     switch (windowsKey) {
3143         case VK_CONVERT:
3144             if ((modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) != 0) {
3145                 return java_awt_event_KeyEvent_VK_ALL_CANDIDATES;
3146             }
3147             if ((modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) != 0) {
3148                 return java_awt_event_KeyEvent_VK_PREVIOUS_CANDIDATE;
3149             }
3150             break;
3151         case VK_DBE_ALPHANUMERIC:
3152             if ((modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) != 0) {
3153                 return java_awt_event_KeyEvent_VK_CODE_INPUT;
3154             }
3155             break;
3156         case VK_KANA:
3157             if (isKanaLockAvailable()) {
3158                 return java_awt_event_KeyEvent_VK_KANA_LOCK;
3159             }
3160             break;
3161     };
3162 
3163     // check dead key
3164     if (isDeadKey) {
3165       for (int i = 0; charToDeadVKTable[i].c != 0; i++) {
3166         if (charToDeadVKTable[i].c == character) {
3167             return charToDeadVKTable[i].javaKey;
3168         }
3169       }
3170     }
3171 
3172     // for the general case, use a bi-directional table
3173     for (int i = 0; keyMapTable[i].windowsKey != 0; i++) {
3174         if (keyMapTable[i].windowsKey == windowsKey) {
3175             return keyMapTable[i].javaKey;
3176         }
3177     }
3178 
3179     for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
3180         if (dynamicKeyMapTable[j].windowsKey == windowsKey) {
3181             if (dynamicKeyMapTable[j].javaKey != java_awt_event_KeyEvent_VK_UNDEFINED) {
3182                 return dynamicKeyMapTable[j].javaKey;
3183             }else{
3184                 break;
3185             }
3186         }
3187     }
3188 
3189     return java_awt_event_KeyEvent_VK_UNDEFINED;
3190 }
3191 
3192 BOOL AwtComponent::IsNavigationKey(UINT wkey) {
3193     switch (wkey) {
3194       case VK_END:
3195       case VK_PRIOR:  // PageUp
3196       case VK_NEXT:  // PageDown
3197       case VK_HOME:
3198       case VK_LEFT:
3199       case VK_UP:
3200       case VK_RIGHT:
3201       case VK_DOWN:
3202           return TRUE;
3203     }
3204     return FALSE;
3205 }
3206 
3207 // determine if a key is a numpad key (distinguishes the numpad
3208 // arrow keys from the non-numpad arrow keys, for example).
3209 BOOL AwtComponent::IsNumPadKey(UINT vkey, BOOL extended)
3210 {
3211     // Note: scancodes are the same for the numpad arrow keys and
3212     // the non-numpad arrow keys (also for PageUp, etc.).
3213     // The scancodes for the numpad divide and the non-numpad slash
3214     // are the same, but the wparams are different
3215 
3216     DTRACE_PRINTLN3("AwtComponent::IsNumPadKey  vkey = %d = 0x%x  extended = %d",
3217       vkey, vkey, extended);
3218 
3219     switch (vkey) {
3220       case VK_CLEAR:  // numpad 5 with numlock off
3221       case VK_NUMPAD0:
3222       case VK_NUMPAD1:
3223       case VK_NUMPAD2:
3224       case VK_NUMPAD3:
3225       case VK_NUMPAD4:
3226       case VK_NUMPAD5:
3227       case VK_NUMPAD6:
3228       case VK_NUMPAD7:
3229       case VK_NUMPAD8:
3230       case VK_NUMPAD9:
3231       case VK_MULTIPLY:
3232       case VK_ADD:
3233       case VK_SEPARATOR:  // numpad ,  not on US kbds
3234       case VK_SUBTRACT:
3235       case VK_DECIMAL:
3236       case VK_DIVIDE:
3237       case VK_NUMLOCK:
3238         return TRUE;
3239         break;
3240       case VK_END:
3241       case VK_PRIOR:  // PageUp
3242       case VK_NEXT:  // PageDown
3243       case VK_HOME:
3244       case VK_LEFT:
3245       case VK_UP:
3246       case VK_RIGHT:
3247       case VK_DOWN:
3248       case VK_INSERT:
3249       case VK_DELETE:
3250         // extended if non-numpad
3251         return (!extended);
3252         break;
3253       case VK_RETURN:  // extended if on numpad
3254         return (extended);
3255         break;
3256       default:
3257         break;
3258     }
3259 
3260     return FALSE;
3261 }
3262 static void
3263 resetKbdState( BYTE kstate[256]) {
3264     BYTE tmpState[256];
3265     WCHAR wc[2];
3266     memmove(tmpState, kstate, sizeof(kstate));
3267     tmpState[VK_SHIFT] = 0;
3268     tmpState[VK_CONTROL] = 0;
3269     tmpState[VK_MENU] = 0;
3270 
3271     ::ToUnicodeEx(VK_SPACE,::MapVirtualKey(VK_SPACE, 0), tmpState, wc, 2, 0,  GetKeyboardLayout(0));
3272 }
3273 
3274 // XXX in the update releases this is an addition to the unchanged existing code
3275 // After the call, a table will have a unicode associated with a windows virtual keycode
3276 // sans modifiers. With some further simplification, one can
3277 // derive java keycode from it, and anyway we will pass this unicode value
3278 // all the way up in a comment to a KeyEvent.
3279 void
3280 AwtComponent::BuildPrimaryDynamicTable() {
3281     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3282     // XXX: how about that?
3283     //CriticalSection::Lock l(GetLock());
3284     //if (GetPeer(env) == NULL) {
3285     //    /* event received during termination. */
3286     //    return;
3287     //}
3288 
3289     HKL hkl = GetKeyboardLayout();
3290     UINT sc = 0;
3291     BYTE kbdState[AwtToolkit::KB_STATE_SIZE];
3292     memset(kbdState, 0, sizeof (kbdState));
3293 
3294     // Use JNI call to obtain java key code. We should keep a list
3295     // of currently available keycodes in a single place.
3296     static jclass extKeyCodesCls;
3297     if( extKeyCodesCls == NULL) {
3298         jclass extKeyCodesClsLocal = env->FindClass("sun/awt/ExtendedKeyCodes");
3299         DASSERT(extKeyCodesClsLocal);
3300         CHECK_NULL(extKeyCodesClsLocal);
3301         extKeyCodesCls = (jclass)env->NewGlobalRef(extKeyCodesClsLocal);
3302         env->DeleteLocalRef(extKeyCodesClsLocal);
3303     }
3304     static jmethodID getExtendedKeyCodeForChar;
3305     if (getExtendedKeyCodeForChar == NULL) {
3306         getExtendedKeyCodeForChar =
3307                   env->GetStaticMethodID(extKeyCodesCls, "getExtendedKeyCodeForChar", "(I)I");
3308         DASSERT(getExtendedKeyCodeForChar);
3309         CHECK_NULL(getExtendedKeyCodeForChar);
3310     }
3311     jint extJKC; //extended Java key code
3312 
3313     for (UINT i = 0; i < 256; i++) {
3314         dynPrimaryKeymap[i].wkey = i;
3315         dynPrimaryKeymap[i].jkey = java_awt_event_KeyEvent_VK_UNDEFINED;
3316         dynPrimaryKeymap[i].unicode = 0;
3317 
3318         if ((sc = MapVirtualKey (i, 0)) == 0) {
3319             dynPrimaryKeymap[i].scancode = 0;
3320             continue;
3321         }
3322         dynPrimaryKeymap[i].scancode = sc;
3323 
3324         // XXX process cases like VK_SHIFT etc.
3325         kbdState[i] = 0x80; // "key pressed".
3326         WCHAR wc[16];
3327         int k = ::ToUnicodeEx(i, sc, kbdState, wc, 16, 0, hkl);
3328         if (k == 1) {
3329             // unicode
3330             dynPrimaryKeymap[i].unicode = wc[0];
3331             if (dynPrimaryKeymap[i].jkey == java_awt_event_KeyEvent_VK_UNDEFINED) {
3332             // Convert unicode to java keycode.
3333                 //dynPrimaryKeymap[i].jkey = ((UINT)(wc[0]) + 0x01000000);
3334                 //
3335                 //XXX If this key in on the keypad, we should force a special value equal to
3336                 //XXX an old java keycode: but how to say if it is a keypad key?
3337                 //XXX We'll do it in WmKeyUp/Down.
3338                 extJKC = env->CallStaticIntMethod(extKeyCodesCls,
3339                                                   getExtendedKeyCodeForChar, (jint)(wc[0]));
3340                 dynPrimaryKeymap[i].jkey = extJKC;
3341             }
3342         }else if (k == -1) {
3343             // dead key: use charToDeadVKTable
3344             dynPrimaryKeymap[i].unicode = wc[0];
3345             resetKbdState( kbdState );
3346             for (const CharToVKEntry *map = charToDeadVKTable;  map->c != 0;  ++map) {
3347                 if (wc[0] == map->c) {
3348                     dynPrimaryKeymap[i].jkey = map->javaKey;
3349                     break;
3350                 }
3351             }
3352         } else if (k == 0) {
3353             // reset
3354             resetKbdState( kbdState );
3355         }else {
3356             // k > 1: this key does generate multiple characters. Ignore it.
3357             // An example: Arabic Lam and Alef ligature.
3358             // There will be no extended keycode and thus shortcuts for this  key.
3359             // XXX shouldn't we reset the kbd state?
3360 #ifdef DEBUG
3361             DTRACE_PRINTLN2("wkey 0x%02X (%d)", i,i);
3362 #endif
3363         }
3364         kbdState[i] = 0; // "key unpressed"
3365     }
3366 }
3367 void
3368 AwtComponent::UpdateDynPrimaryKeymap(UINT wkey, UINT jkeyLegacy, jint keyLocation, UINT modifiers)
3369 {
3370     if( wkey && wkey < 256 ) {
3371         if(keyLocation == java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD) {
3372             // At the creation time,
3373             // dynPrimaryKeymap cannot distinguish between e.g. "/" and "NumPad /"
3374             dynPrimaryKeymap[wkey].jkey = jkeyLegacy;
3375         }
3376         if(dynPrimaryKeymap[wkey].jkey ==  java_awt_event_KeyEvent_VK_UNDEFINED) {
3377             // E.g. it is non-unicode key
3378             dynPrimaryKeymap[wkey].jkey = jkeyLegacy;
3379         }
3380     }
3381 }
3382 
3383 UINT AwtComponent::WindowsKeyToJavaChar(UINT wkey, UINT modifiers, TransOps ops, BOOL &isDeadKey)
3384 {
3385     static Hashtable transTable("VKEY translations");
3386     static Hashtable deadKeyFlagTable("Dead Key Flags");
3387     isDeadKey = FALSE;
3388 
3389     // Try to translate using last saved translation
3390     if (ops == LOAD) {
3391        void* deadKeyFlag = deadKeyFlagTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
3392        void* value = transTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
3393        if (value != NULL) {
3394            isDeadKey = static_cast<BOOL>(reinterpret_cast<INT_PTR>(deadKeyFlag));
3395            return static_cast<UINT>(reinterpret_cast<INT_PTR>(value));
3396        }
3397     }
3398 
3399     // If the windows key is a return, wkey will equal 13 ('\r')
3400     // In this case, we want to return 10 ('\n')
3401     // Since ToAscii would convert VK_RETURN to '\r', we need
3402     // to have a special case here.
3403     if (wkey == VK_RETURN)
3404         return '\n';
3405 
3406     // high order bit in keyboardState indicates whether the key is down
3407     static const BYTE KEY_STATE_DOWN = 0x80;
3408     BYTE    keyboardState[AwtToolkit::KB_STATE_SIZE];
3409     AwtToolkit::GetKeyboardState(keyboardState);
3410 
3411     // apply modifiers to keyboard state if necessary
3412     if (modifiers) {
3413         BOOL shiftIsDown = modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK;
3414         BOOL altIsDown = modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK;
3415         BOOL ctrlIsDown = modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK;
3416 
3417         // Windows treats AltGr as Ctrl+Alt
3418         if (modifiers & java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK) {
3419             altIsDown = TRUE;
3420             ctrlIsDown = TRUE;
3421         }
3422 
3423         if (shiftIsDown) {
3424             keyboardState[VK_SHIFT] |= KEY_STATE_DOWN;
3425         }
3426 
3427         // fix for 4623376,4737679,4501485,4740906,4708221 (4173679/4122715)
3428         // Here we try to resolve a conflict with ::ToAsciiEx's translating
3429         // ALT+number key combinations. kdm@sarc.spb.su
3430         // yan: Do it for navigation keys only, otherwise some AltGr deadkeys fail.
3431         if( IsNavigationKey(wkey) ) {
3432             keyboardState[VK_MENU] &= ~KEY_STATE_DOWN;
3433         }
3434 
3435         if (ctrlIsDown)
3436         {
3437             if (altIsDown) {
3438                 // bugid 4215009: don't mess with AltGr == Ctrl + Alt
3439                 keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
3440             }
3441             else {
3442                 // bugid 4098210: old event model doesn't have KEY_TYPED
3443                 // events, so try to provide a meaningful character for
3444                 // Ctrl+<key>.  Take Ctrl into account only when we know
3445                 // that Ctrl+<key> will be an ASCII control.  Ignore by
3446                 // default.
3447                 keyboardState[VK_CONTROL] &= ~KEY_STATE_DOWN;
3448 
3449                 // Letters have Ctrl+<letter> counterparts.  According to
3450                 // <winuser.h> VK_A through VK_Z are the same as ASCII
3451                 // 'A' through 'Z'.
3452                 if (wkey >= 'A' && wkey <= 'Z') {
3453                     keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
3454                 }
3455                 else {
3456                     // Non-letter controls 033 to 037 are:
3457                     // ^[ (ESC), ^\ (FS), ^] (GS), ^^ (RS), and ^_ (US)
3458 
3459                     // Shift state bits returned by ::VkKeyScan in HIBYTE
3460                     static const UINT _VKS_SHIFT_MASK = 0x01;
3461                     static const UINT _VKS_CTRL_MASK = 0x02;
3462                     static const UINT _VKS_ALT_MASK = 0x04;
3463 
3464                     // Check to see whether there is a meaningful translation
3465                     TCHAR ch;
3466                     short vk;
3467                     for (ch = _T('\033'); ch < _T('\040'); ch++) {
3468                         vk = ::VkKeyScan(ch);
3469                         if (wkey == LOBYTE(vk)) {
3470                             UINT shiftState = HIBYTE(vk);
3471                             if ((shiftState & _VKS_CTRL_MASK) ||
3472                                 (!(shiftState & _VKS_SHIFT_MASK)
3473                                 == !shiftIsDown))
3474                             {
3475                                 keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
3476                             }
3477                             break;
3478                         }
3479                     }
3480                 }
3481             } // ctrlIsDown && altIsDown
3482         } // ctrlIsDown
3483     } // modifiers
3484 
3485     // instead of creating our own conversion tables, I'll let Win32
3486     // convert the character for me.
3487     WORD wChar[2];
3488     UINT scancode = ::MapVirtualKey(wkey, 0);
3489     int converted = ::ToUnicodeEx(wkey, scancode, keyboardState,
3490                                   wChar, 2, 0, GetKeyboardLayout());
3491 
3492     UINT translation;
3493     BOOL deadKeyFlag = (converted == 2);
3494 
3495     // Dead Key
3496     if (converted < 0) {
3497         translation = java_awt_event_KeyEvent_CHAR_UNDEFINED;
3498     } else
3499     // No translation available -- try known conversions or else punt.
3500     if (converted == 0) {
3501         if (wkey == VK_DELETE) {
3502             translation = '\177';
3503         } else
3504         if (wkey >= VK_NUMPAD0 && wkey <= VK_NUMPAD9) {
3505             translation = '0' + wkey - VK_NUMPAD0;
3506         } else {
3507             translation = java_awt_event_KeyEvent_CHAR_UNDEFINED;
3508         }
3509     } else
3510     // the caller expects a Unicode character.
3511     if (converted > 0) {
3512         translation = wChar[0];
3513     }
3514     if (ops == SAVE) {
3515         transTable.put(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)),
3516                        reinterpret_cast<void*>(static_cast<INT_PTR>(translation)));
3517         if (deadKeyFlag) {
3518             deadKeyFlagTable.put(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)),
3519                          reinterpret_cast<void*>(static_cast<INT_PTR>(deadKeyFlag)));
3520         } else {
3521             deadKeyFlagTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
3522         }
3523     }
3524 
3525     isDeadKey = deadKeyFlag;
3526     return translation;
3527 }
3528 
3529 MsgRouting AwtComponent::WmKeyDown(UINT wkey, UINT repCnt,
3530                                    UINT flags, BOOL system)
3531 {
3532     // VK_PROCESSKEY is a special value which means
3533     //          "Current IME wants to consume this KeyEvent"
3534     // Real key code is saved by IMM32.DLL and can be retrieved by
3535     // calling ImmGetVirtualKey();
3536     if (wkey == VK_PROCESSKEY) {
3537         return mrDoDefault;
3538     }
3539     MSG msg;
3540     InitMessage(&msg, (system ? WM_SYSKEYDOWN : WM_KEYDOWN),
3541                              wkey, MAKELPARAM(repCnt, flags));
3542 
3543     UINT modifiers = GetJavaModifiers();
3544     jint keyLocation = GetKeyLocation(wkey, flags);
3545     BOOL isDeadKey = FALSE;
3546     UINT character = WindowsKeyToJavaChar(wkey, modifiers, SAVE, isDeadKey);
3547     UINT jkey = WindowsKeyToJavaKey(wkey, modifiers, character, isDeadKey);
3548     UpdateDynPrimaryKeymap(wkey, jkey, keyLocation, modifiers);
3549 
3550 
3551     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_PRESSED,
3552                              ::JVM_CurrentTimeMillis(NULL, 0), jkey, character,
3553                              modifiers, keyLocation, (jlong)wkey, &msg);
3554 
3555     // bugid 4724007: Windows does not create a WM_CHAR for the Del key
3556     // for some reason, so we need to create the KEY_TYPED event on the
3557     // WM_KEYDOWN.  Use null msg so the character doesn't get sent back
3558     // to the native window for processing (this event is synthesized
3559     // for Java - we don't want Windows trying to process it).
3560     if (jkey == java_awt_event_KeyEvent_VK_DELETE) {
3561         SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
3562                                  ::JVM_CurrentTimeMillis(NULL, 0),
3563                                  java_awt_event_KeyEvent_VK_UNDEFINED,
3564                                  character, modifiers,
3565                                  java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0);
3566     }
3567 
3568     return mrConsume;
3569 }
3570 
3571 MsgRouting AwtComponent::WmKeyUp(UINT wkey, UINT repCnt,
3572                                  UINT flags, BOOL system)
3573 {
3574 
3575     // VK_PROCESSKEY is a special value which means
3576     //          "Current IME wants to consume this KeyEvent"
3577     // Real key code is saved by IMM32.DLL and can be retrieved by
3578     // calling ImmGetVirtualKey();
3579     if (wkey == VK_PROCESSKEY) {
3580         return mrDoDefault;
3581     }
3582     MSG msg;
3583     InitMessage(&msg, (system ? WM_SYSKEYUP : WM_KEYUP),
3584                              wkey, MAKELPARAM(repCnt, flags));
3585 
3586     UINT modifiers = GetJavaModifiers();
3587     jint keyLocation = GetKeyLocation(wkey, flags);
3588     BOOL isDeadKey = FALSE;
3589     UINT character = WindowsKeyToJavaChar(wkey, modifiers, LOAD, isDeadKey);
3590     UINT jkey = WindowsKeyToJavaKey(wkey, modifiers, character, isDeadKey);
3591     UpdateDynPrimaryKeymap(wkey, jkey, keyLocation, modifiers);
3592 
3593     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_RELEASED,
3594                              ::JVM_CurrentTimeMillis(NULL, 0), jkey, character,
3595                              modifiers, keyLocation, (jlong)wkey, &msg);
3596     return mrConsume;
3597 }
3598 
3599 MsgRouting AwtComponent::WmInputLangChange(UINT charset, HKL hKeyboardLayout)
3600 {
3601     // Normally we would be able to use charset and TranslateCharSetInfo
3602     // to get a code page that should be associated with this keyboard
3603     // layout change. However, there seems to be an NT 4.0 bug associated
3604     // with the WM_INPUTLANGCHANGE message, which makes the charset parameter
3605     // unreliable, especially on Asian systems. Our workaround uses the
3606     // keyboard layout handle instead.
3607     m_hkl = hKeyboardLayout;
3608     m_idLang = LOWORD(hKeyboardLayout); // lower word of HKL is LANGID
3609     m_CodePage = LangToCodePage(m_idLang);
3610     BuildDynamicKeyMapTable();  // compute new mappings for VK_OEM
3611     BuildPrimaryDynamicTable();
3612     return mrConsume;           // do not propagate to children
3613 }
3614 
3615 // Convert Language ID to CodePage
3616 UINT AwtComponent::LangToCodePage(LANGID idLang)
3617 {
3618     TCHAR strCodePage[MAX_ACP_STR_LEN];
3619     // use the LANGID to create a LCID
3620     LCID idLocale = MAKELCID(idLang, SORT_DEFAULT);
3621     // get the ANSI code page associated with this locale
3622     if (GetLocaleInfo(idLocale, LOCALE_IDEFAULTANSICODEPAGE, strCodePage, sizeof(strCodePage)/sizeof(TCHAR)) > 0 )
3623         return _ttoi(strCodePage);
3624     else
3625         return GetACP();
3626 }
3627 
3628 
3629 MsgRouting AwtComponent::WmIMEChar(UINT character, UINT repCnt, UINT flags, BOOL system)
3630 {
3631     // We will simply create Java events here.
3632     WCHAR unicodeChar = character;
3633     MSG msg;
3634     InitMessage(&msg, WM_IME_CHAR, character,
3635                               MAKELPARAM(repCnt, flags));
3636 
3637     jint modifiers = GetJavaModifiers();
3638     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
3639                              ::JVM_CurrentTimeMillis(NULL, 0),
3640                              java_awt_event_KeyEvent_VK_UNDEFINED,
3641                              unicodeChar, modifiers,
3642                              java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0,
3643                              &msg);
3644     return mrConsume;
3645 }
3646 
3647 MsgRouting AwtComponent::WmChar(UINT character, UINT repCnt, UINT flags,
3648                                 BOOL system)
3649 {
3650     // Will only get WmChar messages with DBCS if we create them for
3651     // an Edit class in the WmForwardChar method. These synthesized
3652     // DBCS chars are ok to pass on directly to the default window
3653     // procedure. They've already been filtered through the Java key
3654     // event queue. We will never get the trail byte since the edit
3655     // class will PeekMessage(&msg, hwnd, WM_CHAR, WM_CHAR,
3656     // PM_REMOVE).  I would like to be able to pass this character off
3657     // via WM_AWT_FORWARD_BYTE, but the Edit classes don't seem to
3658     // like that.
3659 
3660     // We will simply create Java events here.
3661     UINT message = system ? WM_SYSCHAR : WM_CHAR;
3662 
3663     // The Alt modifier is reported in the 29th bit of the lParam,
3664     // i.e., it is the 13th bit of `flags' (which is HIWORD(lParam)).
3665     bool alt_is_down = (flags & (1<<13)) != 0;
3666 
3667     // Fix for bug 4141621, corrected by fix for bug 6223726: Alt+space doesn't invoke system menu
3668     // We should not pass this particular combination to Java.
3669 
3670     if (system && alt_is_down) {
3671         if (character == VK_SPACE) {
3672             return mrDoDefault;
3673         }
3674     }
3675 
3676     // If this is a WM_CHAR (non-system) message, then the Alt flag
3677     // indicates that the character was typed using an AltGr key
3678     // (which Windows treats as Ctrl+Alt), so in this case we do NOT
3679     // pass the Ctrl and Alt modifiers to Java, but instead we
3680     // replace them with Java's AltGraph modifier.  Note: the AltGraph
3681     // modifier does not exist in 1.1.x releases.
3682     jint modifiers = GetJavaModifiers();
3683     if (!system && alt_is_down) {
3684         // character typed with AltGraph
3685         modifiers &= ~(java_awt_event_InputEvent_ALT_DOWN_MASK
3686                        | java_awt_event_InputEvent_CTRL_DOWN_MASK);
3687         modifiers |= java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK;
3688     }
3689 
3690     WCHAR unicodeChar = character;
3691 
3692     // Kludge: Combine pending single byte with this char for some Chinese IMEs
3693     if (m_PendingLeadByte != 0) {
3694         character = (m_PendingLeadByte & 0x00ff) | (character << 8);
3695         m_PendingLeadByte = 0;
3696         ::MultiByteToWideChar(GetCodePage(), 0, (CHAR*)&character, 2,
3697                           &unicodeChar, 1);
3698     }
3699 
3700     if (unicodeChar == VK_RETURN) {
3701         // Enter key generates \r in windows, but \n is required in java
3702         unicodeChar = java_awt_event_KeyEvent_VK_ENTER;
3703     }
3704     MSG msg;
3705     InitMessage(&msg, message, character,
3706                               MAKELPARAM(repCnt, flags));
3707     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
3708                              ::JVM_CurrentTimeMillis(NULL, 0),
3709                              java_awt_event_KeyEvent_VK_UNDEFINED,
3710                              unicodeChar, modifiers,
3711                              java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0,
3712                              &msg);
3713     return mrConsume;
3714 }
3715 
3716 MsgRouting AwtComponent::WmForwardChar(WCHAR character, LPARAM lParam,
3717                                        BOOL synthetic)
3718 {
3719     // just post WM_CHAR with unicode key value
3720     DefWindowProc(WM_CHAR, (WPARAM)character, lParam);
3721     return mrConsume;
3722 }
3723 
3724 MsgRouting AwtComponent::WmPaste()
3725 {
3726     return mrDoDefault;
3727 }
3728 
3729 // support IME Composition messages
3730 void AwtComponent::SetCompositionWindow(RECT& r)
3731 {
3732     HWND hwnd = ImmGetHWnd();
3733     HIMC hIMC = ImmGetContext(hwnd);
3734     if (hIMC == NULL) {
3735         return;
3736     }
3737     COMPOSITIONFORM cf = {CFS_DEFAULT, {0, 0}, {0, 0, 0, 0}};
3738     ImmSetCompositionWindow(hIMC, &cf);
3739     ImmReleaseContext(hwnd, hIMC);
3740 }
3741 
3742 void AwtComponent::OpenCandidateWindow(int x, int y)
3743 {
3744     UINT bits = 1;
3745     RECT rc;
3746     GetWindowRect(GetHWnd(), &rc);
3747 
3748     for (int iCandType=0; iCandType<32; iCandType++, bits<<=1) {
3749         if ( m_bitsCandType & bits )
3750             SetCandidateWindow(iCandType, x-rc.left, y-rc.top);
3751     }
3752     if (m_bitsCandType != 0) {
3753         // REMIND: is there any chance GetProxyFocusOwner() returns NULL here?
3754         ::DefWindowProc(ImmGetHWnd(),
3755                         WM_IME_NOTIFY, IMN_OPENCANDIDATE, m_bitsCandType);
3756     }
3757 }
3758 
3759 void AwtComponent::SetCandidateWindow(int iCandType, int x, int y)
3760 {
3761     HWND hwnd = ImmGetHWnd();
3762     HIMC hIMC = ImmGetContext(hwnd);
3763     CANDIDATEFORM cf;
3764     cf.dwIndex = iCandType;
3765     cf.dwStyle = CFS_CANDIDATEPOS;
3766     cf.ptCurrentPos.x = x;
3767     cf.ptCurrentPos.y = y;
3768 
3769     ImmSetCandidateWindow(hIMC, &cf);
3770     ImmReleaseContext(hwnd, hIMC);
3771 }
3772 
3773 MsgRouting AwtComponent::WmImeSetContext(BOOL fSet, LPARAM *lplParam)
3774 {
3775     // If the Windows input context is disabled, do not let Windows
3776     // display any UIs.
3777     HWND hwnd = ImmGetHWnd();
3778     HIMC hIMC = ImmGetContext(hwnd);
3779     if (hIMC == NULL) {
3780         *lplParam = 0;
3781         return mrDoDefault;
3782     }
3783     ImmReleaseContext(hwnd, hIMC);
3784 
3785     if (fSet) {
3786         LPARAM lParam = *lplParam;
3787         if (!m_useNativeCompWindow) {
3788             // stop to draw native composing window.
3789             *lplParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
3790         }
3791     }
3792     return mrDoDefault;
3793 }
3794 
3795 MsgRouting AwtComponent::WmImeNotify(WPARAM subMsg, LPARAM bitsCandType)
3796 {
3797     if (!m_useNativeCompWindow && subMsg == IMN_OPENCANDIDATE) {
3798         m_bitsCandType = bitsCandType;
3799         InquireCandidatePosition();
3800         return mrConsume;
3801     }
3802     return mrDoDefault;
3803 }
3804 
3805 MsgRouting AwtComponent::WmImeStartComposition()
3806 {
3807     if (m_useNativeCompWindow) {
3808         RECT rc;
3809         ::GetClientRect(GetHWnd(), &rc);
3810         SetCompositionWindow(rc);
3811         return mrDoDefault;
3812     } else
3813         return mrConsume;
3814 }
3815 
3816 MsgRouting AwtComponent::WmImeEndComposition()
3817 {
3818     if (m_useNativeCompWindow)   return mrDoDefault;
3819 
3820     SendInputMethodEvent(
3821         java_awt_event_InputMethodEvent_INPUT_METHOD_TEXT_CHANGED,
3822         NULL, 0, NULL, NULL, 0, NULL, NULL, 0, 0, 0 );
3823     return mrConsume;
3824 }
3825 
3826 MsgRouting AwtComponent::WmImeComposition(WORD wChar, LPARAM flags)
3827 {
3828     if (m_useNativeCompWindow)   return mrDoDefault;
3829 
3830     int*      bndClauseW = NULL;
3831     jstring*  readingClauseW = NULL;
3832     int*      bndAttrW = NULL;
3833     BYTE*     valAttrW = NULL;
3834     int       cClauseW = 0;
3835     AwtInputTextInfor* textInfor = NULL;
3836 
3837     try {
3838         HWND hwnd = ImmGetHWnd();
3839         HIMC hIMC = ImmGetContext(hwnd);
3840         DASSERT(hIMC!=0);
3841 
3842         textInfor = new AwtInputTextInfor;
3843         textInfor->GetContextData(hIMC, flags);
3844         ImmReleaseContext(hwnd, hIMC);
3845 
3846         jstring jtextString = textInfor->GetText();
3847         /* The conditions to send the input method event to AWT EDT are:
3848            1. Whenever there is a composition message sent regarding whether
3849            the composition text is NULL or not. See details at bug 6222692.
3850            2. When there is a committed message sent, in which case, we have to
3851            check whether the committed string is NULL or not. If the committed string
3852            is NULL, there is no need to send any input method event.
3853            (Minor note: 'jtextString' returned is the merged string in the case of
3854            partial commit.)
3855         */
3856         if ((flags & GCS_RESULTSTR && jtextString != NULL) ||
3857             (flags & GCS_COMPSTR)) {
3858             int       cursorPosW = textInfor->GetCursorPosition();
3859             // In order not to delete the readingClauseW in the catch clause,
3860             // calling GetAttributeInfor before GetClauseInfor.
3861             int       cAttrW = textInfor->GetAttributeInfor(bndAttrW, valAttrW);
3862             cClauseW = textInfor->GetClauseInfor(bndClauseW, readingClauseW);
3863 
3864             /* Send INPUT_METHOD_TEXT_CHANGED event to the WInputMethod which in turn sends
3865                the event to AWT EDT.
3866 
3867                The last two paremeters are set to equal since we don't have recommendations for
3868                the visible position within the current composed text. See details at
3869                java.awt.event.InputMethodEvent.
3870             */
3871             SendInputMethodEvent(java_awt_event_InputMethodEvent_INPUT_METHOD_TEXT_CHANGED,
3872                                  jtextString,
3873                                  cClauseW, bndClauseW, readingClauseW,
3874                                  cAttrW, bndAttrW, valAttrW,
3875                                  textInfor->GetCommittedTextLength(),
3876                                  cursorPosW, cursorPosW);
3877         }
3878     } catch (...) {
3879         // since GetClauseInfor and GetAttributeInfor could throw exception, we have to release
3880         // the pointer here.
3881         delete [] bndClauseW;
3882         delete [] readingClauseW;
3883         delete [] bndAttrW;
3884         delete [] valAttrW;
3885         throw;
3886     }
3887 
3888     /* Free the storage allocated. Since jtextString won't be passed from threads
3889      *  to threads, we just use the local ref and it will be deleted within the destructor
3890      *  of AwtInputTextInfor object.
3891      */
3892     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3893     if (cClauseW && readingClauseW) {
3894         for (int i = 0; i < cClauseW; i ++) {
3895             if (readingClauseW[i]) {
3896                 env->DeleteLocalRef(readingClauseW[i]);
3897             }
3898         }
3899     }
3900     delete [] bndClauseW;
3901     delete [] readingClauseW;
3902     delete [] bndAttrW;
3903     delete [] valAttrW;
3904     delete textInfor;
3905 
3906     return mrConsume;
3907 }
3908 
3909 //
3910 // generate and post InputMethodEvent
3911 //
3912 void AwtComponent::SendInputMethodEvent(jint id, jstring text,
3913                                         int cClause, int* rgClauseBoundary, jstring* rgClauseReading,
3914                                         int cAttrBlock, int* rgAttrBoundary, BYTE *rgAttrValue,
3915                                         int commitedTextLength, int caretPos, int visiblePos)
3916 {
3917     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3918 
3919     // assumption for array type casting
3920     DASSERT(sizeof(int)==sizeof(jint));
3921     DASSERT(sizeof(BYTE)==sizeof(jbyte));
3922 
3923     // caluse information
3924     jintArray clauseBoundary = NULL;
3925     jobjectArray clauseReading = NULL;
3926     if (cClause && rgClauseBoundary && rgClauseReading) {
3927         // convert clause boundary offset array to java array
3928         clauseBoundary = env->NewIntArray(cClause+1);
3929         DASSERT(clauseBoundary);
3930         CHECK_NULL(clauseBoundary);
3931         env->SetIntArrayRegion(clauseBoundary, 0, cClause+1, (jint *)rgClauseBoundary);
3932         DASSERT(!safe_ExceptionOccurred(env));
3933 
3934         // convert clause reading string array to java array
3935         jclass stringCls = JNU_ClassString(env);
3936         DASSERT(stringCls);
3937         CHECK_NULL(stringCls);
3938         clauseReading = env->NewObjectArray(cClause, stringCls, NULL);
3939         DASSERT(clauseReading);
3940         CHECK_NULL(clauseReading);
3941         for (int i=0; i<cClause; i++)   env->SetObjectArrayElement(clauseReading, i, rgClauseReading[i]);
3942         DASSERT(!safe_ExceptionOccurred(env));
3943     }
3944 
3945 
3946     // attrubute value definition in WInputMethod.java must be equal to that in IMM.H
3947     DASSERT(ATTR_INPUT==sun_awt_windows_WInputMethod_ATTR_INPUT);
3948     DASSERT(ATTR_TARGET_CONVERTED==sun_awt_windows_WInputMethod_ATTR_TARGET_CONVERTED);
3949     DASSERT(ATTR_CONVERTED==sun_awt_windows_WInputMethod_ATTR_CONVERTED);
3950     DASSERT(ATTR_TARGET_NOTCONVERTED==sun_awt_windows_WInputMethod_ATTR_TARGET_NOTCONVERTED);
3951     DASSERT(ATTR_INPUT_ERROR==sun_awt_windows_WInputMethod_ATTR_INPUT_ERROR);
3952 
3953     // attribute information
3954     jintArray attrBoundary = NULL;
3955     jbyteArray attrValue = NULL;
3956     if (cAttrBlock && rgAttrBoundary && rgAttrValue) {
3957         // convert attribute boundary offset array to java array
3958         attrBoundary = env->NewIntArray(cAttrBlock+1);
3959         DASSERT(attrBoundary);
3960         CHECK_NULL(attrBoundary);
3961         env->SetIntArrayRegion(attrBoundary, 0, cAttrBlock+1, (jint *)rgAttrBoundary);
3962         DASSERT(!safe_ExceptionOccurred(env));
3963 
3964         // convert attribute value byte array to java array
3965         attrValue = env->NewByteArray(cAttrBlock);
3966         DASSERT(attrValue);
3967         CHECK_NULL(attrValue);
3968         env->SetByteArrayRegion(attrValue, 0, cAttrBlock, (jbyte *)rgAttrValue);
3969         DASSERT(!safe_ExceptionOccurred(env));
3970     }
3971 
3972 
3973     // get global reference of WInputMethod class (run only once)
3974     static jclass wInputMethodCls = NULL;
3975     if (wInputMethodCls == NULL) {
3976         jclass wInputMethodClsLocal = env->FindClass("sun/awt/windows/WInputMethod");
3977         DASSERT(wInputMethodClsLocal);
3978         CHECK_NULL(wInputMethodClsLocal);
3979         wInputMethodCls = (jclass)env->NewGlobalRef(wInputMethodClsLocal);
3980         env->DeleteLocalRef(wInputMethodClsLocal);
3981     }
3982 
3983     // get method ID of sendInputMethodEvent() (run only once)
3984     static jmethodID sendIMEventMid = 0;
3985     if (sendIMEventMid == 0) {
3986         sendIMEventMid =  env->GetMethodID(wInputMethodCls, "sendInputMethodEvent",
3987                                            "(IJLjava/lang/String;[I[Ljava/lang/String;[I[BIII)V");
3988         DASSERT(sendIMEventMid);
3989         CHECK_NULL(sendIMEventMid);
3990     }
3991 
3992     // call m_InputMethod.sendInputMethod()
3993     env->CallVoidMethod(m_InputMethod, sendIMEventMid, id, ::JVM_CurrentTimeMillis(NULL, 0),
3994                         text, clauseBoundary, clauseReading, attrBoundary,
3995                         attrValue, commitedTextLength, caretPos, visiblePos);
3996     if (safe_ExceptionOccurred(env))   env->ExceptionDescribe();
3997     DASSERT(!safe_ExceptionOccurred(env));
3998 
3999 }
4000 
4001 
4002 
4003 //
4004 // Inquires candidate position according to the composed text
4005 //
4006 void AwtComponent::InquireCandidatePosition()
4007 {
4008     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4009 
4010     // get global reference of WInputMethod class (run only once)
4011     static jclass wInputMethodCls = NULL;
4012     if (wInputMethodCls == NULL) {
4013         jclass wInputMethodClsLocal = env->FindClass("sun/awt/windows/WInputMethod");
4014         DASSERT(wInputMethodClsLocal);
4015         CHECK_NULL(wInputMethodClsLocal);
4016         wInputMethodCls = (jclass)env->NewGlobalRef(wInputMethodClsLocal);
4017         env->DeleteLocalRef(wInputMethodClsLocal);
4018     }
4019 
4020     // get method ID of sendInputMethodEvent() (run only once)
4021     static jmethodID inqCandPosMid = 0;
4022     if (inqCandPosMid == 0) {
4023         inqCandPosMid =  env->GetMethodID(wInputMethodCls, "inquireCandidatePosition", "()V");
4024         DASSERT(!safe_ExceptionOccurred(env));
4025         DASSERT(inqCandPosMid);
4026         CHECK_NULL(inqCandPosMid);
4027     }
4028 
4029     // call m_InputMethod.sendInputMethod()
4030     jobject candPos = env->CallObjectMethod(m_InputMethod, inqCandPosMid);
4031     DASSERT(!safe_ExceptionOccurred(env));
4032 }
4033 
4034 HWND AwtComponent::ImmGetHWnd()
4035 {
4036     HWND proxy = GetProxyFocusOwner();
4037     return (proxy != NULL) ? proxy : GetHWnd();
4038 }
4039 
4040 HIMC AwtComponent::ImmAssociateContext(HIMC himc)
4041 {
4042     return ::ImmAssociateContext(ImmGetHWnd(), himc);
4043 }
4044 
4045 HWND AwtComponent::GetProxyFocusOwner()
4046 {
4047     AwtWindow *window = GetContainer();
4048     if (window != 0) {
4049         AwtFrame *owner = window->GetOwningFrameOrDialog();
4050         if (owner != 0) {
4051             return owner->GetProxyFocusOwner();
4052         } else if (!window->IsSimpleWindow()) { // isn't an owned simple window
4053             return ((AwtFrame*)window)->GetProxyFocusOwner();
4054         }
4055     }
4056     return (HWND)NULL;
4057 }
4058 
4059 /* Call DefWindowProc for the focus proxy, if any */
4060 void AwtComponent::CallProxyDefWindowProc(UINT message, WPARAM wParam,
4061     LPARAM lParam, LRESULT &retVal, MsgRouting &mr)
4062 {
4063     if (mr != mrConsume)  {
4064         HWND proxy = GetProxyFocusOwner();
4065         if (proxy != NULL && ::IsWindowEnabled(proxy)) {
4066             retVal = ComCtl32Util::GetInstance().DefWindowProc(NULL, proxy, message, wParam, lParam);
4067             mr = mrConsume;
4068         }
4069     }
4070 }
4071 
4072 MsgRouting AwtComponent::WmCommand(UINT id, HWND hWndChild, UINT notifyCode)
4073 {
4074     /* Menu/Accelerator */
4075     if (hWndChild == 0) {
4076         AwtObject* obj = AwtToolkit::GetInstance().LookupCmdID(id);
4077         if (obj == NULL) {
4078             return mrConsume;
4079         }
4080         DASSERT(((AwtMenuItem*)obj)->GetID() == id);
4081         obj->DoCommand();
4082         return mrConsume;
4083     }
4084     /* Child id notification */
4085     else {
4086         AwtComponent* child = AwtComponent::GetComponent(hWndChild);
4087         if (child) {
4088             child->WmNotify(notifyCode);
4089         }
4090     }
4091     return mrDoDefault;
4092 }
4093 
4094 MsgRouting AwtComponent::WmNotify(UINT notifyCode)
4095 {
4096     return mrDoDefault;
4097 }
4098 
4099 MsgRouting AwtComponent::WmCompareItem(UINT ctrlId,
4100                                        COMPAREITEMSTRUCT &compareInfo,
4101                                        LRESULT &result)
4102 {
4103     AwtComponent* child = AwtComponent::GetComponent(compareInfo.hwndItem);
4104     if (child == this) {
4105         /* DoCallback("handleItemDelete", */
4106     }
4107     else if (child) {
4108         return child->WmCompareItem(ctrlId, compareInfo, result);
4109     }
4110     return mrConsume;
4111 }
4112 
4113 MsgRouting AwtComponent::WmDeleteItem(UINT ctrlId,
4114                                       DELETEITEMSTRUCT &deleteInfo)
4115 {
4116     /*
4117      * Workaround for NT 4.0 bug -- if SetWindowPos is called on a AwtList
4118      * window, a WM_DELETEITEM message is sent to its parent with a window
4119      * handle of one of the list's child windows.  The property lookup
4120      * succeeds, but the HWNDs don't match.
4121      */
4122     if (deleteInfo.hwndItem == NULL) {
4123         return mrConsume;
4124     }
4125     AwtComponent* child = (AwtComponent *)AwtComponent::GetComponent(deleteInfo.hwndItem);
4126 
4127     if (child && child->GetHWnd() != deleteInfo.hwndItem) {
4128         return mrConsume;
4129     }
4130 
4131     if (child == this) {
4132         /*DoCallback("handleItemDelete", */
4133     }
4134     else if (child) {
4135         return child->WmDeleteItem(ctrlId, deleteInfo);
4136     }
4137     return mrConsume;
4138 }
4139 
4140 MsgRouting AwtComponent::WmDrawItem(UINT ctrlId, DRAWITEMSTRUCT &drawInfo)
4141 {
4142     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4143 
4144     if (drawInfo.CtlType == ODT_MENU) {
4145         if (drawInfo.itemData != 0) {
4146             AwtMenu* menu = (AwtMenu*)(drawInfo.itemData);
4147             menu->DrawItem(drawInfo);
4148         }
4149     } else {
4150         return OwnerDrawItem(ctrlId, drawInfo);
4151     }
4152     return mrConsume;
4153 }
4154 
4155 MsgRouting AwtComponent::WmMeasureItem(UINT ctrlId,
4156                                        MEASUREITEMSTRUCT &measureInfo)
4157 {
4158     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4159 
4160     if (measureInfo.CtlType == ODT_MENU) {
4161         if (measureInfo.itemData != 0) {
4162             AwtMenu* menu = (AwtMenu*)(measureInfo.itemData);
4163             HDC hDC = ::GetDC(GetHWnd());
4164             /* menu->MeasureItem(env, hDC, measureInfo); */
4165             menu->MeasureItem(hDC, measureInfo);
4166             ::ReleaseDC(GetHWnd(), hDC);
4167         }
4168     } else {
4169         return OwnerMeasureItem(ctrlId, measureInfo);
4170     }
4171     return mrConsume;
4172 }
4173 
4174 MsgRouting AwtComponent::OwnerDrawItem(UINT ctrlId,
4175     DRAWITEMSTRUCT &drawInfo)
4176 {
4177     AwtComponent* child = AwtComponent::GetComponent(drawInfo.hwndItem);
4178     if (child == this) {
4179         /* DoCallback("handleItemDelete", */
4180     } else if (child != NULL) {
4181         return child->WmDrawItem(ctrlId, drawInfo);
4182     }
4183     return mrConsume;
4184 }
4185 
4186 MsgRouting AwtComponent::OwnerMeasureItem(UINT ctrlId,
4187     MEASUREITEMSTRUCT &measureInfo)
4188 {
4189     HWND  hChild = ::GetDlgItem(GetHWnd(), measureInfo.CtlID);
4190     AwtComponent* child = AwtComponent::GetComponent(hChild);
4191     /*
4192      * If the parent cannot find the child's instance from its handle,
4193      * maybe the child is in its creation.  So the child must be searched
4194      * from the list linked before the child's creation.
4195      */
4196     if (child == NULL) {
4197         child = SearchChild((UINT)ctrlId);
4198     }
4199 
4200     if (child == this) {
4201     /* DoCallback("handleItemDelete",  */
4202     }
4203     else if (child) {
4204         return child->WmMeasureItem(ctrlId, measureInfo);
4205     }
4206     return mrConsume;
4207 }
4208 
4209 /* for WmDrawItem method of Label, Button and Checkbox */
4210 void AwtComponent::DrawWindowText(HDC hDC, jobject font, jstring text,
4211                                   int x, int y)
4212 {
4213     int nOldBkMode = ::SetBkMode(hDC,TRANSPARENT);
4214     DASSERT(nOldBkMode != 0);
4215     AwtFont::drawMFString(hDC, font, text, x, y, GetCodePage());
4216     VERIFY(::SetBkMode(hDC,nOldBkMode));
4217 }
4218 
4219 /*
4220  * Draw text in gray (the color being set to COLOR_GRAYTEXT) when the
4221  * component is disabled.  Used only for label, checkbox and button in
4222  * OWNER_DRAW.  It draws the text in emboss.
4223  */
4224 void AwtComponent::DrawGrayText(HDC hDC, jobject font, jstring text,
4225                                 int x, int y)
4226 {
4227     ::SetTextColor(hDC, ::GetSysColor(COLOR_BTNHILIGHT));
4228     AwtComponent::DrawWindowText(hDC, font, text, x+1, y+1);
4229     ::SetTextColor(hDC, ::GetSysColor(COLOR_BTNSHADOW));
4230     AwtComponent::DrawWindowText(hDC, font, text, x, y);
4231 }
4232 
4233 /* for WmMeasureItem method of List and Choice */
4234 jstring AwtComponent::GetItemString(JNIEnv *env, jobject target, jint index)
4235 {
4236     jstring str = (jstring)JNU_CallMethodByName(env, NULL, target, "getItemImpl",
4237                                                 "(I)Ljava/lang/String;",
4238                                                 index).l;
4239     DASSERT(!safe_ExceptionOccurred(env));
4240     return str;
4241 }
4242 
4243 /* for WmMeasureItem method of List and Choice */
4244 void AwtComponent::MeasureListItem(JNIEnv *env,
4245                                    MEASUREITEMSTRUCT &measureInfo)
4246 {
4247     if (env->EnsureLocalCapacity(1) < 0) {
4248         return;
4249     }
4250     jobject dimension = PreferredItemSize(env);
4251     DASSERT(dimension);
4252     measureInfo.itemWidth =
4253       env->GetIntField(dimension, AwtDimension::widthID);
4254     measureInfo.itemHeight =
4255       env->GetIntField(dimension, AwtDimension::heightID);
4256     env->DeleteLocalRef(dimension);
4257 }
4258 
4259 /* for WmDrawItem method of List and Choice */
4260 void AwtComponent::DrawListItem(JNIEnv *env, DRAWITEMSTRUCT &drawInfo)
4261 {
4262     if (env->EnsureLocalCapacity(3) < 0) {
4263         return;
4264     }
4265     jobject peer = GetPeer(env);
4266     jobject target = env->GetObjectField(peer, AwtObject::targetID);
4267 
4268     HDC hDC = drawInfo.hDC;
4269     RECT rect = drawInfo.rcItem;
4270 
4271     BOOL bEnabled = isEnabled();
4272     BOOL unfocusableChoice = (drawInfo.itemState & ODS_COMBOBOXEDIT) && !IsFocusable();
4273     DWORD crBack, crText;
4274     if (drawInfo.itemState & ODS_SELECTED){
4275         /* Set background and text colors for selected item */
4276         crBack = ::GetSysColor (COLOR_HIGHLIGHT);
4277         crText = ::GetSysColor (COLOR_HIGHLIGHTTEXT);
4278     } else {
4279         /* Set background and text colors for unselected item */
4280         crBack = GetBackgroundColor();
4281         crText = bEnabled ? GetColor() : ::GetSysColor(COLOR_GRAYTEXT);
4282     }
4283     if (unfocusableChoice) {
4284         //6190728. Shouldn't draw selection field (edit control) of an owner-drawn combo box.
4285         crBack = GetBackgroundColor();
4286         crText = bEnabled ? GetColor() : ::GetSysColor(COLOR_GRAYTEXT);
4287     }
4288 
4289     /* Fill item rectangle with background color */
4290     HBRUSH hbrBack = ::CreateSolidBrush (crBack);
4291     DASSERT(hbrBack);
4292     /* 6190728. Shouldn't draw any kind of rectangle around selection field
4293      * (edit control) of an owner-drawn combo box while unfocusable
4294      */
4295     if (!unfocusableChoice){
4296         VERIFY(::FillRect (hDC, &rect, hbrBack));
4297     }
4298     VERIFY(::DeleteObject (hbrBack));
4299 
4300     /* Set current background and text colors */
4301     ::SetBkColor (hDC, crBack);
4302     ::SetTextColor (hDC, crText);
4303 
4304     /*draw string (with left margin of 1 point) */
4305     if ((int) (drawInfo.itemID) >= 0) {
4306             jobject font = GET_FONT(target, peer);
4307             jstring text = GetItemString(env, target, drawInfo.itemID);
4308             if (env->ExceptionCheck()) {
4309                 env->DeleteLocalRef(font);
4310                 env->DeleteLocalRef(target);
4311                 return;
4312             }
4313             SIZE size = AwtFont::getMFStringSize(hDC, font, text);
4314             AwtFont::drawMFString(hDC, font, text,
4315                                   (GetRTL()) ? rect.right - size.cx - 1
4316                                              : rect.left + 1,
4317                                   (rect.top + rect.bottom - size.cy) / 2,
4318                                   GetCodePage());
4319             env->DeleteLocalRef(font);
4320             env->DeleteLocalRef(text);
4321     }
4322     if ((drawInfo.itemState & ODS_FOCUS)  &&
4323         (drawInfo.itemAction & (ODA_FOCUS | ODA_DRAWENTIRE))) {
4324       if (!unfocusableChoice){
4325           VERIFY(::DrawFocusRect(hDC, &rect));
4326       }
4327     }
4328     env->DeleteLocalRef(target);
4329 }
4330 
4331 /* for MeasureListItem method and WmDrawItem method of Checkbox */
4332 jint AwtComponent::GetFontHeight(JNIEnv *env)
4333 {
4334     if (env->EnsureLocalCapacity(4) < 0) {
4335         return NULL;
4336     }
4337     jobject self = GetPeer(env);
4338     jobject target = env->GetObjectField(self, AwtObject::targetID);
4339 
4340     jobject font = GET_FONT(target, self);
4341     jobject toolkit = env->CallObjectMethod(target,
4342                                             AwtComponent::getToolkitMID);
4343 
4344     DASSERT(!safe_ExceptionOccurred(env));
4345 
4346     jobject fontMetrics =
4347         env->CallObjectMethod(toolkit, AwtToolkit::getFontMetricsMID, font);
4348 
4349     DASSERT(!safe_ExceptionOccurred(env));
4350 
4351     jint height = env->CallIntMethod(fontMetrics, AwtFont::getHeightMID);
4352     DASSERT(!safe_ExceptionOccurred(env));
4353 
4354     env->DeleteLocalRef(target);
4355     env->DeleteLocalRef(font);
4356     env->DeleteLocalRef(toolkit);
4357     env->DeleteLocalRef(fontMetrics);
4358 
4359     return height;
4360 }
4361 
4362 // If you override WmPrint, make sure to save a copy of the DC on the GDI
4363 // stack to be restored in WmPrintClient. Windows mangles the DC in
4364 // ::DefWindowProc.
4365 MsgRouting AwtComponent::WmPrint(HDC hDC, LPARAM flags)
4366 {
4367     /*
4368      * DefWindowProc for WM_PRINT changes DC parameters, so we have
4369      * to restore it ourselves. Otherwise it will cause problems
4370      * when several components are printed to the same DC.
4371      */
4372     int nOriginalDC = ::SaveDC(hDC);
4373     DASSERT(nOriginalDC != 0);
4374 
4375     if (flags & PRF_NONCLIENT) {
4376 
4377         VERIFY(::SaveDC(hDC));
4378 
4379         DefWindowProc(WM_PRINT, (WPARAM)hDC,
4380                       (flags & (PRF_NONCLIENT
4381                                 | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
4382 
4383         VERIFY(::RestoreDC(hDC, -1));
4384 
4385         // Special case for components with a sunken border. Windows does not
4386         // print the border correctly on PCL printers, so we have to do it ourselves.
4387         if (GetStyleEx() & WS_EX_CLIENTEDGE) {
4388             RECT r;
4389             VERIFY(::GetWindowRect(GetHWnd(), &r));
4390             VERIFY(::OffsetRect(&r, -r.left, -r.top));
4391             VERIFY(::DrawEdge(hDC, &r, EDGE_SUNKEN, BF_RECT));
4392         }
4393     }
4394 
4395     if (flags & PRF_CLIENT) {
4396 
4397         /*
4398          * Special case for components with a sunken border.
4399          * Windows prints a client area without offset to a border width.
4400          * We will first print the non-client area with the original offset,
4401          * then the client area with a corrected offset.
4402          */
4403         if (GetStyleEx() & WS_EX_CLIENTEDGE) {
4404 
4405             int nEdgeWidth = ::GetSystemMetrics(SM_CXEDGE);
4406             int nEdgeHeight = ::GetSystemMetrics(SM_CYEDGE);
4407 
4408             VERIFY(::OffsetWindowOrgEx(hDC, -nEdgeWidth, -nEdgeHeight, NULL));
4409 
4410             // Save a copy of the DC for WmPrintClient
4411             VERIFY(::SaveDC(hDC));
4412 
4413             DefWindowProc(WM_PRINT, (WPARAM) hDC,
4414                           (flags & (PRF_CLIENT
4415                                     | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
4416 
4417             VERIFY(::OffsetWindowOrgEx(hDC, nEdgeWidth, nEdgeHeight, NULL));
4418 
4419         } else {
4420 
4421             // Save a copy of the DC for WmPrintClient
4422             VERIFY(::SaveDC(hDC));
4423             DefWindowProc(WM_PRINT, (WPARAM) hDC,
4424                           (flags & (PRF_CLIENT
4425                                     | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
4426         }
4427     }
4428 
4429     if (flags & (PRF_CHILDREN | PRF_OWNED)) {
4430         DefWindowProc(WM_PRINT, (WPARAM) hDC,
4431                       (flags & ~PRF_CLIENT & ~PRF_NONCLIENT));
4432     }
4433 
4434     VERIFY(::RestoreDC(hDC, nOriginalDC));
4435 
4436     return mrConsume;
4437 }
4438 
4439 // If you override WmPrintClient, make sure to obtain a valid copy of
4440 // the DC from the GDI stack. The copy of the DC should have been placed
4441 // there by WmPrint. Windows mangles the DC in ::DefWindowProc.
4442 MsgRouting AwtComponent::WmPrintClient(HDC hDC, LPARAM)
4443 {
4444     // obtain valid DC from GDI stack
4445     ::RestoreDC(hDC, -1);
4446 
4447     return mrDoDefault;
4448 }
4449 
4450 MsgRouting AwtComponent::WmNcCalcSize(BOOL fCalcValidRects,
4451                                       LPNCCALCSIZE_PARAMS lpncsp,
4452                                       LRESULT &retVal)
4453 {
4454     return mrDoDefault;
4455 }
4456 
4457 MsgRouting AwtComponent::WmNcPaint(HRGN hrgn)
4458 {
4459     return mrDoDefault;
4460 }
4461 
4462 MsgRouting AwtComponent::WmNcHitTest(UINT x, UINT y, LRESULT &retVal)
4463 {
4464     return mrDoDefault;
4465 }
4466 
4467 /**
4468  * WmQueryNewPalette is called whenever our component is coming to
4469  * the foreground; this gives us an opportunity to install our
4470  * custom palette.  If this install actually changes entries in
4471  * the system palette, then we get a further call to WmPaletteChanged
4472  * (but note that we only need to realize our palette once).
4473  */
4474 MsgRouting AwtComponent::WmQueryNewPalette(LRESULT &retVal)
4475 {
4476     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
4477     m_QueryNewPaletteCalled = TRUE;
4478     HDC hDC = ::GetDC(GetHWnd());
4479     DASSERT(hDC);
4480     AwtWin32GraphicsDevice::SelectPalette(hDC, screen);
4481     AwtWin32GraphicsDevice::RealizePalette(hDC, screen);
4482     ::ReleaseDC(GetHWnd(), hDC);
4483     // We must realize the palettes of all of our DC's
4484     // There is sometimes a problem where the realization of
4485     // our temporary hDC here does not actually do what
4486     // we want.  Not clear why, but presumably fallout from
4487     // our use of several simultaneous hDC's.
4488     activeDCList.RealizePalettes(screen);
4489     // Do not invalidate here; if the palette
4490     // has not changed we will get an extra repaint
4491     retVal = TRUE;
4492 
4493     return mrDoDefault;
4494 }
4495 
4496 /**
4497  * We should not need to track this event since we handle our
4498  * palette management effectively in the WmQueryNewPalette and
4499  * WmPaletteChanged methods.  However, there seems to be a bug
4500  * on some win32 systems (e.g., NT4) whereby the palette
4501  * immediately after a displayChange is not yet updated to its
4502  * final post-display-change values (hence we adjust our palette
4503  * using the wrong system palette entries), then the palette is
4504  * updated, but a WM_PALETTECHANGED message is never sent.
4505  * By tracking the ISCHANGING message as well (and by tracking
4506  * displayChange events in the AwtToolkit object), we can account
4507  * for this error by forcing our WmPaletteChanged method to be
4508  * called and thereby realizing our logical palette and updating
4509  * our dynamic colorModel object.
4510  */
4511 MsgRouting AwtComponent::WmPaletteIsChanging(HWND hwndPalChg)
4512 {
4513     if (AwtToolkit::GetInstance().HasDisplayChanged()) {
4514         WmPaletteChanged(hwndPalChg);
4515         AwtToolkit::GetInstance().ResetDisplayChanged();
4516     }
4517     return mrDoDefault;
4518 }
4519 
4520 MsgRouting AwtComponent::WmPaletteChanged(HWND hwndPalChg)
4521 {
4522     // We need to re-realize our palette here (unless we're the one
4523     // that was realizing it in the first place).  That will let us match the
4524     // remaining colors in the system palette as best we can.  We always
4525     // invalidate because the palette will have changed when we receive this
4526     // message.
4527 
4528     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
4529     if (hwndPalChg != GetHWnd()) {
4530         HDC hDC = ::GetDC(GetHWnd());
4531         DASSERT(hDC);
4532         AwtWin32GraphicsDevice::SelectPalette(hDC, screen);
4533         AwtWin32GraphicsDevice::RealizePalette(hDC, screen);
4534         ::ReleaseDC(GetHWnd(), hDC);
4535         // We must realize the palettes of all of our DC's
4536         activeDCList.RealizePalettes(screen);
4537     }
4538     if (AwtWin32GraphicsDevice::UpdateSystemPalette(screen)) {
4539         AwtWin32GraphicsDevice::UpdateDynamicColorModel(screen);
4540     }
4541     Invalidate(NULL);
4542     return mrDoDefault;
4543 }
4544 
4545 MsgRouting AwtComponent::WmStyleChanged(int wStyleType, LPSTYLESTRUCT lpss)
4546 {
4547     DASSERT(!IsBadReadPtr(lpss, sizeof(STYLESTRUCT)));
4548     return mrDoDefault;
4549 }
4550 
4551 MsgRouting AwtComponent::WmSettingChange(UINT wFlag, LPCTSTR pszSection)
4552 {
4553     DASSERT(!IsBadStringPtr(pszSection, 20));
4554     DTRACE_PRINTLN2("WM_SETTINGCHANGE: wFlag=%d pszSection=%s", (int)wFlag, pszSection);
4555     return mrDoDefault;
4556 }
4557 
4558 HDC AwtComponent::GetDCFromComponent()
4559 {
4560     GetDCReturnStruct *hdcStruct =
4561         (GetDCReturnStruct*)SendMessage(WM_AWT_GETDC);
4562     HDC hdc;
4563     if (hdcStruct) {
4564         if (hdcStruct->gdiLimitReached) {
4565             if (jvm != NULL) {
4566                 JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4567                 if (env != NULL && !safe_ExceptionOccurred(env)) {
4568                     JNU_ThrowByName(env, "java/awt/AWTError",
4569                         "HDC creation failure - " \
4570                         "exceeded maximum GDI resources");
4571                 }
4572             }
4573         }
4574         hdc = hdcStruct->hDC;
4575         delete hdcStruct;
4576     } else {
4577         hdc = NULL;
4578     }
4579     return hdc;
4580 }
4581 
4582 void AwtComponent::FillBackground(HDC hMemoryDC, SIZE &size)
4583 {
4584     RECT eraseR = { 0, 0, size.cx, size.cy };
4585     VERIFY(::FillRect(hMemoryDC, &eraseR, GetBackgroundBrush()));
4586 }
4587 
4588 void AwtComponent::FillAlpha(void *bitmapBits, SIZE &size, BYTE alpha)
4589 {
4590     if (!bitmapBits) {
4591         return;
4592     }
4593 
4594     DWORD* dest = (DWORD*)bitmapBits;
4595     //XXX: might be optimized to use one loop (cy*cx -> 0)
4596     for (int i = 0; i < size.cy; i++ ) {
4597         for (int j = 0; j < size.cx; j++ ) {
4598             ((BYTE*)(dest++))[3] = alpha;
4599         }
4600     }
4601 }
4602 
4603 jintArray AwtComponent::CreatePrintedPixels(SIZE &loc, SIZE &size, int alpha) {
4604     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4605 
4606     if (!::IsWindowVisible(GetHWnd())) {
4607         return NULL;
4608     }
4609 
4610     HDC hdc = GetDCFromComponent();
4611     if (!hdc) {
4612         return NULL;
4613     }
4614     HDC hMemoryDC = ::CreateCompatibleDC(hdc);
4615     void *bitmapBits = NULL;
4616     HBITMAP hBitmap = BitmapUtil::CreateARGBBitmap(size.cx, size.cy, &bitmapBits);
4617     HBITMAP hOldBitmap = (HBITMAP)::SelectObject(hMemoryDC, hBitmap);
4618     SendMessage(WM_AWT_RELEASEDC, (WPARAM)hdc);
4619 
4620     FillBackground(hMemoryDC, size);
4621 
4622     VERIFY(::SetWindowOrgEx(hMemoryDC, loc.cx, loc.cy, NULL));
4623 
4624     // Don't bother with PRF_CHECKVISIBLE because we called IsWindowVisible
4625     // above.
4626     SendMessage(WM_PRINT, (WPARAM)hMemoryDC, PRF_CLIENT | PRF_NONCLIENT);
4627 
4628     // First make sure the system completed any drawing to the bitmap.
4629     ::GdiFlush();
4630 
4631     // WM_PRINT does not fill the alpha-channel of the ARGB bitmap
4632     // leaving it equal to zero. Hence we need to fill it manually. Otherwise
4633     // the pixels will be considered transparent when interpreting the data.
4634     FillAlpha(bitmapBits, size, alpha);
4635 
4636     ::SelectObject(hMemoryDC, hOldBitmap);
4637 
4638     BITMAPINFO bmi;
4639     memset(&bmi, 0, sizeof(BITMAPINFO));
4640     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
4641     bmi.bmiHeader.biWidth = size.cx;
4642     bmi.bmiHeader.biHeight = -size.cy;
4643     bmi.bmiHeader.biPlanes = 1;
4644     bmi.bmiHeader.biBitCount = 32;
4645     bmi.bmiHeader.biCompression = BI_RGB;
4646 
4647     jobject localPixelArray = env->NewIntArray(size.cx * size.cy);
4648     jintArray pixelArray = NULL;
4649     if (localPixelArray != NULL) {
4650         pixelArray = (jintArray)env->NewGlobalRef(localPixelArray);
4651         env->DeleteLocalRef(localPixelArray); localPixelArray = NULL;
4652 
4653         jboolean isCopy;
4654         jint *pixels = env->GetIntArrayElements(pixelArray, &isCopy);
4655 
4656         ::GetDIBits(hMemoryDC, hBitmap, 0, size.cy, (LPVOID)pixels, &bmi,
4657                     DIB_RGB_COLORS);
4658 
4659         env->ReleaseIntArrayElements(pixelArray, pixels, 0);
4660     }
4661 
4662     VERIFY(::DeleteObject(hBitmap));
4663     VERIFY(::DeleteDC(hMemoryDC));
4664 
4665     return pixelArray;
4666 }
4667 
4668 void* AwtComponent::SetNativeFocusOwner(void *self) {
4669     if (self == NULL) {
4670         // It means that the KFM wants to set focus to null
4671         sm_focusOwner = NULL;
4672         return NULL;
4673     }
4674 
4675     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4676 
4677     AwtComponent *c = NULL;
4678     jobject peer = (jobject)self;
4679 
4680     PDATA pData;
4681     JNI_CHECK_NULL_GOTO(peer, "peer", ret);
4682     pData = JNI_GET_PDATA(peer);
4683     if (pData == NULL) {
4684         goto ret;
4685     }
4686     c = (AwtComponent *)pData;
4687 
4688 ret:
4689     if (c && ::IsWindow(c->GetHWnd())) {
4690         sm_focusOwner = c->GetHWnd();
4691     } else {
4692         sm_focusOwner = NULL;
4693     }
4694     env->DeleteGlobalRef(peer);
4695     return NULL;
4696 }
4697 
4698 void* AwtComponent::GetNativeFocusedWindow() {
4699     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4700     AwtComponent *comp =
4701         AwtComponent::GetComponent(AwtComponent::GetFocusedWindow());
4702     return (comp != NULL) ? comp->GetTargetAsGlobalRef(env) : NULL;
4703 }
4704 
4705 void* AwtComponent::GetNativeFocusOwner() {
4706     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4707     AwtComponent *comp =
4708         AwtComponent::GetComponent(AwtComponent::sm_focusOwner);
4709     return (comp != NULL) ? comp->GetTargetAsGlobalRef(env) : NULL;
4710 }
4711 
4712 AwtComponent* AwtComponent::SearchChild(UINT id) {
4713     ChildListItem* child;
4714     for (child = m_childList; child != NULL;child = child->m_next) {
4715         if (child->m_ID == id)
4716             return child->m_Component;
4717     }
4718     /*
4719      * DASSERT(FALSE);
4720      * This should not be happend if all children are recorded
4721      */
4722     return NULL;        /* make compiler happy */
4723 }
4724 
4725 void AwtComponent::RemoveChild(UINT id) {
4726     ChildListItem* child = m_childList;
4727     ChildListItem* lastChild = NULL;
4728     while (child != NULL) {
4729         if (child->m_ID == id) {
4730             if (lastChild == NULL) {
4731                 m_childList = child->m_next;
4732             } else {
4733                 lastChild->m_next = child->m_next;
4734             }
4735             child->m_next = NULL;
4736             DASSERT(child != NULL);
4737             delete child;
4738             return;
4739         }
4740         lastChild = child;
4741         child = child->m_next;
4742     }
4743 }
4744 
4745 void AwtComponent::SendKeyEvent(jint id, jlong when, jint raw, jint cooked,
4746                                 jint modifiers, jint keyLocation, jlong nativeCode, MSG *pMsg)
4747 {
4748     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4749     CriticalSection::Lock l(GetLock());
4750     if (GetPeer(env) == NULL) {
4751         /* event received during termination. */
4752         return;
4753     }
4754 
4755     static jclass keyEventCls;
4756     if (keyEventCls == NULL) {
4757         jclass keyEventClsLocal = env->FindClass("java/awt/event/KeyEvent");
4758         DASSERT(keyEventClsLocal);
4759         if (keyEventClsLocal == NULL) {
4760             /* exception already thrown */
4761             return;
4762         }
4763         keyEventCls = (jclass)env->NewGlobalRef(keyEventClsLocal);
4764         env->DeleteLocalRef(keyEventClsLocal);
4765     }
4766 
4767     static jmethodID keyEventConst;
4768     if (keyEventConst == NULL) {
4769         keyEventConst =  env->GetMethodID(keyEventCls, "<init>",
4770                                           "(Ljava/awt/Component;IJIICI)V");
4771         DASSERT(keyEventConst);
4772         CHECK_NULL(keyEventConst);
4773     }
4774     if (env->EnsureLocalCapacity(2) < 0) {
4775         return;
4776     }
4777     jobject target = GetTarget(env);
4778     jobject keyEvent = env->NewObject(keyEventCls, keyEventConst, target,
4779                                       id, when, modifiers, raw, cooked,
4780                                       keyLocation);
4781     if (safe_ExceptionOccurred(env)) env->ExceptionDescribe();
4782     DASSERT(!safe_ExceptionOccurred(env));
4783     DASSERT(keyEvent != NULL);
4784     if (keyEvent == NULL) {
4785         env->DeleteLocalRef(target);
4786         return;
4787     }
4788     env->SetLongField(keyEvent, AwtKeyEvent::rawCodeID, nativeCode);
4789     if( nativeCode && nativeCode < 256 ) {
4790         env->SetLongField(keyEvent, AwtKeyEvent::primaryLevelUnicodeID, (jlong)(dynPrimaryKeymap[nativeCode].unicode));
4791         env->SetLongField(keyEvent, AwtKeyEvent::extendedKeyCodeID, (jlong)(dynPrimaryKeymap[nativeCode].jkey));
4792         if( nativeCode < 255 ) {
4793             env->SetLongField(keyEvent, AwtKeyEvent::scancodeID, (jlong)(dynPrimaryKeymap[nativeCode].scancode));
4794         }else if( pMsg != NULL ) {
4795             // unknown key with virtual keycode 0xFF.
4796             // Its scancode is not in the table, pickup it from the message.
4797             env->SetLongField(keyEvent, AwtKeyEvent::scancodeID, (jlong)(HIWORD(pMsg->lParam) & 0xFF));
4798         }
4799     }
4800     if (pMsg != NULL) {
4801         AwtAWTEvent::saveMSG(env, pMsg, keyEvent);
4802     }
4803     SendEvent(keyEvent);
4804 
4805     env->DeleteLocalRef(keyEvent);
4806     env->DeleteLocalRef(target);
4807 }
4808 
4809 void
4810 AwtComponent::SendKeyEventToFocusOwner(jint id, jlong when,
4811                                        jint raw, jint cooked,
4812                                        jint modifiers, jint keyLocation,
4813                                        jlong nativeCode,
4814                                        MSG *msg)
4815 {
4816     /*
4817      * if focus owner is null, but focused window isn't
4818      * we will send key event to focused window
4819      */
4820     HWND hwndTarget = ((sm_focusOwner != NULL) ? sm_focusOwner : AwtComponent::GetFocusedWindow());
4821 
4822     if (hwndTarget == GetHWnd()) {
4823         SendKeyEvent(id, when, raw, cooked, modifiers, keyLocation, nativeCode, msg);
4824     } else {
4825         AwtComponent *target = NULL;
4826         if (hwndTarget != NULL) {
4827             target = AwtComponent::GetComponent(hwndTarget);
4828             if (target == NULL) {
4829                 target = this;
4830             }
4831         }
4832         if (target != NULL) {
4833             target->SendKeyEvent(id, when, raw, cooked, modifiers,
4834               keyLocation, nativeCode, msg);
4835         }
4836     }
4837 }
4838 
4839 void AwtComponent::SetDragCapture(UINT flags)
4840 {
4841     // don't want to interfere with other controls
4842     if (::GetCapture() == NULL) {
4843         ::SetCapture(GetHWnd());
4844     }
4845 }
4846 
4847 void AwtComponent::ReleaseDragCapture(UINT flags)
4848 {
4849     if ((::GetCapture() == GetHWnd()) && ((flags & ALL_MK_BUTTONS) == 0)) {
4850         // user has released all buttons, so release the capture
4851         ::ReleaseCapture();
4852     }
4853 }
4854 
4855 void AwtComponent::SendMouseEvent(jint id, jlong when, jint x, jint y,
4856                                   jint modifiers, jint clickCount,
4857                                   jboolean popupTrigger, jint button,
4858                                   MSG *pMsg)
4859 {
4860     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4861     CriticalSection::Lock l(GetLock());
4862     if (GetPeer(env) == NULL) {
4863         /* event received during termination. */
4864         return;
4865     }
4866 
4867     static jclass mouseEventCls;
4868     if (mouseEventCls == NULL) {
4869         jclass mouseEventClsLocal =
4870             env->FindClass("java/awt/event/MouseEvent");
4871         CHECK_NULL(mouseEventClsLocal);
4872         mouseEventCls = (jclass)env->NewGlobalRef(mouseEventClsLocal);
4873         env->DeleteLocalRef(mouseEventClsLocal);
4874     }
4875     RECT insets;
4876     GetInsets(&insets);
4877 
4878     static jmethodID mouseEventConst;
4879     if (mouseEventConst == NULL) {
4880         mouseEventConst =
4881             env->GetMethodID(mouseEventCls, "<init>",
4882                  "(Ljava/awt/Component;IJIIIIIIZI)V");
4883         DASSERT(mouseEventConst);
4884         CHECK_NULL(mouseEventConst);
4885     }
4886     if (env->EnsureLocalCapacity(2) < 0) {
4887         return;
4888     }
4889     jobject target = GetTarget(env);
4890     DWORD curMousePos = ::GetMessagePos();
4891     int xAbs = GET_X_LPARAM(curMousePos);
4892     int yAbs = GET_Y_LPARAM(curMousePos);
4893     jobject mouseEvent = env->NewObject(mouseEventCls, mouseEventConst,
4894                                         target,
4895                                         id, when, modifiers,
4896                                         x+insets.left, y+insets.top,
4897                                         xAbs, yAbs,
4898                                         clickCount, popupTrigger, button);
4899 
4900     if (safe_ExceptionOccurred(env)) {
4901         env->ExceptionDescribe();
4902         env->ExceptionClear();
4903     }
4904 
4905     DASSERT(mouseEvent != NULL);
4906     CHECK_NULL(mouseEvent);
4907     if (pMsg != 0) {
4908         AwtAWTEvent::saveMSG(env, pMsg, mouseEvent);
4909     }
4910     SendEvent(mouseEvent);
4911 
4912     env->DeleteLocalRef(mouseEvent);
4913     env->DeleteLocalRef(target);
4914 }
4915 
4916 void
4917 AwtComponent::SendMouseWheelEvent(jint id, jlong when, jint x, jint y,
4918                                   jint modifiers, jint clickCount,
4919                                   jboolean popupTrigger, jint scrollType,
4920                                   jint scrollAmount, jint roundedWheelRotation,
4921                                   jdouble preciseWheelRotation, MSG *pMsg)
4922 {
4923     /* Code based not so loosely on AwtComponent::SendMouseEvent */
4924     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4925     CriticalSection::Lock l(GetLock());
4926     if (GetPeer(env) == NULL) {
4927         /* event received during termination. */
4928         return;
4929     }
4930 
4931     static jclass mouseWheelEventCls;
4932     if (mouseWheelEventCls == NULL) {
4933         jclass mouseWheelEventClsLocal =
4934             env->FindClass("java/awt/event/MouseWheelEvent");
4935         CHECK_NULL(mouseWheelEventClsLocal);
4936         mouseWheelEventCls = (jclass)env->NewGlobalRef(mouseWheelEventClsLocal);
4937         env->DeleteLocalRef(mouseWheelEventClsLocal);
4938     }
4939     RECT insets;
4940     GetInsets(&insets);
4941 
4942     static jmethodID mouseWheelEventConst;
4943     if (mouseWheelEventConst == NULL) {
4944         mouseWheelEventConst =
4945             env->GetMethodID(mouseWheelEventCls, "<init>",
4946                            "(Ljava/awt/Component;IJIIIIIIZIIID)V");
4947         DASSERT(mouseWheelEventConst);
4948         CHECK_NULL(mouseWheelEventConst);
4949     }
4950     if (env->EnsureLocalCapacity(2) < 0) {
4951         return;
4952     }
4953     jobject target = GetTarget(env);
4954     DTRACE_PRINTLN("creating MWE in JNI");
4955 
4956     jobject mouseWheelEvent = env->NewObject(mouseWheelEventCls,
4957                                              mouseWheelEventConst,
4958                                              target,
4959                                              id, when, modifiers,
4960                                              x+insets.left, y+insets.top,
4961                                              0, 0,
4962                                              clickCount, popupTrigger,
4963                                              scrollType, scrollAmount,
4964                                              roundedWheelRotation, preciseWheelRotation);
4965 
4966     DASSERT(mouseWheelEvent != NULL);
4967     if (mouseWheelEvent == NULL || safe_ExceptionOccurred(env)) {
4968         env->ExceptionDescribe();
4969         env->ExceptionClear();
4970         env->DeleteLocalRef(target);
4971         return;
4972     }
4973     if (pMsg != NULL) {
4974         AwtAWTEvent::saveMSG(env, pMsg, mouseWheelEvent);
4975     }
4976     SendEvent(mouseWheelEvent);
4977 
4978     env->DeleteLocalRef(mouseWheelEvent);
4979     env->DeleteLocalRef(target);
4980 }
4981 
4982 void AwtComponent::SendFocusEvent(jint id, HWND opposite)
4983 {
4984     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4985 
4986     CriticalSection::Lock l(GetLock());
4987     if (GetPeer(env) == NULL) {
4988         /* event received during termination. */
4989         return;
4990     }
4991 
4992     static jclass focusEventCls;
4993     if (focusEventCls == NULL) {
4994         jclass focusEventClsLocal
4995             = env->FindClass("java/awt/event/FocusEvent");
4996         DASSERT(focusEventClsLocal);
4997         CHECK_NULL(focusEventClsLocal);
4998         focusEventCls = (jclass)env->NewGlobalRef(focusEventClsLocal);
4999         env->DeleteLocalRef(focusEventClsLocal);
5000     }
5001 
5002     static jmethodID focusEventConst;
5003     if (focusEventConst == NULL) {
5004         focusEventConst =
5005             env->GetMethodID(focusEventCls, "<init>",
5006                              "(Ljava/awt/Component;IZLjava/awt/Component;)V");
5007         DASSERT(focusEventConst);
5008         CHECK_NULL(focusEventConst);
5009     }
5010 
5011     static jclass sequencedEventCls;
5012     if (sequencedEventCls == NULL) {
5013         jclass sequencedEventClsLocal =
5014             env->FindClass("java/awt/SequencedEvent");
5015         DASSERT(sequencedEventClsLocal);
5016         CHECK_NULL(sequencedEventClsLocal);
5017         sequencedEventCls =
5018             (jclass)env->NewGlobalRef(sequencedEventClsLocal);
5019         env->DeleteLocalRef(sequencedEventClsLocal);
5020     }
5021 
5022     static jmethodID sequencedEventConst;
5023     if (sequencedEventConst == NULL) {
5024         sequencedEventConst =
5025             env->GetMethodID(sequencedEventCls, "<init>",
5026                              "(Ljava/awt/AWTEvent;)V");
5027         DASSERT(sequencedEventConst);
5028         CHECK_NULL(sequencedEventConst);
5029     }
5030 
5031     if (env->EnsureLocalCapacity(3) < 0) {
5032         return;
5033     }
5034 
5035     jobject target = GetTarget(env);
5036     jobject jOpposite = NULL;
5037     if (opposite != NULL) {
5038         AwtComponent *awtOpposite = AwtComponent::GetComponent(opposite);
5039         if (awtOpposite != NULL) {
5040             jOpposite = awtOpposite->GetTarget(env);
5041         }
5042     }
5043     jobject focusEvent = env->NewObject(focusEventCls, focusEventConst,
5044                                         target, id, JNI_FALSE, jOpposite);
5045     DASSERT(!safe_ExceptionOccurred(env));
5046     DASSERT(focusEvent != NULL);
5047     if (jOpposite != NULL) {
5048         env->DeleteLocalRef(jOpposite); jOpposite = NULL;
5049     }
5050     env->DeleteLocalRef(target); target = NULL;
5051     CHECK_NULL(focusEvent);
5052 
5053     jobject sequencedEvent = env->NewObject(sequencedEventCls,
5054                                             sequencedEventConst,
5055                                             focusEvent);
5056     DASSERT(!safe_ExceptionOccurred(env));
5057     DASSERT(sequencedEvent != NULL);
5058     env->DeleteLocalRef(focusEvent); focusEvent = NULL;
5059     CHECK_NULL(sequencedEvent);
5060     SendEvent(sequencedEvent);
5061 
5062     env->DeleteLocalRef(sequencedEvent);
5063 }
5064 
5065 /*
5066  * Forward a filtered event directly to the subclassed window.
5067  * This method is needed so that DefWindowProc is invoked on the
5068  * component's owning thread.
5069  */
5070 MsgRouting AwtComponent::HandleEvent(MSG *msg, BOOL)
5071 {
5072     DefWindowProc(msg->message, msg->wParam, msg->lParam);
5073     delete msg;
5074     return mrConsume;
5075 }
5076 
5077 /* Post a WM_AWT_HANDLE_EVENT message which invokes HandleEvent
5078    on the toolkit thread. This method may pre-filter the messages. */
5079 BOOL AwtComponent::PostHandleEventMessage(MSG *msg, BOOL synthetic)
5080 {
5081     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5082     // We should cut off keyboard events to disabled components
5083     // to avoid the components responding visually to keystrokes when disabled.
5084     // we shouldn't cut off WM_SYS* messages as they aren't used for normal activity
5085     // but to activate menus, close windows, etc
5086     switch(msg->message) {
5087         case WM_KEYDOWN:
5088         case WM_KEYUP:
5089         case WM_CHAR:
5090         case WM_DEADCHAR:
5091             {
5092                 if (!isRecursivelyEnabled()) {
5093                     goto quit;
5094                 }
5095                 break;
5096             }
5097     }
5098     if (PostMessage(GetHWnd(), WM_AWT_HANDLE_EVENT,
5099         (WPARAM) synthetic, (LPARAM) msg)) {
5100             return TRUE;
5101     } else {
5102         JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
5103     }
5104 quit:
5105     delete msg;
5106     return FALSE;
5107 }
5108 
5109 void AwtComponent::SynthesizeKeyMessage(JNIEnv *env, jobject keyEvent)
5110 {
5111     jint id = (env)->GetIntField(keyEvent, AwtAWTEvent::idID);
5112     UINT message;
5113     switch (id) {
5114       case java_awt_event_KeyEvent_KEY_PRESSED:
5115           message = WM_KEYDOWN;
5116           break;
5117       case java_awt_event_KeyEvent_KEY_RELEASED:
5118           message = WM_KEYUP;
5119           break;
5120       case java_awt_event_KeyEvent_KEY_TYPED:
5121           message = WM_CHAR;
5122           break;
5123       default:
5124           return;
5125     }
5126 
5127     /*
5128      * KeyEvent.modifiers aren't supported -- the Java apppwd must send separate
5129      * KEY_PRESSED and KEY_RELEASED events for the modifier virtual keys.
5130      */
5131     if (id == java_awt_event_KeyEvent_KEY_TYPED) {
5132         // WM_CHAR message must be posted using WM_AWT_FORWARD_CHAR
5133         // (for Edit control)
5134         jchar keyChar = (jchar)
5135           (env)->GetCharField(keyEvent, AwtKeyEvent::keyCharID);
5136 
5137         // Bugid 4724007.  If it is a Delete character, don't send the fake
5138         // KEY_TYPED we created back to the native window: Windows doesn't
5139         // expect a WM_CHAR for Delete in TextFields, so it tries to enter a
5140         // character after deleting.
5141         if (keyChar == '\177') { // the Delete character
5142             return;
5143         }
5144 
5145         // Disable forwarding WM_CHAR messages to disabled components
5146         if (isRecursivelyEnabled()) {
5147             if (!::PostMessage(GetHWnd(), WM_AWT_FORWARD_CHAR,
5148                 MAKEWPARAM(keyChar, TRUE), 0)) {
5149                 JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
5150             }
5151         }
5152     } else {
5153         jint keyCode =
5154           (env)->GetIntField(keyEvent, AwtKeyEvent::keyCodeID);
5155         UINT key, modifiers;
5156         AwtComponent::JavaKeyToWindowsKey(keyCode, &key, &modifiers);
5157         MSG* msg = CreateMessage(message, key, 0);
5158         PostHandleEventMessage(msg, TRUE);
5159     }
5160 }
5161 
5162 void AwtComponent::SynthesizeMouseMessage(JNIEnv *env, jobject mouseEvent)
5163 {
5164     /*    DebugBreak(); */
5165     jint button = (env)->GetIntField(mouseEvent, AwtMouseEvent::buttonID);
5166     jint modifiers = (env)->GetIntField(mouseEvent, AwtInputEvent::modifiersID);
5167 
5168     WPARAM wParam = 0;
5169     WORD wLow = 0;
5170     jint wheelAmt = 0;
5171     jint id = (env)->GetIntField(mouseEvent, AwtAWTEvent::idID);
5172     UINT message;
5173     switch (id) {
5174       case java_awt_event_MouseEvent_MOUSE_PRESSED: {
5175           switch (button) {
5176             case java_awt_event_MouseEvent_BUTTON1:
5177                 message = WM_LBUTTONDOWN; break;
5178             case java_awt_event_MouseEvent_BUTTON3:
5179                 message = WM_MBUTTONDOWN; break;
5180             case java_awt_event_MouseEvent_BUTTON2:
5181                 message = WM_RBUTTONDOWN; break;
5182           }
5183           break;
5184       }
5185       case java_awt_event_MouseEvent_MOUSE_RELEASED: {
5186           switch (button) {
5187             case java_awt_event_MouseEvent_BUTTON1:
5188                 message = WM_LBUTTONUP; break;
5189             case java_awt_event_MouseEvent_BUTTON3:
5190                 message = WM_MBUTTONUP; break;
5191             case java_awt_event_MouseEvent_BUTTON2:
5192                 message = WM_RBUTTONUP; break;
5193           }
5194           break;
5195       }
5196       case java_awt_event_MouseEvent_MOUSE_MOVED:
5197           /* MOUSE_DRAGGED events must first have sent a MOUSE_PRESSED event. */
5198       case java_awt_event_MouseEvent_MOUSE_DRAGGED:
5199           message = WM_MOUSEMOVE;
5200           break;
5201       case java_awt_event_MouseEvent_MOUSE_WHEEL:
5202           if (modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK) {
5203               wLow |= MK_CONTROL;
5204           }
5205           if (modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) {
5206               wLow |= MK_SHIFT;
5207           }
5208           if (modifiers & java_awt_event_InputEvent_BUTTON1_DOWN_MASK) {
5209               wLow |= MK_LBUTTON;
5210           }
5211           if (modifiers & java_awt_event_InputEvent_BUTTON2_DOWN_MASK) {
5212               wLow |= MK_RBUTTON;
5213           }
5214           if (modifiers & java_awt_event_InputEvent_BUTTON3_DOWN_MASK) {
5215               wLow |= MK_MBUTTON;
5216           }
5217           if (modifiers & X1_BUTTON) {
5218               wLow |= GetButtonMK(X1_BUTTON);
5219           }
5220           if (modifiers & X2_BUTTON) {
5221               wLow |= GetButtonMK(X2_BUTTON);
5222           }
5223 
5224           wheelAmt = (jint)JNU_CallMethodByName(env,
5225                                                NULL,
5226                                                mouseEvent,
5227                                                "getWheelRotation",
5228                                                "()I").i;
5229           DASSERT(!safe_ExceptionOccurred(env));
5230           JNU_CHECK_EXCEPTION(env);
5231           DTRACE_PRINTLN1("wheelAmt = %i\n", wheelAmt);
5232 
5233           // convert Java wheel amount value to Win32
5234           wheelAmt *= -1 * WHEEL_DELTA;
5235 
5236           message = WM_MOUSEWHEEL;
5237           wParam = MAKEWPARAM(wLow, wheelAmt);
5238 
5239           break;
5240       default:
5241           return;
5242     }
5243     jint x = (env)->GetIntField(mouseEvent, AwtMouseEvent::xID);
5244     jint y = (env)->GetIntField(mouseEvent, AwtMouseEvent::yID);
5245     MSG* msg = CreateMessage(message, wParam, MAKELPARAM(x, y), x, y);
5246     PostHandleEventMessage(msg, TRUE);
5247 }
5248 
5249 BOOL AwtComponent::InheritsNativeMouseWheelBehavior() {return false;}
5250 
5251 void AwtComponent::Invalidate(RECT* r)
5252 {
5253     ::InvalidateRect(GetHWnd(), r, FALSE);
5254 }
5255 
5256 void AwtComponent::BeginValidate()
5257 {
5258     DASSERT(m_validationNestCount >= 0 &&
5259            m_validationNestCount < 1000); // sanity check
5260 
5261     if (m_validationNestCount == 0) {
5262     // begin deferred window positioning if we're not inside
5263     // another Begin/EndValidate pair
5264         DASSERT(m_hdwp == NULL);
5265         m_hdwp = ::BeginDeferWindowPos(32);
5266     }
5267 
5268     m_validationNestCount++;
5269 }
5270 
5271 void AwtComponent::EndValidate()
5272 {
5273     DASSERT(m_validationNestCount > 0 &&
5274            m_validationNestCount < 1000); // sanity check
5275     DASSERT(m_hdwp != NULL);
5276 
5277     m_validationNestCount--;
5278     if (m_validationNestCount == 0) {
5279     // if this call to EndValidate is not nested inside another
5280     // Begin/EndValidate pair, end deferred window positioning
5281         ::EndDeferWindowPos(m_hdwp);
5282         m_hdwp = NULL;
5283     }
5284 }
5285 
5286 /**
5287  * HWND, AwtComponent and Java Peer interaction
5288  */
5289 
5290 /*
5291  *Link the C++, Java peer, and HWNDs together.
5292  */
5293 void AwtComponent::LinkObjects(JNIEnv *env, jobject peer)
5294 {
5295     /*
5296      * Bind all three objects together thru this C++ object, two-way to each:
5297      *     JavaPeer <-> C++ <-> HWND
5298      *
5299      * C++ -> JavaPeer
5300      */
5301     if (m_peerObject == NULL) {
5302         // This may have already been set up by CreateHWnd
5303         // And we don't want to create two references so we
5304         // will leave the prior one alone
5305         m_peerObject = env->NewGlobalRef(peer);
5306     }
5307     /* JavaPeer -> HWND */
5308     env->SetLongField(peer, AwtComponent::hwndID, reinterpret_cast<jlong>(m_hwnd));
5309 
5310     /* JavaPeer -> C++ */
5311     JNI_SET_PDATA(peer, this);
5312 
5313     /* HWND -> C++ */
5314     SetComponentInHWND();
5315 }
5316 
5317 /* Cleanup above linking */
5318 void AwtComponent::UnlinkObjects()
5319 {
5320     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5321     if (m_peerObject) {
5322         env->SetLongField(m_peerObject, AwtComponent::hwndID, 0);
5323         JNI_SET_PDATA(m_peerObject, static_cast<PDATA>(NULL));
5324         JNI_SET_DESTROYED(m_peerObject);
5325         env->DeleteGlobalRef(m_peerObject);
5326         m_peerObject = NULL;
5327     }
5328 }
5329 
5330 void AwtComponent::Enable(BOOL bEnable)
5331 {
5332     if (bEnable && IsTopLevel()) {
5333         // we should not enable blocked toplevels
5334         bEnable = !::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()));
5335     }
5336     // Shouldn't trigger native focus change
5337     // (only the proxy may be the native focus owner).
5338     ::EnableWindow(GetHWnd(), bEnable);
5339 
5340     CriticalSection::Lock l(GetLock());
5341     VerifyState();
5342 }
5343 
5344 /*
5345  * associate an AwtDropTarget with this AwtComponent
5346  */
5347 
5348 AwtDropTarget* AwtComponent::CreateDropTarget(JNIEnv* env) {
5349     m_dropTarget = new AwtDropTarget(env, this);
5350     m_dropTarget->RegisterTarget(TRUE);
5351     return m_dropTarget;
5352 }
5353 
5354 /*
5355  * disassociate an AwtDropTarget with this AwtComponent
5356  */
5357 
5358 void AwtComponent::DestroyDropTarget() {
5359     if (m_dropTarget != NULL) {
5360         m_dropTarget->RegisterTarget(FALSE);
5361         m_dropTarget->Release();
5362         m_dropTarget = NULL;
5363     }
5364 }
5365 
5366 BOOL AwtComponent::IsFocusingMouseMessage(MSG *pMsg) {
5367     return pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_LBUTTONDBLCLK;
5368 }
5369 
5370 BOOL AwtComponent::IsFocusingKeyMessage(MSG *pMsg) {
5371     return pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_SPACE;
5372 }
5373 
5374 void AwtComponent::_Show(void *param)
5375 {
5376     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5377 
5378     jobject self = (jobject)param;
5379 
5380     AwtComponent *p;
5381 
5382     PDATA pData;
5383     JNI_CHECK_PEER_GOTO(self, ret);
5384     p = (AwtComponent *)pData;
5385     if (::IsWindow(p->GetHWnd()))
5386     {
5387         p->SendMessage(WM_AWT_COMPONENT_SHOW);
5388     }
5389 ret:
5390     env->DeleteGlobalRef(self);
5391 }
5392 
5393 void AwtComponent::_Hide(void *param)
5394 {
5395     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5396 
5397     jobject self = (jobject)param;
5398 
5399     AwtComponent *p;
5400 
5401     PDATA pData;
5402     JNI_CHECK_PEER_GOTO(self, ret);
5403     p = (AwtComponent *)pData;
5404     if (::IsWindow(p->GetHWnd()))
5405     {
5406         p->SendMessage(WM_AWT_COMPONENT_HIDE);
5407     }
5408 ret:
5409     env->DeleteGlobalRef(self);
5410 }
5411 
5412 void AwtComponent::_Enable(void *param)
5413 {
5414     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5415 
5416     jobject self = (jobject)param;
5417 
5418     AwtComponent *p;
5419 
5420     PDATA pData;
5421     JNI_CHECK_PEER_GOTO(self, ret);
5422     p = (AwtComponent *)pData;
5423     if (::IsWindow(p->GetHWnd()))
5424     {
5425         p->Enable(TRUE);
5426     }
5427 ret:
5428     env->DeleteGlobalRef(self);
5429 }
5430 
5431 void AwtComponent::_Disable(void *param)
5432 {
5433     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5434 
5435     jobject self = (jobject)param;
5436 
5437     AwtComponent *p;
5438 
5439     PDATA pData;
5440     JNI_CHECK_PEER_GOTO(self, ret);
5441     p = (AwtComponent *)pData;
5442     if (::IsWindow(p->GetHWnd()))
5443     {
5444         p->Enable(FALSE);
5445     }
5446 ret:
5447     env->DeleteGlobalRef(self);
5448 }
5449 
5450 jobject AwtComponent::_GetLocationOnScreen(void *param)
5451 {
5452     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5453 
5454     jobject self = (jobject)param;
5455 
5456     jobject result = NULL;
5457     AwtComponent *p;
5458 
5459     PDATA pData;
5460     JNI_CHECK_PEER_GOTO(self, ret);
5461     p = (AwtComponent *)pData;
5462     if (::IsWindow(p->GetHWnd()))
5463     {
5464         RECT rect;
5465         VERIFY(::GetWindowRect(p->GetHWnd(),&rect));
5466         result = JNU_NewObjectByName(env, "java/awt/Point", "(II)V",
5467             rect.left, rect.top);
5468     }
5469 ret:
5470     env->DeleteGlobalRef(self);
5471 
5472     if (result != NULL)
5473     {
5474         jobject resultGlobalRef = env->NewGlobalRef(result);
5475         env->DeleteLocalRef(result);
5476         return resultGlobalRef;
5477     }
5478     else
5479     {
5480         return NULL;
5481     }
5482 }
5483 
5484 void AwtComponent::_Reshape(void *param)
5485 {
5486     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5487 
5488     ReshapeStruct *rs = (ReshapeStruct*)param;
5489     jobject self = rs->component;
5490     jint x = rs->x;
5491     jint y = rs->y;
5492     jint w = rs->w;
5493     jint h = rs->h;
5494 
5495     AwtComponent *p;
5496 
5497     PDATA pData;
5498     JNI_CHECK_PEER_GOTO(self, ret);
5499     p = (AwtComponent *)pData;
5500     if (::IsWindow(p->GetHWnd()))
5501     {
5502         RECT* r = new RECT;
5503         ::SetRect(r, x, y, x + w, y + h);
5504         p->SendMessage(WM_AWT_RESHAPE_COMPONENT, CHECK_EMBEDDED, (LPARAM)r);
5505     }
5506 ret:
5507     env->DeleteGlobalRef(self);
5508 
5509     delete rs;
5510 }
5511 
5512 void AwtComponent::_ReshapeNoCheck(void *param)
5513 {
5514     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5515 
5516     ReshapeStruct *rs = (ReshapeStruct*)param;
5517     jobject self = rs->component;
5518     jint x = rs->x;
5519     jint y = rs->y;
5520     jint w = rs->w;
5521     jint h = rs->h;
5522 
5523     AwtComponent *p;
5524 
5525     PDATA pData;
5526     JNI_CHECK_PEER_GOTO(self, ret);
5527     p = (AwtComponent *)pData;
5528     if (::IsWindow(p->GetHWnd()))
5529     {
5530         RECT* r = new RECT;
5531         ::SetRect(r, x, y, x + w, y + h);
5532         p->SendMessage(WM_AWT_RESHAPE_COMPONENT, DONT_CHECK_EMBEDDED, (LPARAM)r);
5533     }
5534 ret:
5535     env->DeleteGlobalRef(self);
5536 
5537     delete rs;
5538 }
5539 
5540 void AwtComponent::_NativeHandleEvent(void *param)
5541 {
5542     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5543 
5544     NativeHandleEventStruct *nhes = (NativeHandleEventStruct *)param;
5545     jobject self = nhes->component;
5546     jobject event = nhes->event;
5547 
5548     AwtComponent *p;
5549 
5550     PDATA pData;
5551     JNI_CHECK_NULL_GOTO(self, "peer", ret);
5552     pData = JNI_GET_PDATA(self);
5553     if (pData == NULL) {
5554         env->DeleteGlobalRef(self);
5555         if (event != NULL) {
5556             env->DeleteGlobalRef(event);
5557         }
5558         delete nhes;
5559         return;
5560     }
5561     JNI_CHECK_NULL_GOTO(event, "null AWTEvent", ret);
5562 
5563     p = (AwtComponent *)pData;
5564     if (::IsWindow(p->GetHWnd()))
5565     {
5566         if (env->EnsureLocalCapacity(1) < 0) {
5567             env->DeleteGlobalRef(self);
5568             env->DeleteGlobalRef(event);
5569             delete nhes;
5570             return;
5571         }
5572         jbyteArray bdata = (jbyteArray)(env)->GetObjectField(event, AwtAWTEvent::bdataID);
5573         int id = (env)->GetIntField(event, AwtAWTEvent::idID);
5574         DASSERT(!safe_ExceptionOccurred(env));
5575         if (bdata != 0) {
5576             MSG msg;
5577             (env)->GetByteArrayRegion(bdata, 0, sizeof(MSG), (jbyte *)&msg);
5578             (env)->DeleteLocalRef(bdata);
5579             static BOOL keyDownConsumed = FALSE;
5580             static BOOL bCharChanged = FALSE;
5581             static WCHAR modifiedChar;
5582             WCHAR unicodeChar;
5583 
5584             /* Remember if a KEY_PRESSED event is consumed, as an old model
5585              * program won't consume a subsequent KEY_TYPED event.
5586              */
5587             jboolean consumed =
5588                 (env)->GetBooleanField(event, AwtAWTEvent::consumedID);
5589             DASSERT(!safe_ExceptionOccurred(env));
5590 
5591             if (consumed) {
5592                 keyDownConsumed = (id == java_awt_event_KeyEvent_KEY_PRESSED);
5593                 env->DeleteGlobalRef(self);
5594                 env->DeleteGlobalRef(event);
5595                 delete nhes;
5596                 return;
5597 
5598             } else if (id == java_awt_event_KeyEvent_KEY_PRESSED) {
5599                 // Fix for 6637607: reset consuming
5600                 keyDownConsumed = FALSE;
5601             }
5602 
5603             /* Consume a KEY_TYPED event if a KEY_PRESSED had been, to support
5604              * the old model.
5605              */
5606             if ((id == java_awt_event_KeyEvent_KEY_TYPED) && keyDownConsumed) {
5607                 keyDownConsumed = FALSE;
5608                 env->DeleteGlobalRef(self);
5609                 env->DeleteGlobalRef(event);
5610                 delete nhes;
5611                 return;
5612             }
5613 
5614             /* Modify any event parameters, if necessary. */
5615             if (self && pData &&
5616                 id >= java_awt_event_KeyEvent_KEY_FIRST &&
5617                 id <= java_awt_event_KeyEvent_KEY_LAST) {
5618 
5619                     AwtComponent* p = (AwtComponent*)pData;
5620 
5621                     jint keyCode =
5622                       (env)->GetIntField(event, AwtKeyEvent::keyCodeID);
5623                     jchar keyChar =
5624                       (env)->GetCharField(event, AwtKeyEvent::keyCharID);
5625                     jint modifiers =
5626                       (env)->GetIntField(event, AwtInputEvent::modifiersID);
5627 
5628                     DASSERT(!safe_ExceptionOccurred(env));
5629 
5630                 /* Check to see whether the keyCode or modifiers were changed
5631                    on the keyPressed event, and tweak the following keyTyped
5632                    event (if any) accodingly.  */
5633                 switch (id) {
5634                 case java_awt_event_KeyEvent_KEY_PRESSED:
5635                 {
5636                     UINT winKey = (UINT)msg.wParam;
5637                     bCharChanged = FALSE;
5638 
5639                     if (winKey == VK_PROCESSKEY) {
5640                         // Leave it up to IME
5641                         break;
5642                     }
5643 
5644                     if (keyCode != java_awt_event_KeyEvent_VK_UNDEFINED) {
5645                         UINT newWinKey, ignored;
5646                         p->JavaKeyToWindowsKey(keyCode, &newWinKey, &ignored, winKey);
5647                         if (newWinKey != 0) {
5648                             winKey = newWinKey;
5649                         }
5650                     }
5651 
5652                     BOOL isDeadKey = FALSE;
5653                     modifiedChar = p->WindowsKeyToJavaChar(winKey, modifiers, AwtComponent::NONE, isDeadKey);
5654                     bCharChanged = (keyChar != modifiedChar);
5655                 }
5656                 break;
5657 
5658                 case java_awt_event_KeyEvent_KEY_RELEASED:
5659                 {
5660                     keyDownConsumed = FALSE;
5661                     bCharChanged = FALSE;
5662                 }
5663                 break;
5664 
5665                 case java_awt_event_KeyEvent_KEY_TYPED:
5666                 {
5667                     if (bCharChanged)
5668                     {
5669                         unicodeChar = modifiedChar;
5670                     }
5671                     else
5672                     {
5673                         unicodeChar = keyChar;
5674                     }
5675                     bCharChanged = FALSE;
5676 
5677                     // Disable forwarding KEY_TYPED messages to peers of
5678                     // disabled components
5679                     if (p->isRecursivelyEnabled()) {
5680                         // send the character back to the native window for
5681                         // processing. The WM_AWT_FORWARD_CHAR handler will send
5682                         // this character to DefWindowProc
5683                         if (!::PostMessage(p->GetHWnd(), WM_AWT_FORWARD_CHAR,
5684                             MAKEWPARAM(unicodeChar, FALSE), msg.lParam)) {
5685                             JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
5686                         }
5687                     }
5688                     env->DeleteGlobalRef(self);
5689                     env->DeleteGlobalRef(event);
5690                     delete nhes;
5691                     return;
5692                 }
5693                 break;
5694 
5695                 default:
5696                     break;
5697                 }
5698             }
5699 
5700             // ignore all InputMethodEvents
5701             if (self && (pData = JNI_GET_PDATA(self)) &&
5702                 id >= java_awt_event_InputMethodEvent_INPUT_METHOD_FIRST &&
5703                 id <= java_awt_event_InputMethodEvent_INPUT_METHOD_LAST) {
5704                 env->DeleteGlobalRef(self);
5705                 env->DeleteGlobalRef(event);
5706                 delete nhes;
5707                 return;
5708             }
5709 
5710             // Create copy for local msg
5711             MSG* pCopiedMsg = new MSG;
5712             memmove(pCopiedMsg, &msg, sizeof(MSG));
5713             // Event handler deletes msg
5714             p->PostHandleEventMessage(pCopiedMsg, FALSE);
5715 
5716             env->DeleteGlobalRef(self);
5717             env->DeleteGlobalRef(event);
5718             delete nhes;
5719             return;
5720         }
5721 
5722         /* Forward any valid synthesized events.  Currently only mouse and
5723          * key events are supported.
5724          */
5725         if (self == NULL || (pData = JNI_GET_PDATA(self)) == NULL) {
5726             env->DeleteGlobalRef(self);
5727             env->DeleteGlobalRef(event);
5728             delete nhes;
5729             return;
5730         }
5731 
5732         AwtComponent* p = (AwtComponent*)pData;
5733         if (id >= java_awt_event_KeyEvent_KEY_FIRST &&
5734             id <= java_awt_event_KeyEvent_KEY_LAST) {
5735             p->SynthesizeKeyMessage(env, event);
5736         } else if (id >= java_awt_event_MouseEvent_MOUSE_FIRST &&
5737                    id <= java_awt_event_MouseEvent_MOUSE_LAST) {
5738             p->SynthesizeMouseMessage(env, event);
5739         }
5740     }
5741 
5742 ret:
5743     if (self != NULL) {
5744         env->DeleteGlobalRef(self);
5745     }
5746     if (event != NULL) {
5747         env->DeleteGlobalRef(event);
5748     }
5749 
5750     delete nhes;
5751 }
5752 
5753 void AwtComponent::_SetForeground(void *param)
5754 {
5755     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5756 
5757     SetColorStruct *scs = (SetColorStruct *)param;
5758     jobject self = scs->component;
5759     jint rgb = scs->rgb;
5760 
5761     AwtComponent *c = NULL;
5762 
5763     PDATA pData;
5764     JNI_CHECK_PEER_GOTO(self, ret);
5765     c = (AwtComponent *)pData;
5766     if (::IsWindow(c->GetHWnd()))
5767     {
5768         c->SetColor(PALETTERGB((rgb>>16)&0xff,
5769                                (rgb>>8)&0xff,
5770                                (rgb)&0xff));
5771         c->VerifyState();
5772     }
5773 ret:
5774     env->DeleteGlobalRef(self);
5775 
5776     delete scs;
5777 }
5778 
5779 void AwtComponent::_SetBackground(void *param)
5780 {
5781     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5782 
5783     SetColorStruct *scs = (SetColorStruct *)param;
5784     jobject self = scs->component;
5785     jint rgb = scs->rgb;
5786 
5787     AwtComponent *c = NULL;
5788 
5789     PDATA pData;
5790     JNI_CHECK_PEER_GOTO(self, ret);
5791     c = (AwtComponent *)pData;
5792     if (::IsWindow(c->GetHWnd()))
5793     {
5794         c->SetBackgroundColor(PALETTERGB((rgb>>16)&0xff,
5795                                          (rgb>>8)&0xff,
5796                                          (rgb)&0xff));
5797         c->VerifyState();
5798     }
5799 ret:
5800     env->DeleteGlobalRef(self);
5801 
5802     delete scs;
5803 }
5804 
5805 void AwtComponent::_SetFont(void *param)
5806 {
5807     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5808 
5809     SetFontStruct *sfs = (SetFontStruct *)param;
5810     jobject self = sfs->component;
5811     jobject font = sfs->font;
5812 
5813     AwtComponent *c = NULL;
5814 
5815     PDATA pData;
5816     JNI_CHECK_PEER_GOTO(self, ret);
5817     JNI_CHECK_NULL_GOTO(font, "null font", ret);
5818     c = (AwtComponent *)pData;
5819     if (::IsWindow(c->GetHWnd()))
5820     {
5821         AwtFont *awtFont = (AwtFont *)env->GetLongField(font, AwtFont::pDataID);
5822         if (awtFont == NULL) {
5823             /*arguments of AwtFont::Create are changed for multifont component */
5824             awtFont = AwtFont::Create(env, font);
5825         }
5826         env->SetLongField(font, AwtFont::pDataID, (jlong)awtFont);
5827 
5828         c->SetFont(awtFont);
5829     }
5830 ret:
5831     env->DeleteGlobalRef(self);
5832     env->DeleteGlobalRef(font);
5833 
5834     delete sfs;
5835 }
5836 
5837 // Sets or kills focus for a component.
5838 void AwtComponent::_SetFocus(void *param)
5839 {
5840     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5841 
5842     SetFocusStruct *sfs = (SetFocusStruct *)param;
5843     jobject self = sfs->component;
5844     jboolean doSetFocus = sfs->doSetFocus;
5845 
5846     AwtComponent *c = NULL;
5847 
5848     PDATA pData;
5849     JNI_CHECK_NULL_GOTO(self, "peer", ret);
5850     pData = JNI_GET_PDATA(self);
5851     if (pData == NULL) {
5852         // do nothing just return false
5853         goto ret;
5854     }
5855 
5856     c = (AwtComponent *)pData;
5857     if (::IsWindow(c->GetHWnd())) {
5858         c->SendMessage(WM_AWT_COMPONENT_SETFOCUS, (WPARAM)doSetFocus, 0);
5859     }
5860 ret:
5861     env->DeleteGlobalRef(self);
5862 
5863     delete sfs;
5864 }
5865 
5866 void AwtComponent::_Start(void *param)
5867 {
5868     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5869 
5870     jobject self = (jobject)param;
5871 
5872     AwtComponent *c = NULL;
5873 
5874     PDATA pData;
5875     JNI_CHECK_PEER_GOTO(self, ret);
5876     c = (AwtComponent *)pData;
5877     if (::IsWindow(c->GetHWnd()))
5878     {
5879         jobject target = c->GetTarget(env);
5880 
5881         /* Disable window if specified -- windows are enabled by default. */
5882         jboolean enabled = (jboolean)env->GetBooleanField(target,
5883                                                           AwtComponent::enabledID);
5884         if (!enabled) {
5885             ::EnableWindow(c->GetHWnd(), FALSE);
5886         }
5887 
5888         /* The peer is now ready for callbacks, since this is the last
5889          * initialization call
5890          */
5891         c->EnableCallbacks(TRUE);
5892 
5893         // Fix 4745222: we need to invalidate region since we validated it before initialization.
5894         ::InvalidateRgn(c->GetHWnd(), NULL, FALSE);
5895 
5896         // Fix 4530093: WM_PAINT after EnableCallbacks
5897         ::UpdateWindow(c->GetHWnd());
5898 
5899         env->DeleteLocalRef(target);
5900     }
5901 ret:
5902     env->DeleteGlobalRef(self);
5903 }
5904 
5905 void AwtComponent::_BeginValidate(void *param)
5906 {
5907     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5908     if (AwtToolkit::IsMainThread()) {
5909         jobject self = (jobject)param;
5910         if (self != NULL) {
5911             PDATA pData = JNI_GET_PDATA(self);
5912             if (pData) {
5913                 AwtComponent *c = (AwtComponent *)pData;
5914                 if (::IsWindow(c->GetHWnd())) {
5915                     c->SendMessage(WM_AWT_BEGIN_VALIDATE);
5916                 }
5917             }
5918             env->DeleteGlobalRef(self);
5919         }
5920     } else {
5921         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_BeginValidate, param);
5922     }
5923 }
5924 
5925 void AwtComponent::_EndValidate(void *param)
5926 {
5927     if (AwtToolkit::IsMainThread()) {
5928         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5929         jobject self = (jobject)param;
5930         if (self != NULL) {
5931             PDATA pData = JNI_GET_PDATA(self);
5932             if (pData) {
5933                 AwtComponent *c = (AwtComponent *)pData;
5934                 if (::IsWindow(c->GetHWnd())) {
5935                     c->SendMessage(WM_AWT_END_VALIDATE);
5936                 }
5937             }
5938             env->DeleteGlobalRef(self);
5939         }
5940     } else {
5941         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_EndValidate, param);
5942     }
5943 }
5944 
5945 void AwtComponent::_UpdateWindow(void *param)
5946 {
5947     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5948     if (AwtToolkit::IsMainThread()) {
5949         jobject self = (jobject)param;
5950         AwtComponent *c = NULL;
5951         PDATA pData;
5952         JNI_CHECK_PEER_GOTO(self, ret);
5953         c = (AwtComponent *)pData;
5954         if (::IsWindow(c->GetHWnd())) {
5955             ::UpdateWindow(c->GetHWnd());
5956         }
5957 ret:
5958         env->DeleteGlobalRef(self);
5959     } else {
5960         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_UpdateWindow, param);
5961     }
5962 }
5963 
5964 jlong AwtComponent::_AddNativeDropTarget(void *param)
5965 {
5966     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5967 
5968     jobject self = (jobject)param;
5969 
5970     jlong result = 0;
5971     AwtComponent *c = NULL;
5972 
5973     PDATA pData;
5974     JNI_CHECK_PEER_GOTO(self, ret);
5975     c = (AwtComponent *)pData;
5976     if (::IsWindow(c->GetHWnd()))
5977     {
5978         result = (jlong)(c->CreateDropTarget(env));
5979     }
5980 ret:
5981     env->DeleteGlobalRef(self);
5982 
5983     return result;
5984 }
5985 
5986 void AwtComponent::_RemoveNativeDropTarget(void *param)
5987 {
5988     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5989 
5990     jobject self = (jobject)param;
5991 
5992     AwtComponent *c = NULL;
5993 
5994     PDATA pData;
5995     JNI_CHECK_PEER_GOTO(self, ret);
5996     c = (AwtComponent *)pData;
5997     if (::IsWindow(c->GetHWnd()))
5998     {
5999         c->DestroyDropTarget();
6000     }
6001 ret:
6002     env->DeleteGlobalRef(self);
6003 }
6004 
6005 jintArray AwtComponent::_CreatePrintedPixels(void *param)
6006 {
6007     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6008 
6009     CreatePrintedPixelsStruct *cpps = (CreatePrintedPixelsStruct *)param;
6010     jobject self = cpps->component;
6011 
6012     jintArray result = NULL;
6013     AwtComponent *c = NULL;
6014 
6015     PDATA pData;
6016     JNI_CHECK_PEER_GOTO(self, ret);
6017     c = (AwtComponent *)pData;
6018     if (::IsWindow(c->GetHWnd()))
6019     {
6020         result = (jintArray)c->SendMessage(WM_AWT_CREATE_PRINTED_PIXELS, (WPARAM)cpps, 0);
6021     }
6022 ret:
6023     env->DeleteGlobalRef(self);
6024 
6025     delete cpps;
6026     return result; // this reference is global
6027 }
6028 
6029 jboolean AwtComponent::_IsObscured(void *param)
6030 {
6031     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6032 
6033     jobject self = (jobject)param;
6034 
6035     jboolean result = JNI_FALSE;
6036     AwtComponent *c = NULL;
6037 
6038     PDATA pData;
6039     JNI_CHECK_PEER_GOTO(self, ret);
6040 
6041     c = (AwtComponent *)pData;
6042 
6043     if (::IsWindow(c->GetHWnd()))
6044     {
6045         HWND hWnd = c->GetHWnd();
6046         HDC hDC = ::GetDC(hWnd);
6047         RECT clipbox;
6048         int callresult = ::GetClipBox(hDC, &clipbox);
6049         switch(callresult) {
6050             case NULLREGION :
6051                 result = JNI_FALSE;
6052                 break;
6053             case SIMPLEREGION : {
6054                 RECT windowRect;
6055                 if (!::GetClientRect(hWnd, &windowRect)) {
6056                     result = JNI_TRUE;
6057                 } else {
6058                     result  = (jboolean)((clipbox.bottom != windowRect.bottom)
6059                         || (clipbox.left != windowRect.left)
6060                         || (clipbox.right != windowRect.right)
6061                         || (clipbox.top != windowRect.top));
6062                 }
6063                 break;
6064             }
6065             case COMPLEXREGION :
6066             default :
6067                 result = JNI_TRUE;
6068                 break;
6069         }
6070         ::ReleaseDC(hWnd, hDC);
6071     }
6072 ret:
6073     env->DeleteGlobalRef(self);
6074 
6075     return result;
6076 }
6077 
6078 jboolean AwtComponent::_NativeHandlesWheelScrolling(void *param)
6079 {
6080     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6081 
6082     jobject self = (jobject)param;
6083 
6084     jboolean result = JNI_FALSE;
6085     AwtComponent *c = NULL;
6086 
6087     PDATA pData;
6088     JNI_CHECK_PEER_GOTO(self, ret);
6089     c = (AwtComponent *)pData;
6090     if (::IsWindow(c->GetHWnd()))
6091     {
6092         result = JNI_IS_TRUE(c->InheritsNativeMouseWheelBehavior());
6093     }
6094 ret:
6095     env->DeleteGlobalRef(self);
6096 
6097     return result;
6098 }
6099 
6100 void AwtComponent::SetParent(void * param) {
6101     if (AwtToolkit::IsMainThread()) {
6102         AwtComponent** comps = (AwtComponent**)param;
6103         if ((comps[0] != NULL) && (comps[1] != NULL)) {
6104             HWND selfWnd = comps[0]->GetHWnd();
6105             HWND parentWnd = comps[1]->GetHWnd();
6106             if (::IsWindow(selfWnd) && ::IsWindow(parentWnd)) {
6107                 // Shouldn't trigger native focus change
6108                 // (only the proxy may be the native focus owner).
6109                 ::SetParent(selfWnd, parentWnd);
6110             }
6111         }
6112         delete[] comps;
6113     } else {
6114         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::SetParent, param);
6115     }
6116 }
6117 
6118 void AwtComponent::_SetRectangularShape(void *param)
6119 {
6120     if (!AwtToolkit::IsMainThread()) {
6121         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_SetRectangularShape, param);
6122     } else {
6123         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6124 
6125         SetRectangularShapeStruct *data = (SetRectangularShapeStruct *)param;
6126         jobject self = data->component;
6127         jint x1 = data->x1;
6128         jint x2 = data->x2;
6129         jint y1 = data->y1;
6130         jint y2 = data->y2;
6131         jobject region = data->region;
6132 
6133         AwtComponent *c = NULL;
6134 
6135         PDATA pData;
6136         JNI_CHECK_PEER_GOTO(self, ret);
6137 
6138         c = (AwtComponent *)pData;
6139         if (::IsWindow(c->GetHWnd())) {
6140             HRGN hRgn = NULL;
6141 
6142             // If all the params are zeros, the shape must be simply reset.
6143             // Otherwise, convert it into a region.
6144             if (region || x1 || x2 || y1 || y2) {
6145                 RECT_T rects[256];
6146                 RECT_T *pRect = rects;
6147 
6148                 const int numrects = RegionToYXBandedRectangles(env, x1, y1, x2, y2,
6149                         region, &pRect, sizeof(rects)/sizeof(rects[0]));
6150                 if (!pRect) {
6151                     // RegionToYXBandedRectangles doesn't use safe_Malloc(),
6152                     // so throw the exception explicitly
6153                     throw std::bad_alloc();
6154                 }
6155 
6156                 RGNDATA *pRgnData = (RGNDATA *) SAFE_SIZE_STRUCT_ALLOC(safe_Malloc,
6157                         sizeof(RGNDATAHEADER), sizeof(RECT_T), numrects);
6158                 memcpy((BYTE*)pRgnData + sizeof(RGNDATAHEADER), pRect, sizeof(RECT_T) * numrects);
6159                 if (pRect != rects) {
6160                     free(pRect);
6161                 }
6162                 pRect = NULL;
6163 
6164                 RGNDATAHEADER *pRgnHdr = (RGNDATAHEADER *) pRgnData;
6165                 pRgnHdr->dwSize = sizeof(RGNDATAHEADER);
6166                 pRgnHdr->iType = RDH_RECTANGLES;
6167                 pRgnHdr->nRgnSize = 0;
6168                 pRgnHdr->rcBound.top = 0;
6169                 pRgnHdr->rcBound.left = 0;
6170                 pRgnHdr->rcBound.bottom = LONG(y2 - y1);
6171                 pRgnHdr->rcBound.right = LONG(x2 - x1);
6172                 pRgnHdr->nCount = numrects;
6173 
6174                 hRgn = ::ExtCreateRegion(NULL,
6175                         sizeof(RGNDATAHEADER) + sizeof(RECT_T) * pRgnHdr->nCount, pRgnData);
6176 
6177                 free(pRgnData);
6178             }
6179 
6180             ::SetWindowRgn(c->GetHWnd(), hRgn, TRUE);
6181         }
6182 
6183 ret:
6184         env->DeleteGlobalRef(self);
6185         if (region) {
6186             env->DeleteGlobalRef(region);
6187         }
6188 
6189         delete data;
6190     }
6191 }
6192 
6193 void AwtComponent::_SetZOrder(void *param) {
6194     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6195 
6196     SetZOrderStruct *data = (SetZOrderStruct *)param;
6197     jobject self = data->component;
6198     HWND above = HWND_TOP;
6199     if (data->above != 0) {
6200         above = reinterpret_cast<HWND>(data->above);
6201     }
6202 
6203     AwtComponent *c = NULL;
6204 
6205     PDATA pData;
6206     JNI_CHECK_PEER_GOTO(self, ret);
6207 
6208     c = (AwtComponent *)pData;
6209     if (::IsWindow(c->GetHWnd())) {
6210         ::SetWindowPos(c->GetHWnd(), above, 0, 0, 0, 0,
6211                        SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE | SWP_ASYNCWINDOWPOS);
6212     }
6213 
6214 ret:
6215     env->DeleteGlobalRef(self);
6216 
6217     delete data;
6218 }
6219 
6220 void AwtComponent::PostUngrabEvent() {
6221     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6222     jobject target = GetTarget(env);
6223     jobject event = JNU_NewObjectByName(env, "sun/awt/UngrabEvent", "(Ljava/awt/Component;)V",
6224                                         target);
6225     if (safe_ExceptionOccurred(env)) {
6226         env->ExceptionDescribe();
6227         env->ExceptionClear();
6228     }
6229     env->DeleteLocalRef(target);
6230     if (event != NULL) {
6231         SendEvent(event);
6232         env->DeleteLocalRef(event);
6233     }
6234 }
6235 
6236 void AwtComponent::SetFocusedWindow(HWND window)
6237 {
6238     HWND old = sm_focusedWindow;
6239     sm_focusedWindow = window;
6240 
6241     AwtWindow::FocusedWindowChanged(old, window);
6242 }
6243 
6244 /************************************************************************
6245  * Component native methods
6246  */
6247 
6248 extern "C" {
6249 
6250 /**
6251  * This method is called from the WGL pipeline when it needs to retrieve
6252  * the HWND associated with a ComponentPeer's C++ level object.
6253  */
6254 HWND
6255 AwtComponent_GetHWnd(JNIEnv *env, jlong pData)
6256 {
6257     AwtComponent *p = (AwtComponent *)jlong_to_ptr(pData);
6258     if (p == NULL) {
6259         return (HWND)0;
6260     }
6261     return p->GetHWnd();
6262 }
6263 
6264 static void _GetInsets(void* param)
6265 {
6266     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6267 
6268     GetInsetsStruct *gis = (GetInsetsStruct *)param;
6269     jobject self = gis->window;
6270 
6271     gis->insets->left = gis->insets->top =
6272         gis->insets->right = gis->insets->bottom = 0;
6273 
6274     PDATA pData;
6275     JNI_CHECK_PEER_GOTO(self, ret);
6276     AwtComponent *component = (AwtComponent *)pData;
6277 
6278     component->GetInsets(gis->insets);
6279 
6280   ret:
6281     env->DeleteGlobalRef(self);
6282     delete gis;
6283 }
6284 
6285 /**
6286  * This method is called from the WGL pipeline when it needs to retrieve
6287  * the insets associated with a ComponentPeer's C++ level object.
6288  */
6289 void AwtComponent_GetInsets(JNIEnv *env, jobject peer, RECT *insets)
6290 {
6291     TRY;
6292 
6293     GetInsetsStruct *gis = new GetInsetsStruct;
6294     gis->window = env->NewGlobalRef(peer);
6295     gis->insets = insets;
6296 
6297     AwtToolkit::GetInstance().InvokeFunction(_GetInsets, gis);
6298     // global refs and mds are deleted in _UpdateWindow
6299 
6300     CATCH_BAD_ALLOC;
6301 
6302 }
6303 
6304 JNIEXPORT void JNICALL
6305 Java_java_awt_Component_initIDs(JNIEnv *env, jclass cls)
6306 {
6307     TRY;
6308     jclass inputEventClazz = env->FindClass("java/awt/event/InputEvent");
6309     CHECK_NULL(inputEventClazz);
6310     jmethodID getButtonDownMasksID = env->GetStaticMethodID(inputEventClazz, "getButtonDownMasks", "()[I");
6311     CHECK_NULL(getButtonDownMasksID);
6312     jintArray obj = (jintArray)env->CallStaticObjectMethod(inputEventClazz, getButtonDownMasksID);
6313     jint * tmp = env->GetIntArrayElements(obj, JNI_FALSE);
6314     CHECK_NULL(tmp);
6315     jsize len = env->GetArrayLength(obj);
6316     AwtComponent::masks = SAFE_SIZE_NEW_ARRAY(jint, len);
6317     for (int i = 0; i < len; i++) {
6318         AwtComponent::masks[i] = tmp[i];
6319     }
6320     env->ReleaseIntArrayElements(obj, tmp, 0);
6321     env->DeleteLocalRef(obj);
6322 
6323     /* class ids */
6324     jclass peerCls = env->FindClass("sun/awt/windows/WComponentPeer");
6325 
6326     DASSERT(peerCls);
6327     CHECK_NULL(peerCls);
6328 
6329     /* field ids */
6330     AwtComponent::peerID =
6331       env->GetFieldID(cls, "peer", "Ljava/awt/peer/ComponentPeer;");
6332     DASSERT(AwtComponent::peerID);
6333     CHECK_NULL(AwtComponent::peerID);
6334 
6335     AwtComponent::xID = env->GetFieldID(cls, "x", "I");
6336     DASSERT(AwtComponent::xID);
6337     CHECK_NULL(AwtComponent::xID);
6338 
6339     AwtComponent::yID = env->GetFieldID(cls, "y", "I");
6340     DASSERT(AwtComponent::yID);
6341     CHECK_NULL(AwtComponent::yID);
6342 
6343     AwtComponent::heightID = env->GetFieldID(cls, "height", "I");
6344     DASSERT(AwtComponent::heightID);
6345     CHECK_NULL(AwtComponent::heightID);
6346 
6347     AwtComponent::widthID = env->GetFieldID(cls, "width", "I");
6348     DASSERT(AwtComponent::widthID);
6349     CHECK_NULL(AwtComponent::widthID);
6350 
6351     AwtComponent::visibleID = env->GetFieldID(cls, "visible", "Z");
6352     DASSERT(AwtComponent::visibleID);
6353     CHECK_NULL(AwtComponent::visibleID);
6354 
6355     AwtComponent::backgroundID =
6356         env->GetFieldID(cls, "background", "Ljava/awt/Color;");
6357     DASSERT(AwtComponent::backgroundID);
6358     CHECK_NULL(AwtComponent::backgroundID);
6359 
6360     AwtComponent::foregroundID =
6361         env->GetFieldID(cls, "foreground", "Ljava/awt/Color;");
6362     DASSERT(AwtComponent::foregroundID);
6363     CHECK_NULL(AwtComponent::foregroundID);
6364 
6365     AwtComponent::enabledID = env->GetFieldID(cls, "enabled", "Z");
6366     DASSERT(AwtComponent::enabledID);
6367     CHECK_NULL(AwtComponent::enabledID);
6368 
6369     AwtComponent::parentID = env->GetFieldID(cls, "parent", "Ljava/awt/Container;");
6370     DASSERT(AwtComponent::parentID);
6371     CHECK_NULL(AwtComponent::parentID);
6372 
6373     AwtComponent::graphicsConfigID =
6374      env->GetFieldID(cls, "graphicsConfig", "Ljava/awt/GraphicsConfiguration;");
6375     DASSERT(AwtComponent::graphicsConfigID);
6376     CHECK_NULL(AwtComponent::graphicsConfigID);
6377 
6378     AwtComponent::focusableID = env->GetFieldID(cls, "focusable", "Z");
6379     DASSERT(AwtComponent::focusableID);
6380     CHECK_NULL(AwtComponent::focusableID);
6381 
6382     AwtComponent::appContextID = env->GetFieldID(cls, "appContext",
6383                                                  "Lsun/awt/AppContext;");
6384     DASSERT(AwtComponent::appContextID);
6385     CHECK_NULL(AwtComponent::appContextID);
6386 
6387     AwtComponent::peerGCID = env->GetFieldID(peerCls, "winGraphicsConfig",
6388                                         "Lsun/awt/Win32GraphicsConfig;");
6389     DASSERT(AwtComponent::peerGCID);
6390     CHECK_NULL(AwtComponent::peerGCID);
6391 
6392     AwtComponent::hwndID = env->GetFieldID(peerCls, "hwnd", "J");
6393     DASSERT(AwtComponent::hwndID);
6394     CHECK_NULL(AwtComponent::hwndID);
6395 
6396     AwtComponent::cursorID = env->GetFieldID(cls, "cursor", "Ljava/awt/Cursor;");
6397     DASSERT(AwtComponent::cursorID);
6398     CHECK_NULL(AwtComponent::cursorID);
6399 
6400     /* method ids */
6401     AwtComponent::getFontMID =
6402         env->GetMethodID(cls, "getFont_NoClientCode", "()Ljava/awt/Font;");
6403     DASSERT(AwtComponent::getFontMID);
6404     CHECK_NULL(AwtComponent::getFontMID);
6405 
6406     AwtComponent::getToolkitMID =
6407         env->GetMethodID(cls, "getToolkitImpl", "()Ljava/awt/Toolkit;");
6408     DASSERT(AwtComponent::getToolkitMID);
6409     CHECK_NULL(AwtComponent::getToolkitMID);
6410 
6411     AwtComponent::isEnabledMID = env->GetMethodID(cls, "isEnabledImpl", "()Z");
6412     DASSERT(AwtComponent::isEnabledMID);
6413     CHECK_NULL(AwtComponent::isEnabledMID);
6414 
6415     AwtComponent::getLocationOnScreenMID =
6416         env->GetMethodID(cls, "getLocationOnScreen_NoTreeLock", "()Ljava/awt/Point;");
6417     DASSERT(AwtComponent::getLocationOnScreenMID);
6418     CHECK_NULL(AwtComponent::getLocationOnScreenMID);
6419 
6420     AwtComponent::replaceSurfaceDataMID =
6421         env->GetMethodID(peerCls, "replaceSurfaceData", "()V");
6422     DASSERT(AwtComponent::replaceSurfaceDataMID);
6423     CHECK_NULL(AwtComponent::replaceSurfaceDataMID);
6424 
6425     AwtComponent::replaceSurfaceDataLaterMID =
6426         env->GetMethodID(peerCls, "replaceSurfaceDataLater", "()V");
6427     DASSERT(AwtComponent::replaceSurfaceDataLaterMID);
6428     CHECK_NULL(AwtComponent::replaceSurfaceDataLaterMID);
6429 
6430     AwtComponent::disposeLaterMID = env->GetMethodID(peerCls, "disposeLater", "()V");
6431     DASSERT(AwtComponent::disposeLaterMID);
6432     CHECK_NULL(AwtComponent::disposeLaterMID);
6433 
6434     CATCH_BAD_ALLOC;
6435 }
6436 
6437 } /* extern "C" */
6438 
6439 
6440 /************************************************************************
6441  * ComponentPeer native methods
6442  */
6443 
6444 extern "C" {
6445 
6446 /*
6447  * Class:     sun_awt_windows_WComponentPeer
6448  * Method:    pShow
6449  * Signature: ()V
6450  */
6451 JNIEXPORT void JNICALL
6452 Java_sun_awt_windows_WComponentPeer_pShow(JNIEnv *env, jobject self)
6453 {
6454     TRY;
6455 
6456     jobject selfGlobalRef = env->NewGlobalRef(self);
6457 
6458     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Show, (void *)selfGlobalRef);
6459     // selfGlobalRef is deleted in _Show
6460 
6461     CATCH_BAD_ALLOC;
6462 }
6463 
6464 /*
6465  * Class:     sun_awt_windows_WComponentPeer
6466  * Method:    hide
6467  * Signature: ()V
6468  */
6469 JNIEXPORT void JNICALL
6470 Java_sun_awt_windows_WComponentPeer_hide(JNIEnv *env, jobject self)
6471 {
6472     TRY;
6473 
6474     jobject selfGlobalRef = env->NewGlobalRef(self);
6475 
6476     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Hide, (void *)selfGlobalRef);
6477     // selfGlobalRef is deleted in _Hide
6478 
6479     CATCH_BAD_ALLOC;
6480 }
6481 
6482 /*
6483  * Class:     sun_awt_windows_WComponentPeer
6484  * Method:    enable
6485  * Signature: ()V
6486  */
6487 JNIEXPORT void JNICALL
6488 Java_sun_awt_windows_WComponentPeer_enable(JNIEnv *env, jobject self)
6489 {
6490     TRY;
6491 
6492     jobject selfGlobalRef = env->NewGlobalRef(self);
6493 
6494     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Enable, (void *)selfGlobalRef);
6495     // selfGlobalRef is deleted in _Enable
6496 
6497     CATCH_BAD_ALLOC;
6498 }
6499 
6500 /*
6501  * Class:     sun_awt_windows_WComponentPeer
6502  * Method:    disable
6503  * Signature: ()V
6504  */
6505 JNIEXPORT void JNICALL
6506 Java_sun_awt_windows_WComponentPeer_disable(JNIEnv *env, jobject self)
6507 {
6508     TRY;
6509 
6510     jobject selfGlobalRef = env->NewGlobalRef(self);
6511 
6512     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Disable, (void *)selfGlobalRef);
6513     // selfGlobalRef is deleted in _Disable
6514 
6515     CATCH_BAD_ALLOC;
6516 }
6517 
6518 /*
6519  * Class:     sun_awt_windows_WComponentPeer
6520  * Method:    getLocationOnScreen
6521  * Signature: ()Ljava/awt/Point;
6522  */
6523 JNIEXPORT jobject JNICALL
6524 Java_sun_awt_windows_WComponentPeer_getLocationOnScreen(JNIEnv *env, jobject self)
6525 {
6526     TRY;
6527 
6528     jobject selfGlobalRef = env->NewGlobalRef(self);
6529 
6530     jobject resultGlobalRef = (jobject)AwtToolkit::GetInstance().SyncCall(
6531         (void*(*)(void*))AwtComponent::_GetLocationOnScreen, (void *)selfGlobalRef);
6532     // selfGlobalRef is deleted in _GetLocationOnScreen
6533     if (resultGlobalRef != NULL)
6534     {
6535         jobject resultLocalRef = env->NewLocalRef(resultGlobalRef);
6536         env->DeleteGlobalRef(resultGlobalRef);
6537         return resultLocalRef;
6538     }
6539 
6540     return NULL;
6541 
6542     CATCH_BAD_ALLOC_RET(NULL);
6543 }
6544 
6545 /*
6546  * Class:     sun_awt_windows_WComponentPeer
6547  * Method:    reshape
6548  * Signature: (IIII)V
6549  */
6550 JNIEXPORT void JNICALL
6551 Java_sun_awt_windows_WComponentPeer_reshape(JNIEnv *env, jobject self,
6552                                             jint x, jint y, jint w, jint h)
6553 {
6554     TRY;
6555 
6556     ReshapeStruct *rs = new ReshapeStruct;
6557     rs->component = env->NewGlobalRef(self);
6558     rs->x = x;
6559     rs->y = y;
6560     rs->w = w;
6561     rs->h = h;
6562 
6563     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Reshape, rs);
6564     // global ref and rs are deleted in _Reshape
6565 
6566     CATCH_BAD_ALLOC;
6567 }
6568 
6569 /*
6570  * Class:     sun_awt_windows_WComponentPeer
6571  * Method:    reshape
6572  * Signature: (IIII)V
6573  */
6574 JNIEXPORT void JNICALL
6575 Java_sun_awt_windows_WComponentPeer_reshapeNoCheck(JNIEnv *env, jobject self,
6576                                             jint x, jint y, jint w, jint h)
6577 {
6578     TRY;
6579 
6580     ReshapeStruct *rs = new ReshapeStruct;
6581     rs->component = env->NewGlobalRef(self);
6582     rs->x = x;
6583     rs->y = y;
6584     rs->w = w;
6585     rs->h = h;
6586 
6587     AwtToolkit::GetInstance().SyncCall(AwtComponent::_ReshapeNoCheck, rs);
6588     // global ref and rs are deleted in _ReshapeNoCheck
6589 
6590     CATCH_BAD_ALLOC;
6591 }
6592 
6593 
6594 /*
6595  * Class:     sun_awt_windows_WComponentPeer
6596  * Method:    nativeHandleEvent
6597  * Signature: (Ljava/awt/AWTEvent;)V
6598  */
6599 JNIEXPORT void JNICALL
6600 Java_sun_awt_windows_WComponentPeer_nativeHandleEvent(JNIEnv *env,
6601                                                       jobject self,
6602                                                       jobject event)
6603 {
6604     TRY;
6605 
6606     jobject selfGlobalRef = env->NewGlobalRef(self);
6607     jobject eventGlobalRef = env->NewGlobalRef(event);
6608 
6609     NativeHandleEventStruct *nhes = new NativeHandleEventStruct;
6610     nhes->component = selfGlobalRef;
6611     nhes->event = eventGlobalRef;
6612 
6613     AwtToolkit::GetInstance().SyncCall(AwtComponent::_NativeHandleEvent, nhes);
6614     // global refs and nhes are deleted in _NativeHandleEvent
6615 
6616     CATCH_BAD_ALLOC;
6617 }
6618 
6619 /*
6620  * Class:     sun_awt_windows_WComponentPeer
6621  * Method:    _dispose
6622  * Signature: ()V
6623  */
6624 JNIEXPORT void JNICALL
6625 Java_sun_awt_windows_WComponentPeer__1dispose(JNIEnv *env, jobject self)
6626 {
6627     TRY_NO_HANG;
6628 
6629     AwtObject::_Dispose(self);
6630 
6631     CATCH_BAD_ALLOC;
6632 }
6633 
6634 /*
6635  * Class:     sun_awt_windows_WComponentPeer
6636  * Method:    _setForeground
6637  * Signature: (I)V
6638  */
6639 JNIEXPORT void JNICALL
6640 Java_sun_awt_windows_WComponentPeer__1setForeground(JNIEnv *env, jobject self,
6641                                                     jint rgb)
6642 {
6643     TRY;
6644 
6645     jobject selfGlobalRef = env->NewGlobalRef(self);
6646 
6647     SetColorStruct *scs = new SetColorStruct;
6648     scs->component = selfGlobalRef;
6649     scs->rgb = rgb;
6650 
6651     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetForeground, scs);
6652     // selfGlobalRef and scs are deleted in _SetForeground()
6653 
6654     CATCH_BAD_ALLOC;
6655 }
6656 
6657 /*
6658  * Class:     sun_awt_windows_WComponentPeer
6659  * Method:    _setBackground
6660  * Signature: (I)V
6661  */
6662 JNIEXPORT void JNICALL
6663 Java_sun_awt_windows_WComponentPeer__1setBackground(JNIEnv *env, jobject self,
6664                                                     jint rgb)
6665 {
6666     TRY;
6667 
6668     jobject selfGlobalRef = env->NewGlobalRef(self);
6669 
6670     SetColorStruct *scs = new SetColorStruct;
6671     scs->component = selfGlobalRef;
6672     scs->rgb = rgb;
6673 
6674     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetBackground, scs);
6675     // selfGlobalRef and scs are deleted in _SetBackground()
6676 
6677     CATCH_BAD_ALLOC;
6678 }
6679 
6680 /*
6681  * Class:     sun_awt_windows_WComponentPeer
6682  * Method:    _setFont
6683  * Signature: (Ljava/awt/Font;)V
6684  */
6685 JNIEXPORT void JNICALL
6686 Java_sun_awt_windows_WComponentPeer__1setFont(JNIEnv *env, jobject self,
6687                         jobject font)
6688 {
6689     TRY;
6690 
6691     jobject selfGlobalRef = env->NewGlobalRef(self);
6692     jobject fontGlobalRef = env->NewGlobalRef(font);
6693 
6694     SetFontStruct *sfs = new SetFontStruct;
6695     sfs->component = selfGlobalRef;
6696     sfs->font = fontGlobalRef;
6697 
6698     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetFont, sfs);
6699     // global refs and sfs are deleted in _SetFont()
6700 
6701     CATCH_BAD_ALLOC;
6702 }
6703 
6704 /*
6705  * Class:     sun_awt_windows_WComponentPeer
6706  * Method:    focusGained
6707  * Signature: (Z)
6708  */
6709 JNIEXPORT void JNICALL Java_sun_awt_windows_WComponentPeer_setFocus
6710     (JNIEnv *env, jobject self, jboolean doSetFocus)
6711 {
6712     TRY;
6713 
6714     jobject selfGlobalRef = env->NewGlobalRef(self);
6715 
6716     SetFocusStruct *sfs = new SetFocusStruct;
6717     sfs->component = selfGlobalRef;
6718     sfs->doSetFocus = doSetFocus;
6719 
6720     AwtToolkit::GetInstance().SyncCall(
6721         (void*(*)(void*))AwtComponent::_SetFocus, sfs);
6722     // global refs and self are deleted in _SetFocus
6723 
6724     CATCH_BAD_ALLOC;
6725 }
6726 
6727 /*
6728  * Class:     sun_awt_windows_WComponentPeer
6729  * Method:    start
6730  * Signature: ()V
6731  */
6732 JNIEXPORT void JNICALL
6733 Java_sun_awt_windows_WComponentPeer_start(JNIEnv *env, jobject self)
6734 {
6735     TRY;
6736 
6737     jobject selfGlobalRef = env->NewGlobalRef(self);
6738 
6739     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Start, (void *)selfGlobalRef);
6740     // selfGlobalRef is deleted in _Start
6741 
6742     CATCH_BAD_ALLOC;
6743 }
6744 
6745 /*
6746  * Class:     sun_awt_windows_WComponentPeer
6747  * Method:    beginValidate
6748  * Signature: ()V
6749  */
6750 JNIEXPORT void JNICALL
6751 Java_sun_awt_windows_WComponentPeer_beginValidate(JNIEnv *env, jobject self)
6752 {
6753     TRY;
6754 
6755     jobject selfGlobalRef = env->NewGlobalRef(self);
6756 
6757     AwtToolkit::GetInstance().SyncCall(AwtComponent::_BeginValidate, (void *)selfGlobalRef);
6758     // selfGlobalRef is deleted in _BeginValidate
6759 
6760     CATCH_BAD_ALLOC;
6761 }
6762 
6763 /*
6764  * Class:     sun_awt_windows_WComponentPeer
6765  * Method:    endValidate
6766  * Signature: ()V
6767  */
6768 JNIEXPORT void JNICALL
6769 Java_sun_awt_windows_WComponentPeer_endValidate(JNIEnv *env, jobject self)
6770 {
6771     TRY;
6772 
6773     jobject selfGlobalRef = env->NewGlobalRef(self);
6774 
6775     AwtToolkit::GetInstance().SyncCall(AwtComponent::_EndValidate, (void *)selfGlobalRef);
6776     // selfGlobalRef is deleted in _EndValidate
6777 
6778     CATCH_BAD_ALLOC;
6779 }
6780 
6781 JNIEXPORT void JNICALL
6782 Java_sun_awt_windows_WComponentPeer_updateWindow(JNIEnv *env, jobject self)
6783 {
6784     TRY;
6785 
6786     jobject selfGlobalRef = env->NewGlobalRef(self);
6787 
6788     AwtToolkit::GetInstance().SyncCall(AwtComponent::_UpdateWindow, (void *)selfGlobalRef);
6789     // selfGlobalRef is deleted in _UpdateWindow
6790 
6791     CATCH_BAD_ALLOC;
6792 }
6793 
6794 /*
6795  * Class:     sun_awt_windows_WComponentPeer
6796  * Method:    addNativeDropTarget
6797  * Signature: ()L
6798  */
6799 
6800 JNIEXPORT jlong JNICALL
6801 Java_sun_awt_windows_WComponentPeer_addNativeDropTarget(JNIEnv *env,
6802                                                         jobject self)
6803 {
6804     TRY;
6805 
6806     jobject selfGlobalRef = env->NewGlobalRef(self);
6807 
6808     return ptr_to_jlong(AwtToolkit::GetInstance().SyncCall(
6809         (void*(*)(void*))AwtComponent::_AddNativeDropTarget,
6810         (void *)selfGlobalRef));
6811     // selfGlobalRef is deleted in _AddNativeDropTarget
6812 
6813     CATCH_BAD_ALLOC_RET(0);
6814 }
6815 
6816 /*
6817  * Class:     sun_awt_windows_WComponentPeer
6818  * Method:    removeNativeDropTarget
6819  * Signature: ()V
6820  */
6821 
6822 JNIEXPORT void JNICALL
6823 Java_sun_awt_windows_WComponentPeer_removeNativeDropTarget(JNIEnv *env,
6824                                                            jobject self)
6825 {
6826     TRY;
6827 
6828     jobject selfGlobalRef = env->NewGlobalRef(self);
6829 
6830     AwtToolkit::GetInstance().SyncCall(
6831         AwtComponent::_RemoveNativeDropTarget, (void *)selfGlobalRef);
6832     // selfGlobalRef is deleted in _RemoveNativeDropTarget
6833 
6834     CATCH_BAD_ALLOC;
6835 }
6836 
6837 /*
6838  * Class:     sun_awt_windows_WComponentPeer
6839  * Method:    getTargetGC
6840  * Signature: ()Ljava/awt/GraphicsConfiguration;
6841  */
6842 JNIEXPORT jobject JNICALL
6843 Java_sun_awt_windows_WComponentPeer_getTargetGC(JNIEnv* env, jobject theThis)
6844 {
6845     TRY;
6846 
6847     jobject targetObj;
6848     jobject gc = 0;
6849 
6850     targetObj = env->GetObjectField(theThis, AwtObject::targetID);
6851     DASSERT(targetObj);
6852 
6853     gc = env->GetObjectField(targetObj, AwtComponent::graphicsConfigID);
6854     return gc;
6855 
6856     CATCH_BAD_ALLOC_RET(NULL);
6857 }
6858 
6859 /*
6860  * Class:     sun_awt_windows_WComponentPeer
6861  * Method:    createPrintedPixels
6862  * Signature: (IIIIII)I[
6863  */
6864 JNIEXPORT jintArray JNICALL
6865 Java_sun_awt_windows_WComponentPeer_createPrintedPixels(JNIEnv* env,
6866     jobject self, jint srcX, jint srcY, jint srcW, jint srcH, jint alpha)
6867 {
6868     TRY;
6869 
6870     jobject selfGlobalRef = env->NewGlobalRef(self);
6871 
6872     CreatePrintedPixelsStruct *cpps = new CreatePrintedPixelsStruct;
6873     cpps->component = selfGlobalRef;
6874     cpps->srcx = srcX;
6875     cpps->srcy = srcY;
6876     cpps->srcw = srcW;
6877     cpps->srch = srcH;
6878     cpps->alpha = alpha;
6879 
6880     jintArray globalRef = (jintArray)AwtToolkit::GetInstance().SyncCall(
6881         (void*(*)(void*))AwtComponent::_CreatePrintedPixels, cpps);
6882     // selfGlobalRef and cpps are deleted in _CreatePrintedPixels
6883     if (globalRef != NULL)
6884     {
6885         jintArray localRef = (jintArray)env->NewLocalRef(globalRef);
6886         env->DeleteGlobalRef(globalRef);
6887         return localRef;
6888     }
6889     else
6890     {
6891         return NULL;
6892     }
6893 
6894     CATCH_BAD_ALLOC_RET(NULL);
6895 }
6896 
6897 /*
6898  * Class:     sun_awt_windows_WComponentPeer
6899  * Method:    nativeHandlesWheelScrolling
6900  * Signature: ()Z
6901  */
6902 JNIEXPORT jboolean JNICALL
6903 Java_sun_awt_windows_WComponentPeer_nativeHandlesWheelScrolling (JNIEnv* env,
6904     jobject self)
6905 {
6906     TRY;
6907 
6908     return (jboolean)AwtToolkit::GetInstance().SyncCall(
6909         (void *(*)(void *))AwtComponent::_NativeHandlesWheelScrolling,
6910         env->NewGlobalRef(self));
6911     // global ref is deleted in _NativeHandlesWheelScrolling
6912 
6913     CATCH_BAD_ALLOC_RET(NULL);
6914 }
6915 
6916 /*
6917  * Class:     sun_awt_windows_WComponentPeer
6918  * Method:    isObscured
6919  * Signature: ()Z
6920  */
6921 JNIEXPORT jboolean JNICALL
6922 Java_sun_awt_windows_WComponentPeer_isObscured(JNIEnv* env,
6923     jobject self)
6924 {
6925     TRY;
6926 
6927     jobject selfGlobalRef = env->NewGlobalRef(self);
6928 
6929     return (jboolean)AwtToolkit::GetInstance().SyncCall(
6930         (void*(*)(void*))AwtComponent::_IsObscured,
6931         (void *)selfGlobalRef);
6932     // selfGlobalRef is deleted in _IsObscured
6933 
6934     CATCH_BAD_ALLOC_RET(NULL);
6935 }
6936 
6937 JNIEXPORT void JNICALL
6938 Java_sun_awt_windows_WComponentPeer_pSetParent(JNIEnv* env, jobject self, jobject parent) {
6939     TRY;
6940 
6941     typedef AwtComponent* PComponent;
6942     AwtComponent** comps = new PComponent[2];
6943     AwtComponent* comp = (AwtComponent*)JNI_GET_PDATA(self);
6944     AwtComponent* parentComp = (AwtComponent*)JNI_GET_PDATA(parent);
6945     comps[0] = comp;
6946     comps[1] = parentComp;
6947 
6948     AwtToolkit::GetInstance().SyncCall(AwtComponent::SetParent, comps);
6949     // comps is deleted in SetParent
6950 
6951     CATCH_BAD_ALLOC;
6952 }
6953 
6954 JNIEXPORT void JNICALL
6955 Java_sun_awt_windows_WComponentPeer_setRectangularShape(JNIEnv* env, jobject self,
6956         jint x1, jint y1, jint x2, jint y2, jobject region)
6957 {
6958     TRY;
6959 
6960     SetRectangularShapeStruct * data = new SetRectangularShapeStruct;
6961     data->component = env->NewGlobalRef(self);
6962     data->x1 = x1;
6963     data->x2 = x2;
6964     data->y1 = y1;
6965     data->y2 = y2;
6966     if (region) {
6967         data->region = env->NewGlobalRef(region);
6968     } else {
6969         data->region = NULL;
6970     }
6971 
6972     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetRectangularShape, data);
6973     // global refs and data are deleted in _SetRectangularShape
6974 
6975     CATCH_BAD_ALLOC;
6976 }
6977 
6978 JNIEXPORT void JNICALL
6979 Java_sun_awt_windows_WComponentPeer_setZOrder(JNIEnv* env, jobject self, jlong above)
6980 {
6981     TRY;
6982 
6983     SetZOrderStruct * data = new SetZOrderStruct;
6984     data->component = env->NewGlobalRef(self);
6985     data->above = above;
6986 
6987     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetZOrder, data);
6988     // global refs and data are deleted in _SetLower
6989 
6990     CATCH_BAD_ALLOC;
6991 }
6992 
6993 } /* extern "C" */
6994 
6995 
6996 /************************************************************************
6997  * Diagnostic routines
6998  */
6999 
7000 #ifdef DEBUG
7001 
7002 void AwtComponent::VerifyState()
7003 {
7004     if (AwtToolkit::GetInstance().VerifyComponents() == FALSE) {
7005         return;
7006     }
7007 
7008     if (m_callbacksEnabled == FALSE) {
7009         /* Component is not fully setup yet. */
7010         return;
7011     }
7012 
7013     /* Get target bounds. */
7014     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
7015     if (env->PushLocalFrame(10) < 0)
7016         return;
7017 
7018     jobject target = GetTarget(env);
7019 
7020     jint x = env->GetIntField(target, AwtComponent::xID);
7021     jint y = env->GetIntField(target, AwtComponent::yID);
7022     jint width = env->GetIntField(target, AwtComponent::widthID);
7023     jint height = env->GetIntField(target, AwtComponent::heightID);
7024 
7025     /* Convert target origin to absolute coordinates */
7026     while (TRUE) {
7027 
7028         jobject parent = env->GetObjectField(target, AwtComponent::parentID);
7029         if (parent == NULL) {
7030             break;
7031         }
7032         x += env->GetIntField(parent, AwtComponent::xID);
7033         y += env->GetIntField(parent, AwtComponent::yID);
7034 
7035         /* If this component has insets, factor them in, but ignore
7036          * top-level windows.
7037          */
7038         jobject parent2 = env->GetObjectField(parent, AwtComponent::parentID);
7039         if (parent2 != NULL) {
7040             jobject peer = GetPeerForTarget(env, parent);
7041             if (peer != NULL &&
7042                 JNU_IsInstanceOfByName(env, peer,
7043                                        "sun/awt/windows/WPanelPeer") > 0) {
7044                 jobject insets =
7045                     JNU_CallMethodByName(env, NULL, peer,"insets",
7046                                          "()Ljava/awt/Insets;").l;
7047                 x += (env)->GetIntField(insets, AwtInsets::leftID);
7048                 y += (env)->GetIntField(insets, AwtInsets::topID);
7049             }
7050         }
7051         env->DeleteLocalRef(target);
7052         target = parent;
7053     }
7054 
7055     // Test whether component's bounds match the native window's
7056     RECT rect;
7057     VERIFY(::GetWindowRect(GetHWnd(), &rect));
7058 #if 0
7059     DASSERT( (x == rect.left) &&
7060             (y == rect.top) &&
7061             (width == (rect.right-rect.left)) &&
7062             (height == (rect.bottom-rect.top)) );
7063 #else
7064     BOOL fSizeValid = ( (x == rect.left) &&
7065             (y == rect.top) &&
7066             (width == (rect.right-rect.left)) &&
7067             (height == (rect.bottom-rect.top)) );
7068 #endif
7069 
7070     // See if visible state matches
7071     BOOL wndVisible = ::IsWindowVisible(GetHWnd());
7072     jboolean targetVisible;
7073     // To avoid possibly running client code on the toolkit thread, don't
7074     // do the following check if we're running on the toolkit thread.
7075     if (AwtToolkit::MainThread() != ::GetCurrentThreadId()) {
7076         targetVisible = JNU_CallMethodByName(env, NULL, GetTarget(env),
7077                                                   "isShowing", "()Z").z;
7078         DASSERT(!safe_ExceptionOccurred(env));
7079     } else {
7080         targetVisible = wndVisible ? 1 : 0;
7081     }
7082 #if 0
7083     DASSERT( (targetVisible && wndVisible) ||
7084             (!targetVisible && !wndVisible) );
7085 #else
7086     BOOL fVisibleValid = ( (targetVisible && wndVisible) ||
7087             (!targetVisible && !wndVisible) );
7088 #endif
7089 
7090     // Check enabled state
7091     BOOL wndEnabled = ::IsWindowEnabled(GetHWnd());
7092     jboolean enabled = (jboolean)env->GetBooleanField(target,
7093                                                       AwtComponent::enabledID);
7094 #if 0
7095     DASSERT( (enabled && wndEnabled) ||
7096             (!enabled && !wndEnabled) );
7097 #else
7098     BOOL fEnabledValid = ((enabled && wndEnabled) ||
7099                           (!(enabled && !wndEnabled) ));
7100 
7101     if (!fSizeValid || !fVisibleValid || !fEnabledValid) {
7102         printf("AwtComponent::ValidateState() failed:\n");
7103         // To avoid possibly running client code on the toolkit thread, don't
7104         // do the following call if we're running on the toolkit thread.
7105         if (AwtToolkit::MainThread() != ::GetCurrentThreadId()) {
7106             jstring targetStr =
7107                 (jstring)JNU_CallMethodByName(env, NULL, GetTarget(env),
7108                                               "getName",
7109                                               "()Ljava/lang/String;").l;
7110             DASSERT(!safe_ExceptionOccurred(env));
7111             LPCWSTR targetStrW = JNU_GetStringPlatformChars(env, targetStr, NULL);
7112             printf("\t%S\n", targetStrW);
7113             JNU_ReleaseStringPlatformChars(env, targetStr, targetStrW);
7114         }
7115         printf("\twas:       [%d,%d,%dx%d]\n", x, y, width, height);
7116         if (!fSizeValid) {
7117             printf("\tshould be: [%d,%d,%dx%d]\n", rect.left, rect.top,
7118                    rect.right-rect.left, rect.bottom-rect.top);
7119         }
7120         if (!fVisibleValid) {
7121             printf("\tshould be: %s\n",
7122                    (targetVisible) ? "visible" : "hidden");
7123         }
7124         if (!fEnabledValid) {
7125             printf("\tshould be: %s\n",
7126                    enabled ? "enabled" : "disabled");
7127         }
7128     }
7129 #endif
7130     env->PopLocalFrame(0);
7131 }
7132 #endif //DEBUG
7133 
7134 // Methods for globally managed DC list
7135 
7136 /**
7137  * Add a new DC to the DC list for this component.
7138  */
7139 void DCList::AddDC(HDC hDC, HWND hWnd)
7140 {
7141     DCItem *newItem = new DCItem;
7142     newItem->hDC = hDC;
7143     newItem->hWnd = hWnd;
7144     AddDCItem(newItem);
7145 }
7146 
7147 void DCList::AddDCItem(DCItem *newItem)
7148 {
7149     listLock.Enter();
7150     newItem->next = head;
7151     head = newItem;
7152     listLock.Leave();
7153 }
7154 
7155 /**
7156  * Given a DC, remove it from the DC list and return
7157  * TRUE if it exists on the current list.  Otherwise
7158  * return FALSE.
7159  * A DC may not exist on the list because it has already
7160  * been released elsewhere (for example, the window
7161  * destruction process may release a DC while a rendering
7162  * thread may also want to release a DC when it notices that
7163  * its DC is obsolete for the current window).
7164  */
7165 DCItem *DCList::RemoveDC(HDC hDC)
7166 {
7167     listLock.Enter();
7168     DCItem **prevPtrPtr = &head;
7169     DCItem *listPtr = head;
7170     while (listPtr) {
7171         DCItem *nextPtr = listPtr->next;
7172         if (listPtr->hDC == hDC) {
7173             *prevPtrPtr = nextPtr;
7174             break;
7175         }
7176         prevPtrPtr = &listPtr->next;
7177         listPtr = nextPtr;
7178     }
7179     listLock.Leave();
7180     return listPtr;
7181 }
7182 
7183 /**
7184  * Remove all DCs from the DC list which are associated with
7185  * the same window as hWnd.  Return the list of those
7186  * DC's to the caller (which will then probably want to
7187  * call ReleaseDC() for the returned DCs).
7188  */
7189 DCItem *DCList::RemoveAllDCs(HWND hWnd)
7190 {
7191     listLock.Enter();
7192     DCItem **prevPtrPtr = &head;
7193     DCItem *listPtr = head;
7194     DCItem *newListPtr = NULL;
7195     BOOL ret = FALSE;
7196     while (listPtr) {
7197         DCItem *nextPtr = listPtr->next;
7198         if (listPtr->hWnd == hWnd) {
7199             *prevPtrPtr = nextPtr;
7200             listPtr->next = newListPtr;
7201             newListPtr = listPtr;
7202         } else {
7203             prevPtrPtr = &listPtr->next;
7204         }
7205         listPtr = nextPtr;
7206     }
7207     listLock.Leave();
7208     return newListPtr;
7209 }
7210 
7211 
7212 /**
7213  * Realize palettes of all existing HDC objects
7214  */
7215 void DCList::RealizePalettes(int screen)
7216 {
7217     listLock.Enter();
7218     DCItem *listPtr = head;
7219     while (listPtr) {
7220         AwtWin32GraphicsDevice::RealizePalette(listPtr->hDC, screen);
7221         listPtr = listPtr->next;
7222     }
7223     listLock.Leave();
7224 }
7225 
7226 void MoveDCToPassiveList(HDC hDC) {
7227     DCItem *removedDC;
7228     if ((removedDC = activeDCList.RemoveDC(hDC)) != NULL) {
7229         passiveDCList.AddDCItem(removedDC);
7230     }
7231 }
7232 
7233 void ReleaseDCList(HWND hwnd, DCList &list) {
7234     DCItem *removedDCs = list.RemoveAllDCs(hwnd);
7235     while (removedDCs) {
7236         DCItem *tmpDCList = removedDCs;
7237         DASSERT(::GetObjectType(tmpDCList->hDC) == OBJ_DC);
7238         int retValue = ::ReleaseDC(tmpDCList->hWnd, tmpDCList->hDC);
7239         VERIFY(retValue != 0);
7240         if (retValue != 0) {
7241             // Valid ReleaseDC call; need to decrement GDI object counter
7242             AwtGDIObject::Decrement();
7243         }
7244         removedDCs = removedDCs->next;
7245         delete tmpDCList;
7246     }
7247 }
7248