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