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