1 /*
   2  * Copyright (c) 1996, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include "awt.h"
  27 
  28 #include <windowsx.h>
  29 #include <zmouse.h>
  30 
  31 #include "jlong.h"
  32 #include "awt_AWTEvent.h"
  33 #include "awt_BitmapUtil.h"
  34 #include "awt_Component.h"
  35 #include "awt_Cursor.h"
  36 #include "awt_Dimension.h"
  37 #include "awt_Frame.h"
  38 #include "awt_InputEvent.h"
  39 #include "awt_InputTextInfor.h"
  40 #include "awt_Insets.h"
  41 #include "awt_KeyEvent.h"
  42 #include "awt_MenuItem.h"
  43 #include "awt_MouseEvent.h"
  44 #include "awt_Palette.h"
  45 #include "awt_Toolkit.h"
  46 #include "awt_Window.h"
  47 #include "awt_Win32GraphicsDevice.h"
  48 #include "Hashtable.h"
  49 #include "ComCtl32Util.h"
  50 
  51 #include <Region.h>
  52 
  53 #include <jawt.h>
  54 
  55 #include <java_awt_Toolkit.h>
  56 #include <java_awt_FontMetrics.h>
  57 #include <java_awt_Color.h>
  58 #include <java_awt_Event.h>
  59 #include <java_awt_event_KeyEvent.h>
  60 #include <java_awt_Insets.h>
  61 #include <sun_awt_windows_WPanelPeer.h>
  62 #include <java_awt_event_InputEvent.h>
  63 #include <java_awt_event_InputMethodEvent.h>
  64 #include <sun_awt_windows_WInputMethod.h>
  65 #include <java_awt_event_MouseEvent.h>
  66 #include <java_awt_event_MouseWheelEvent.h>
  67 
  68 // Begin -- Win32 SDK include files
  69 #include <imm.h>
  70 #include <ime.h>
  71 // End -- Win32 SDK include files
  72 
  73 #include <awt_DnDDT.h>
  74 
  75 LPCTSTR szAwtComponentClassName = TEXT("SunAwtComponent");
  76 // register a message that no other window in the process (even in a plugin
  77 // scenario) will be using
  78 const UINT AwtComponent::WmAwtIsComponent =
  79     ::RegisterWindowMessage(szAwtComponentClassName);
  80 
  81 static HWND g_hwndDown = NULL;
  82 static DCList activeDCList;
  83 static DCList passiveDCList;
  84 
  85 extern void CheckFontSmoothingSettings(HWND);
  86 
  87 extern "C" {
  88     // Remember the input language has changed by some user's action
  89     // (Alt+Shift or through the language icon on the Taskbar) to control the
  90     // race condition between the toolkit thread and the AWT event thread.
  91     // This flag remains TRUE until the next WInputMethod.getNativeLocale() is
  92     // issued.
  93     BOOL g_bUserHasChangedInputLang = FALSE;
  94 }
  95 
  96 BOOL AwtComponent::sm_suppressFocusAndActivation = FALSE;
  97 BOOL AwtComponent::sm_restoreFocusAndActivation = FALSE;
  98 HWND AwtComponent::sm_focusOwner = NULL;
  99 HWND AwtComponent::sm_focusedWindow = NULL;
 100 BOOL AwtComponent::sm_bMenuLoop = FALSE;
 101 AwtComponent* AwtComponent::sm_getComponentCache = NULL;
 102 BOOL AwtComponent::sm_inSynthesizeFocus = FALSE;
 103 
 104 /************************************************************************/
 105 // Struct for _Reshape() and ReshapeNoCheck() methods
 106 struct ReshapeStruct {
 107     jobject component;
 108     jint x, y;
 109     jint w, h;
 110 };
 111 // Struct for _NativeHandleEvent() method
 112 struct NativeHandleEventStruct {
 113     jobject component;
 114     jobject event;
 115 };
 116 // Struct for _SetForeground() and _SetBackground() methods
 117 struct SetColorStruct {
 118     jobject component;
 119     jint rgb;
 120 };
 121 // Struct for _SetFont() method
 122 struct SetFontStruct {
 123     jobject component;
 124     jobject font;
 125 };
 126 // Struct for _CreatePrintedPixels() method
 127 struct CreatePrintedPixelsStruct {
 128     jobject component;
 129     int srcx, srcy;
 130     int srcw, srch;
 131     jint alpha;
 132 };
 133 // Struct for _SetRectangularShape() method
 134 struct SetRectangularShapeStruct {
 135     jobject component;
 136     jint x1, x2, y1, y2;
 137     jobject region;
 138 };
 139 // Struct for _GetInsets function
 140 struct GetInsetsStruct {
 141     jobject window;
 142     RECT *insets;
 143 };
 144 // Struct for _SetZOrder function
 145 struct SetZOrderStruct {
 146     jobject component;
 147     jlong above;
 148 };
 149 // Struct for _SetFocus function
 150 struct SetFocusStruct {
 151     jobject component;
 152     jboolean doSetFocus;
 153 };
 154 /************************************************************************/
 155 
 156 //////////////////////////////////////////////////////////////////////////
 157 
 158 /*************************************************************************
 159  * AwtComponent fields
 160  */
 161 
 162 
 163 jfieldID AwtComponent::peerID;
 164 jfieldID AwtComponent::xID;
 165 jfieldID AwtComponent::yID;
 166 jfieldID AwtComponent::widthID;
 167 jfieldID AwtComponent::heightID;
 168 jfieldID AwtComponent::visibleID;
 169 jfieldID AwtComponent::backgroundID;
 170 jfieldID AwtComponent::foregroundID;
 171 jfieldID AwtComponent::enabledID;
 172 jfieldID AwtComponent::parentID;
 173 jfieldID AwtComponent::graphicsConfigID;
 174 jfieldID AwtComponent::peerGCID;
 175 jfieldID AwtComponent::focusableID;
 176 jfieldID AwtComponent::appContextID;
 177 jfieldID AwtComponent::cursorID;
 178 jfieldID AwtComponent::hwndID;
 179 
 180 jmethodID AwtComponent::getFontMID;
 181 jmethodID AwtComponent::getToolkitMID;
 182 jmethodID AwtComponent::isEnabledMID;
 183 jmethodID AwtComponent::getLocationOnScreenMID;
 184 jmethodID AwtComponent::replaceSurfaceDataMID;
 185 jmethodID AwtComponent::replaceSurfaceDataLaterMID;
 186 jmethodID AwtComponent::disposeLaterMID;
 187 
 188 HKL    AwtComponent::m_hkl = ::GetKeyboardLayout(0);
 189 LANGID AwtComponent::m_idLang = LOWORD(::GetKeyboardLayout(0));
 190 UINT   AwtComponent::m_CodePage
 191                        = AwtComponent::LangToCodePage(m_idLang);
 192 
 193 jint *AwtComponent::masks;
 194 
 195 static BOOL bLeftShiftIsDown = false;
 196 static BOOL bRightShiftIsDown = false;
 197 static UINT lastShiftKeyPressed = 0; // init to safe value
 198 
 199 // Added by waleed to initialize the RTL Flags
 200 BOOL AwtComponent::sm_rtl = PRIMARYLANGID(GetInputLanguage()) == LANG_ARABIC ||
 201                             PRIMARYLANGID(GetInputLanguage()) == LANG_HEBREW;
 202 BOOL AwtComponent::sm_rtlReadingOrder =
 203     PRIMARYLANGID(GetInputLanguage()) == LANG_ARABIC;
 204 
 205 BOOL AwtComponent::sm_PrimaryDynamicTableBuilt = FALSE;
 206 
 207 HWND AwtComponent::sm_cursorOn;
 208 BOOL AwtComponent::m_QueryNewPaletteCalled = FALSE;
 209 
 210 CriticalSection windowMoveLock;
 211 BOOL windowMoveLockHeld = FALSE;
 212 
 213 /************************************************************************
 214  * AwtComponent methods
 215  */
 216 
 217 AwtComponent::AwtComponent()
 218 {
 219     m_mouseButtonClickAllowed = 0;
 220     m_callbacksEnabled = FALSE;
 221     m_hwnd = NULL;
 222 
 223     m_colorForeground = 0;
 224     m_colorBackground = 0;
 225     m_backgroundColorSet = FALSE;
 226     m_penForeground = NULL;
 227     m_brushBackground = NULL;
 228     m_DefWindowProc = NULL;
 229     m_nextControlID = 1;
 230     m_childList = NULL;
 231     m_myControlID = 0;
 232     m_hdwp = NULL;
 233     m_validationNestCount = 0;
 234 
 235     m_dropTarget = NULL;
 236 
 237     m_InputMethod = NULL;
 238     m_useNativeCompWindow = TRUE;
 239     m_PendingLeadByte = 0;
 240     m_bitsCandType = 0;
 241 
 242     windowMoveLockPosX = 0;
 243     windowMoveLockPosY = 0;
 244     windowMoveLockPosCX = 0;
 245     windowMoveLockPosCY = 0;
 246 
 247     m_hCursorCache = NULL;
 248 
 249     m_bSubclassed = FALSE;
 250     m_bPauseDestroy = FALSE;
 251 
 252     m_MessagesProcessing = 0;
 253     m_wheelRotationAmount = 0;
 254     if (!sm_PrimaryDynamicTableBuilt) {
 255         // do it once.
 256         AwtComponent::BuildPrimaryDynamicTable();
 257         sm_PrimaryDynamicTableBuilt = TRUE;
 258     }
 259 }
 260 
 261 AwtComponent::~AwtComponent()
 262 {
 263     DASSERT(AwtToolkit::IsMainThread());
 264 
 265     /* Disconnect all links. */
 266     UnlinkObjects();
 267 
 268     /*
 269      * All the messages for this component are processed, native
 270      * resources are freed, and Java object is not connected to
 271      * the native one anymore. So we can safely destroy component's
 272      * handle.
 273      */
 274     DestroyHWnd();
 275 
 276     if (sm_getComponentCache == this) {
 277         sm_getComponentCache = NULL;
 278     }
 279 }
 280 
 281 void AwtComponent::Dispose()
 282 {
 283     // NOTE: in case the component/toplevel was focused, Java should
 284     // have already taken care of proper transferring it or clearing.
 285 
 286     if (m_hdwp != NULL) {
 287     // end any deferred window positioning, regardless
 288     // of m_validationNestCount
 289         ::EndDeferWindowPos(m_hdwp);
 290     }
 291 
 292     // Send final message to release all DCs associated with this component
 293     SendMessage(WM_AWT_RELEASE_ALL_DCS);
 294 
 295     /* Stop message filtering. */
 296     UnsubclassHWND();
 297 
 298     /* Release global ref to input method */
 299     SetInputMethod(NULL, TRUE);
 300 
 301     if (m_childList != NULL)
 302         delete m_childList;
 303 
 304     DestroyDropTarget();
 305     ReleaseDragCapture(0);
 306 
 307     if (m_myControlID != 0) {
 308         AwtComponent* parent = GetParent();
 309         if (parent != NULL)
 310             parent->RemoveChild(m_myControlID);
 311     }
 312 
 313     ::RemoveProp(GetHWnd(), DrawingStateProp);
 314 
 315     /* Release any allocated resources. */
 316     if (m_penForeground != NULL) {
 317         m_penForeground->Release();
 318         m_penForeground = NULL;
 319     }
 320     if (m_brushBackground != NULL) {
 321         m_brushBackground->Release();
 322         m_brushBackground = NULL;
 323     }
 324 
 325     if (m_bPauseDestroy) {
 326         // AwtComponent::WmNcDestroy could be released now
 327         m_bPauseDestroy = FALSE;
 328         m_hwnd = NULL;
 329     }
 330 
 331     // The component instance is deleted using AwtObject::Dispose() method
 332     AwtObject::Dispose();
 333 }
 334 
 335 /* store component pointer in window extra bytes */
 336 void AwtComponent::SetComponentInHWND() {
 337     DASSERT(::GetWindowLongPtr(GetHWnd(), GWLP_USERDATA) == NULL);
 338     ::SetWindowLongPtr(GetHWnd(), GWLP_USERDATA, (LONG_PTR)this);
 339 }
 340 
 341 /*
 342  * static function to get AwtComponent pointer from hWnd --
 343  * you don't want to call this from inside a wndproc to avoid
 344  * infinite recursion
 345  */
 346 AwtComponent* AwtComponent::GetComponent(HWND hWnd) {
 347     // Requests for Toolkit hwnd resolution happen pretty often. Check first.
 348     if (hWnd == AwtToolkit::GetInstance().GetHWnd()) {
 349         return NULL;
 350     }
 351     if (sm_getComponentCache && sm_getComponentCache->GetHWnd() == hWnd) {
 352         return sm_getComponentCache;
 353     }
 354 
 355     // check that it's an AWT component from the same toolkit as the caller
 356     if (::IsWindow(hWnd) &&
 357         AwtToolkit::MainThread() == ::GetWindowThreadProcessId(hWnd, NULL))
 358     {
 359         DASSERT(WmAwtIsComponent != 0);
 360         if (::SendMessage(hWnd, WmAwtIsComponent, 0, 0L)) {
 361             return sm_getComponentCache = GetComponentImpl(hWnd);
 362         }
 363     }
 364     return NULL;
 365 }
 366 
 367 /*
 368  * static function to get AwtComponent pointer from hWnd--
 369  * different from GetComponent because caller knows the
 370  * hwnd is an AWT component hwnd
 371  */
 372 AwtComponent* AwtComponent::GetComponentImpl(HWND hWnd) {
 373     AwtComponent *component =
 374         (AwtComponent *)::GetWindowLongPtr(hWnd, GWLP_USERDATA);
 375     DASSERT(!component || !IsBadReadPtr(component, sizeof(AwtComponent)) );
 376     DASSERT(!component || component->GetHWnd() == hWnd );
 377     return component;
 378 }
 379 
 380 /*
 381  * Single window proc for all the components. Delegates real work to
 382  * the component's WindowProc() member function.
 383  */
 384 LRESULT CALLBACK AwtComponent::WndProc(HWND hWnd, UINT message,
 385                                        WPARAM wParam, LPARAM lParam)
 386 {
 387     TRY;
 388 
 389     AwtComponent * self = AwtComponent::GetComponentImpl(hWnd);
 390     if (self == NULL || self->GetHWnd() != hWnd ||
 391         message == WM_UNDOCUMENTED_CLIENTSHUTDOWN) // handle log-off gracefully
 392     {
 393         return ComCtl32Util::GetInstance().DefWindowProc(NULL, hWnd, message, wParam, lParam);
 394     } else {
 395         return self->WindowProc(message, wParam, lParam);
 396     }
 397 
 398     CATCH_BAD_ALLOC_RET(0);
 399 }
 400 
 401 BOOL AwtComponent::IsFocusable() {
 402     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 403     jobject peer = GetPeer(env);
 404     jobject target = env->GetObjectField(peer, AwtObject::targetID);
 405     BOOL res = env->GetBooleanField(target, focusableID);
 406     AwtWindow *pCont = GetContainer();
 407     if (pCont) {
 408         res &= pCont->IsFocusableWindow();
 409     }
 410     env->DeleteLocalRef(target);
 411     return res;
 412 }
 413 
 414 /************************************************************************
 415  * AwtComponent dynamic methods
 416  *
 417  * Window class registration routines
 418  */
 419 
 420 /*
 421  * Fix for 4964237: Win XP: Changing theme changes java dialogs title icon
 422  */
 423 void AwtComponent::FillClassInfo(WNDCLASSEX *lpwc)
 424 {
 425     lpwc->cbSize        = sizeof(WNDCLASSEX);
 426     lpwc->style         = 0L;//CS_OWNDC;
 427     lpwc->lpfnWndProc   = (WNDPROC)::DefWindowProc;
 428     lpwc->cbClsExtra    = 0;
 429     lpwc->cbWndExtra    = 0;
 430     lpwc->hInstance     = AwtToolkit::GetInstance().GetModuleHandle(),
 431     lpwc->hIcon         = AwtToolkit::GetInstance().GetAwtIcon();
 432     lpwc->hCursor       = NULL;
 433     lpwc->hbrBackground = NULL;
 434     lpwc->lpszMenuName  = NULL;
 435     lpwc->lpszClassName = GetClassName();
 436     //Fixed 6233560: PIT: Java Cup Logo on the title bar of top-level windows look blurred, Win32
 437     lpwc->hIconSm       = AwtToolkit::GetInstance().GetAwtIconSm();
 438 }
 439 
 440 void AwtComponent::RegisterClass()
 441 {
 442     WNDCLASSEX wc;
 443     if (!::GetClassInfoEx(AwtToolkit::GetInstance().GetModuleHandle(), GetClassName(), &wc)) {
 444         FillClassInfo(&wc);
 445         ATOM ret = ::RegisterClassEx(&wc);
 446         DASSERT(ret != 0);
 447     }
 448 }
 449 
 450 void AwtComponent::UnregisterClass()
 451 {
 452     ::UnregisterClass(GetClassName(), AwtToolkit::GetInstance().GetModuleHandle());
 453 }
 454 
 455 /*
 456  * Copy the graphicsConfig reference from Component into WComponentPeer
 457  */
 458 void AwtComponent::InitPeerGraphicsConfig(JNIEnv *env, jobject peer)
 459 {
 460     jobject target = env->GetObjectField(peer, AwtObject::targetID);
 461     //Get graphicsConfig object ref from Component
 462     jobject compGC = env->GetObjectField(target,
 463                       AwtComponent::graphicsConfigID);
 464 
 465     //Set peer's graphicsConfig to Component's graphicsConfig
 466     if (compGC != NULL) {
 467         jclass win32GCCls = env->FindClass("sun/awt/Win32GraphicsConfig");
 468         DASSERT(win32GCCls != NULL);
 469         DASSERT(env->IsInstanceOf(compGC, win32GCCls));
 470         if (win32GCCls == NULL) {
 471             throw std::bad_alloc();
 472         }
 473         env->SetObjectField(peer, AwtComponent::peerGCID, compGC);
 474     }
 475 }
 476 
 477 void
 478 AwtComponent::CreateHWnd(JNIEnv *env, LPCWSTR title,
 479                          DWORD windowStyle,
 480                          DWORD windowExStyle,
 481                          int x, int y, int w, int h,
 482                          HWND hWndParent, HMENU hMenu,
 483                          COLORREF colorForeground,
 484                          COLORREF colorBackground,
 485                          jobject peer)
 486 {
 487     if (env->EnsureLocalCapacity(2) < 0) {
 488         return;
 489     }
 490 
 491     /*
 492      * The window class of multifont label must be "BUTTON" because
 493      * "STATIC" class can't get WM_DRAWITEM message, and m_peerObject
 494      * member is referred in the GetClassName method of AwtLabel class.
 495      * So m_peerObject member must be set here.
 496      */
 497     if (m_peerObject == NULL) {
 498         m_peerObject = env->NewGlobalRef(peer);
 499     } else {
 500         assert(env->IsSameObject(m_peerObject, peer));
 501     }
 502 
 503     RegisterClass();
 504 
 505     jobject target = env->GetObjectField(peer, AwtObject::targetID);
 506     jboolean visible = env->GetBooleanField(target, AwtComponent::visibleID);
 507     m_visible = visible;
 508 
 509     if (visible) {
 510         windowStyle |= WS_VISIBLE;
 511     } else {
 512         windowStyle &= ~WS_VISIBLE;
 513     }
 514 
 515     InitPeerGraphicsConfig(env, peer);
 516 
 517     SetLastError(0);
 518     HWND hwnd = ::CreateWindowEx(windowExStyle,
 519                                  GetClassName(),
 520                                  title,
 521                                  windowStyle,
 522                                  x, y, w, h,
 523                                  hWndParent,
 524                                  hMenu,
 525                                  AwtToolkit::GetInstance().GetModuleHandle(),
 526                                  NULL);
 527 
 528     // fix for 5088782
 529     // check if CreateWindowsEx() returns not null value and if it does -
 530     //   create an InternalError or OutOfMemoryError based on GetLastError().
 531     //   This error is set to createError field of WObjectPeer and then
 532     //   checked and thrown in WComponentPeer constructor. We can't throw an
 533     //   error here because this code is invoked on Toolkit thread
 534     if (hwnd == NULL)
 535     {
 536         DWORD dw = ::GetLastError();
 537         jobject createError = NULL;
 538         if (dw == ERROR_OUTOFMEMORY)
 539         {
 540             jstring errorMsg = JNU_NewStringPlatform(env, L"too many window handles");
 541             if (errorMsg == NULL || env->ExceptionCheck()) {
 542                 env->ExceptionClear();
 543                 createError = JNU_NewObjectByName(env, "java/lang/OutOfMemoryError", "()V");
 544             } else {
 545                 createError = JNU_NewObjectByName(env, "java/lang/OutOfMemoryError",
 546                                                       "(Ljava/lang/String;)V",
 547                                                       errorMsg);
 548                 env->DeleteLocalRef(errorMsg);
 549             }
 550         }
 551         else
 552         {
 553             TCHAR *buf;
 554             FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 555                 NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 556                 (LPTSTR)&buf, 0, NULL);
 557             jstring s = JNU_NewStringPlatform(env, buf);
 558             if (s == NULL || env->ExceptionCheck()) {
 559                 env->ExceptionClear();
 560                 createError = JNU_NewObjectByName(env, "java/lang/InternalError", "()V");
 561             } else {
 562                 createError = JNU_NewObjectByName(env, "java/lang/InternalError",
 563                                                                   "(Ljava/lang/String;)V", s);
 564                 env->DeleteLocalRef(s);
 565             }
 566             LocalFree(buf);
 567         }
 568         if (createError != NULL) {
 569             env->SetObjectField(peer, AwtObject::createErrorID, createError);
 570             env->DeleteLocalRef(createError);
 571         }
 572         env->DeleteLocalRef(target);
 573         return;
 574     }
 575 
 576     m_hwnd = hwnd;
 577 
 578     ::ImmAssociateContext(m_hwnd, NULL);
 579 
 580     SetDrawState((jint)JAWT_LOCK_SURFACE_CHANGED |
 581         (jint)JAWT_LOCK_BOUNDS_CHANGED |
 582         (jint)JAWT_LOCK_CLIP_CHANGED);
 583 
 584     LinkObjects(env, peer);
 585 
 586     /* Subclass the window now so that we can snoop on its messages */
 587     SubclassHWND();
 588 
 589     /*
 590       * Fix for 4046446.
 591       */
 592     SetWindowPos(GetHWnd(), 0, x, y, w, h, SWP_NOZORDER | SWP_NOCOPYBITS | SWP_NOACTIVATE);
 593 
 594     /* Set default colors. */
 595     m_colorForeground = colorForeground;
 596     m_colorBackground = colorBackground;
 597 
 598     /*
 599      * Only set background color if the color is actually set on the
 600      * target -- this avoids inheriting a parent's color unnecessarily,
 601      * and has to be done here because there isn't an API to get the
 602      * real background color from outside the AWT package.
 603      */
 604     jobject bkgrd = env->GetObjectField(target, AwtComponent::backgroundID) ;
 605     if (bkgrd != NULL) {
 606         JNU_CallMethodByName(env, NULL, peer, "setBackground",
 607                              "(Ljava/awt/Color;)V", bkgrd);
 608         DASSERT(!safe_ExceptionOccurred(env));
 609     }
 610     env->DeleteLocalRef(target);
 611     env->DeleteLocalRef(bkgrd);
 612 }
 613 
 614 /*
 615  * Destroy this window's HWND
 616  */
 617 void AwtComponent::DestroyHWnd() {
 618     if (m_hwnd != NULL) {
 619         AwtToolkit::DestroyComponentHWND(m_hwnd);
 620         //AwtToolkit::DestroyComponent(this);
 621         m_hwnd = NULL;
 622     }
 623 }
 624 
 625 /*
 626  * Returns hwnd for target on non Toolkit thread
 627  */
 628 HWND
 629 AwtComponent::GetHWnd(JNIEnv* env, jobject target) {
 630     if (JNU_IsNull(env, target)) {
 631         return 0;
 632     }
 633     jobject peer = env->GetObjectField(target, AwtComponent::peerID);
 634     if (JNU_IsNull(env, peer)) {
 635         return 0;
 636     }
 637     HWND hwnd = reinterpret_cast<HWND>(static_cast<LONG_PTR> (
 638         env->GetLongField(peer, AwtComponent::hwndID)));
 639     env->DeleteLocalRef(peer);
 640     return hwnd;
 641 }
 642 //
 643 // Propagate the background color to synchronize Java field and peer's field.
 644 // This is needed to fix 4148334
 645 //
 646 void AwtComponent::UpdateBackground(JNIEnv *env, jobject target)
 647 {
 648     if (env->EnsureLocalCapacity(1) < 0) {
 649         return;
 650     }
 651 
 652     jobject bkgrnd = env->GetObjectField(target, AwtComponent::backgroundID);
 653 
 654     if (bkgrnd == NULL) {
 655         bkgrnd = JNU_NewObjectByName(env, "java/awt/Color", "(III)V",
 656                                      GetRValue(m_colorBackground),
 657                                      GetGValue(m_colorBackground),
 658                                      GetBValue(m_colorBackground));
 659         if (bkgrnd != NULL) {
 660             env->SetObjectField(target, AwtComponent::backgroundID, bkgrnd);
 661         }
 662     }
 663     env->DeleteLocalRef(bkgrnd);
 664 }
 665 
 666 /*
 667  * Install our window proc as the proc for our HWND, and save off the
 668  * previous proc as the default
 669  */
 670 void AwtComponent::SubclassHWND()
 671 {
 672     if (m_bSubclassed) {
 673         return;
 674     }
 675     const WNDPROC wndproc = WndProc; // let compiler type check WndProc
 676     m_DefWindowProc = ComCtl32Util::GetInstance().SubclassHWND(GetHWnd(), wndproc);
 677     m_bSubclassed = TRUE;
 678 }
 679 
 680 /*
 681  * Reinstall the original window proc as the proc for our HWND
 682  */
 683 void AwtComponent::UnsubclassHWND()
 684 {
 685     if (!m_bSubclassed) {
 686         return;
 687     }
 688     ComCtl32Util::GetInstance().UnsubclassHWND(GetHWnd(), WndProc, m_DefWindowProc);
 689     m_bSubclassed = FALSE;
 690 }
 691 
 692 /////////////////////////////////////
 693 // (static method)
 694 // Determines the top-level ancestor for a given window. If the given
 695 // window is a top-level window, return itself.
 696 //
 697 // 'Top-level' includes dialogs as well.
 698 //
 699 HWND AwtComponent::GetTopLevelParentForWindow(HWND hwndDescendant) {
 700     if (hwndDescendant == NULL) {
 701         return NULL;
 702     }
 703 
 704     DASSERT(IsWindow(hwndDescendant));
 705     HWND hwnd = hwndDescendant;
 706     for(;;) {
 707         DWORD style = ::GetWindowLong(hwnd, GWL_STYLE);
 708         // a) found a non-child window so terminate
 709         // b) found real toplevel window (e.g. EmbeddedFrame
 710         //    that is child though)
 711         if ( (style & WS_CHILD) == 0 ||
 712              AwtComponent::IsTopLevelHWnd(hwnd) )
 713         {
 714             break;
 715         }
 716         hwnd = ::GetParent(hwnd);
 717     }
 718 
 719     return hwnd;
 720 }
 721 ////////////////////
 722 
 723 jobject AwtComponent::FindHeavyweightUnderCursor(BOOL useCache) {
 724     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 725     if (env->EnsureLocalCapacity(1) < 0) {
 726         return NULL;
 727     }
 728 
 729     HWND hit = NULL;
 730     POINT p = { 0, 0 };
 731     AwtComponent *comp = NULL;
 732 
 733     if (useCache) {
 734         if (sm_cursorOn == NULL) {
 735             return NULL;
 736         }
 737 
 738 
 739         DASSERT(::IsWindow(sm_cursorOn));
 740         VERIFY(::GetCursorPos(&p));
 741         /*
 742          * Fix for BugTraq ID 4304024.
 743          * Allow a non-default cursor only for the client area.
 744          */
 745         comp = AwtComponent::GetComponent(sm_cursorOn);
 746         if (comp != NULL &&
 747             ::SendMessage(sm_cursorOn, WM_NCHITTEST, 0,
 748                           MAKELPARAM(p.x, p.y)) == HTCLIENT) {
 749             goto found;
 750         }
 751     }
 752 
 753     ::GetCursorPos(&p);
 754     hit = ::WindowFromPoint(p);
 755     while (hit != NULL) {
 756         comp = AwtComponent::GetComponent(hit);
 757 
 758         if (comp != NULL) {
 759             INT nHittest = (INT)::SendMessage(hit, WM_NCHITTEST,
 760                                           0, MAKELPARAM(p.x, p.y));
 761             /*
 762              * Fix for BugTraq ID 4304024.
 763              * Allow a non-default cursor only for the client area.
 764              */
 765             if (nHittest != HTCLIENT) {
 766                 /*
 767                  * When over the non-client area, send WM_SETCURSOR
 768                  * to revert the cursor to an arrow.
 769                  */
 770                 ::SendMessage(hit, WM_SETCURSOR, (WPARAM)hit,
 771                               MAKELPARAM(nHittest, WM_MOUSEMOVE));
 772                 return NULL;
 773             } else {
 774               sm_cursorOn = hit;
 775               goto found;
 776             }
 777         }
 778 
 779         if ((::GetWindowLong(hit, GWL_STYLE) & WS_CHILD) == 0) {
 780             return NULL;
 781         }
 782         hit = ::GetParent(hit);
 783     }
 784 
 785     return NULL;
 786 
 787 found:
 788     jobject localRef = comp->GetTarget(env);
 789     jobject globalRef = env->NewGlobalRef(localRef);
 790     env->DeleteLocalRef(localRef);
 791     return globalRef;
 792 }
 793 
 794 void AwtComponent::SetColor(COLORREF c)
 795 {
 796     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
 797     int grayscale = AwtWin32GraphicsDevice::GetGrayness(screen);
 798     if (grayscale != GS_NOTGRAY) {
 799         int g;
 800 
 801         g = (int) (.299 * (c & 0xFF) + .587 * ((c >> 8) & 0xFF) +
 802             .114 * ((c >> 16) & 0xFF) + 0.5);
 803         // c = g | (g << 8) | (g << 16);
 804         c = PALETTERGB(g, g, g);
 805     }
 806 
 807     if (m_colorForeground == c) {
 808         return;
 809     }
 810 
 811     m_colorForeground = c;
 812     if (m_penForeground != NULL) {
 813         m_penForeground->Release();
 814         m_penForeground = NULL;
 815     }
 816     VERIFY(::InvalidateRect(GetHWnd(), NULL, FALSE));
 817 }
 818 
 819 void AwtComponent::SetBackgroundColor(COLORREF c)
 820 {
 821     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
 822     int grayscale = AwtWin32GraphicsDevice::GetGrayness(screen);
 823     if (grayscale != GS_NOTGRAY) {
 824         int g;
 825 
 826         g = (int) (.299 * (c & 0xFF) + .587 * ((c >> 8) & 0xFF) +
 827             .114 * ((c >> 16) & 0xFF) + 0.5);
 828         // c = g | (g << 8) | (g << 16);
 829         c = PALETTERGB(g, g, g);
 830     }
 831 
 832     if (m_colorBackground == c) {
 833         return;
 834     }
 835     m_colorBackground = c;
 836     m_backgroundColorSet = TRUE;
 837     if (m_brushBackground != NULL) {
 838         m_brushBackground->Release();
 839         m_brushBackground = NULL;
 840     }
 841     VERIFY(::InvalidateRect(GetHWnd(), NULL, TRUE));
 842 }
 843 
 844 HPEN AwtComponent::GetForegroundPen()
 845 {
 846     if (m_penForeground == NULL) {
 847         m_penForeground = AwtPen::Get(m_colorForeground);
 848     }
 849     return (HPEN)m_penForeground->GetHandle();
 850 }
 851 
 852 COLORREF AwtComponent::GetBackgroundColor()
 853 {
 854     if (m_backgroundColorSet == FALSE) {
 855         AwtComponent* c = this;
 856         while ((c = c->GetParent()) != NULL) {
 857             if (c->IsBackgroundColorSet()) {
 858                 return c->GetBackgroundColor();
 859             }
 860         }
 861     }
 862     return m_colorBackground;
 863 }
 864 
 865 HBRUSH AwtComponent::GetBackgroundBrush()
 866 {
 867     if (m_backgroundColorSet == FALSE) {
 868         if (m_brushBackground != NULL) {
 869             m_brushBackground->Release();
 870             m_brushBackground = NULL;
 871         }
 872           AwtComponent* c = this;
 873           while ((c = c->GetParent()) != NULL) {
 874               if (c->IsBackgroundColorSet()) {
 875                   m_brushBackground =
 876                       AwtBrush::Get(c->GetBackgroundColor());
 877                   break;
 878               }
 879           }
 880     }
 881     if (m_brushBackground == NULL) {
 882         m_brushBackground = AwtBrush::Get(m_colorBackground);
 883     }
 884     return (HBRUSH)m_brushBackground->GetHandle();
 885 }
 886 
 887 void AwtComponent::SetFont(AwtFont* font)
 888 {
 889     DASSERT(font != NULL);
 890     if (font->GetAscent() < 0) {
 891         AwtFont::SetupAscent(font);
 892     }
 893     SendMessage(WM_SETFONT, (WPARAM)font->GetHFont(), MAKELPARAM(FALSE, 0));
 894     VERIFY(::InvalidateRect(GetHWnd(), NULL, TRUE));
 895 }
 896 
 897 AwtComponent* AwtComponent::GetParent()
 898 {
 899     HWND hwnd = ::GetParent(GetHWnd());
 900     if (hwnd == NULL) {
 901         return NULL;
 902     }
 903     return GetComponent(hwnd);
 904 }
 905 
 906 AwtWindow* AwtComponent::GetContainer()
 907 {
 908     AwtComponent* comp = this;
 909     while (comp != NULL) {
 910         if (comp->IsContainer()) {
 911             return (AwtWindow*)comp;
 912         }
 913         comp = comp->GetParent();
 914     }
 915     return NULL;
 916 }
 917 
 918 void AwtComponent::Show()
 919 {
 920     m_visible = true;
 921     ::ShowWindow(GetHWnd(), SW_SHOWNA);
 922 }
 923 
 924 void AwtComponent::Hide()
 925 {
 926     m_visible = false;
 927     ::ShowWindow(GetHWnd(), SW_HIDE);
 928 }
 929 
 930 BOOL
 931 AwtComponent::SetWindowPos(HWND wnd, HWND after,
 932                            int x, int y, int w, int h, UINT flags)
 933 {
 934     // Conditions we shouldn't handle:
 935     // z-order changes, correct window dimensions
 936     if (after != NULL || (w < 32767 && h < 32767)
 937         || ((::GetWindowLong(wnd, GWL_STYLE) & WS_CHILD) == 0))
 938     {
 939         return ::SetWindowPos(wnd, after, x, y, w, h, flags);
 940     }
 941     WINDOWPLACEMENT wp;
 942     ::ZeroMemory(&wp, sizeof(wp));
 943 
 944     wp.length = sizeof(wp);
 945     ::GetWindowPlacement(wnd, &wp);
 946     wp.rcNormalPosition.left = x;
 947     wp.rcNormalPosition.top = y;
 948     wp.rcNormalPosition.right = x + w;
 949     wp.rcNormalPosition.bottom = y + h;
 950     if ( flags & SWP_NOACTIVATE ) {
 951         wp.showCmd = SW_SHOWNOACTIVATE;
 952     }
 953     ::SetWindowPlacement(wnd, &wp);
 954     return 1;
 955 }
 956 
 957 
 958 void AwtComponent::Reshape(int x, int y, int w, int h)
 959 {
 960 #if defined(DEBUG)
 961     RECT        rc;
 962     ::GetWindowRect(GetHWnd(), &rc);
 963     ::MapWindowPoints(HWND_DESKTOP, ::GetParent(GetHWnd()), (LPPOINT)&rc, 2);
 964     DTRACE_PRINTLN4("AwtComponent::Reshape from %d, %d, %d, %d", rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top);
 965 #endif






 966     AwtWindow* container = GetContainer();
 967     AwtComponent* parent = GetParent();
 968     if (container != NULL && container == parent) {
 969         container->SubtractInsetPoint(x, y);
 970     }
 971     DTRACE_PRINTLN4("AwtComponent::Reshape to %d, %d, %d, %d", x, y, w, h);
 972     UINT flags = SWP_NOACTIVATE | SWP_NOZORDER;
 973 
 974     RECT        r;
 975 
 976     ::GetWindowRect(GetHWnd(), &r);
 977     // if the component size is changing , don't copy window bits
 978     if (r.right - r.left != w || r.bottom - r.top != h) {
 979         flags |= SWP_NOCOPYBITS;
 980     }
 981 
 982     if (parent && _tcscmp(parent->GetClassName(), TEXT("SunAwtScrollPane")) == 0) {
 983         if (x > 0) {
 984             x = 0;
 985         }
 986         if (y > 0) {
 987             y = 0;
 988         }
 989     }
 990     if (m_hdwp != NULL) {
 991         m_hdwp = ::DeferWindowPos(m_hdwp, GetHWnd(), 0, x, y, w, h, flags);
 992         DASSERT(m_hdwp != NULL);
 993     } else {
 994         /*
 995          * Fox for 4046446
 996          * If window has dimensions above the short int limit, ::SetWindowPos doesn't work.
 997          * We should use SetWindowPlacement instead.
 998          */
 999         SetWindowPos(GetHWnd(), 0, x, y, w, h, flags);
1000     }
1001 }
1002 
1003 void AwtComponent::SetScrollValues(UINT bar, int min, int value, int max)
1004 {
1005     int minTmp, maxTmp;
1006 
1007     ::GetScrollRange(GetHWnd(), bar, &minTmp, &maxTmp);
1008     if (min == INT_MAX) {
1009         min = minTmp;
1010     }
1011     if (value == INT_MAX) {
1012         value = ::GetScrollPos(GetHWnd(), bar);
1013     }
1014     if (max == INT_MAX) {
1015         max = maxTmp;
1016     }
1017     if (min == max) {
1018         max++;
1019     }
1020     ::SetScrollRange(GetHWnd(), bar, min, max, FALSE);
1021     ::SetScrollPos(GetHWnd(), bar, value, TRUE);
1022 }
1023 
1024 /*
1025  * Save Global Reference of sun.awt.windows.WInputMethod object
1026  */
1027 void AwtComponent::SetInputMethod(jobject im, BOOL useNativeCompWindow)
1028 {
1029     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
1030 
1031     if (m_InputMethod!=NULL)
1032         env->DeleteGlobalRef(m_InputMethod);
1033 
1034     if (im!=NULL){
1035         m_InputMethod = env->NewGlobalRef(im);
1036         m_useNativeCompWindow = useNativeCompWindow;
1037     } else {
1038         m_InputMethod = NULL;
1039         m_useNativeCompWindow = TRUE;
1040     }
1041 
1042 }
1043 
1044 /*
1045  * Opportunity to process and/or eat a message before it is dispatched
1046  */
1047 MsgRouting AwtComponent::PreProcessMsg(MSG& msg)
1048 {
1049     return mrPassAlong;
1050 }
1051 
1052 static UINT lastMessage = WM_NULL;
1053 
1054 #ifndef SPY_MESSAGES
1055 #define SpyWinMessage(hwin,msg,str)
1056 #else
1057 
1058 #define FMT_MSG(x,y) case x: _stprintf(szBuf, \
1059     "0x%8.8x(%s):%s\n", hwnd, szComment, y); break;
1060 #define WIN_MSG(x) FMT_MSG(x,#x)
1061 
1062 void SpyWinMessage(HWND hwnd, UINT message, LPCTSTR szComment) {
1063 
1064     TCHAR szBuf[256];
1065 
1066     switch (message) {
1067         WIN_MSG(WM_NULL)
1068         WIN_MSG(WM_CREATE)
1069         WIN_MSG(WM_DESTROY)
1070         WIN_MSG(WM_MOVE)
1071         WIN_MSG(WM_SIZE)
1072         WIN_MSG(WM_ACTIVATE)
1073         WIN_MSG(WM_SETFOCUS)
1074         WIN_MSG(WM_KILLFOCUS)
1075         WIN_MSG(WM_ENABLE)
1076         WIN_MSG(WM_SETREDRAW)
1077         WIN_MSG(WM_SETTEXT)
1078         WIN_MSG(WM_GETTEXT)
1079         WIN_MSG(WM_GETTEXTLENGTH)
1080         WIN_MSG(WM_PAINT)
1081         WIN_MSG(WM_CLOSE)
1082         WIN_MSG(WM_QUERYENDSESSION)
1083         WIN_MSG(WM_QUIT)
1084         WIN_MSG(WM_QUERYOPEN)
1085         WIN_MSG(WM_ERASEBKGND)
1086         WIN_MSG(WM_SYSCOLORCHANGE)
1087         WIN_MSG(WM_ENDSESSION)
1088         WIN_MSG(WM_SHOWWINDOW)
1089         FMT_MSG(WM_WININICHANGE,"WM_WININICHANGE/WM_SETTINGCHANGE")
1090         WIN_MSG(WM_DEVMODECHANGE)
1091         WIN_MSG(WM_ACTIVATEAPP)
1092         WIN_MSG(WM_FONTCHANGE)
1093         WIN_MSG(WM_TIMECHANGE)
1094         WIN_MSG(WM_CANCELMODE)
1095         WIN_MSG(WM_SETCURSOR)
1096         WIN_MSG(WM_MOUSEACTIVATE)
1097         WIN_MSG(WM_CHILDACTIVATE)
1098         WIN_MSG(WM_QUEUESYNC)
1099         WIN_MSG(WM_GETMINMAXINFO)
1100         WIN_MSG(WM_PAINTICON)
1101         WIN_MSG(WM_ICONERASEBKGND)
1102         WIN_MSG(WM_NEXTDLGCTL)
1103         WIN_MSG(WM_SPOOLERSTATUS)
1104         WIN_MSG(WM_DRAWITEM)
1105         WIN_MSG(WM_MEASUREITEM)
1106         WIN_MSG(WM_DELETEITEM)
1107         WIN_MSG(WM_VKEYTOITEM)
1108         WIN_MSG(WM_CHARTOITEM)
1109         WIN_MSG(WM_SETFONT)
1110         WIN_MSG(WM_GETFONT)
1111         WIN_MSG(WM_SETHOTKEY)
1112         WIN_MSG(WM_GETHOTKEY)
1113         WIN_MSG(WM_QUERYDRAGICON)
1114         WIN_MSG(WM_COMPAREITEM)
1115         FMT_MSG(0x003D, "WM_GETOBJECT")
1116         WIN_MSG(WM_COMPACTING)
1117         WIN_MSG(WM_COMMNOTIFY)
1118         WIN_MSG(WM_WINDOWPOSCHANGING)
1119         WIN_MSG(WM_WINDOWPOSCHANGED)
1120         WIN_MSG(WM_POWER)
1121         WIN_MSG(WM_COPYDATA)
1122         WIN_MSG(WM_CANCELJOURNAL)
1123         WIN_MSG(WM_NOTIFY)
1124         WIN_MSG(WM_INPUTLANGCHANGEREQUEST)
1125         WIN_MSG(WM_INPUTLANGCHANGE)
1126         WIN_MSG(WM_TCARD)
1127         WIN_MSG(WM_HELP)
1128         WIN_MSG(WM_USERCHANGED)
1129         WIN_MSG(WM_NOTIFYFORMAT)
1130         WIN_MSG(WM_CONTEXTMENU)
1131         WIN_MSG(WM_STYLECHANGING)
1132         WIN_MSG(WM_STYLECHANGED)
1133         WIN_MSG(WM_DISPLAYCHANGE)
1134         WIN_MSG(WM_GETICON)
1135         WIN_MSG(WM_SETICON)
1136         WIN_MSG(WM_NCCREATE)
1137         WIN_MSG(WM_NCDESTROY)
1138         WIN_MSG(WM_NCCALCSIZE)
1139         WIN_MSG(WM_NCHITTEST)
1140         WIN_MSG(WM_NCPAINT)
1141         WIN_MSG(WM_NCACTIVATE)
1142         WIN_MSG(WM_GETDLGCODE)
1143         WIN_MSG(WM_SYNCPAINT)
1144         WIN_MSG(WM_NCMOUSEMOVE)
1145         WIN_MSG(WM_NCLBUTTONDOWN)
1146         WIN_MSG(WM_NCLBUTTONUP)
1147         WIN_MSG(WM_NCLBUTTONDBLCLK)
1148         WIN_MSG(WM_NCRBUTTONDOWN)
1149         WIN_MSG(WM_NCRBUTTONUP)
1150         WIN_MSG(WM_NCRBUTTONDBLCLK)
1151         WIN_MSG(WM_NCMBUTTONDOWN)
1152         WIN_MSG(WM_NCMBUTTONUP)
1153         WIN_MSG(WM_NCMBUTTONDBLCLK)
1154         WIN_MSG(WM_KEYDOWN)
1155         WIN_MSG(WM_KEYUP)
1156         WIN_MSG(WM_CHAR)
1157         WIN_MSG(WM_DEADCHAR)
1158         WIN_MSG(WM_SYSKEYDOWN)
1159         WIN_MSG(WM_SYSKEYUP)
1160         WIN_MSG(WM_SYSCHAR)
1161         WIN_MSG(WM_SYSDEADCHAR)
1162         WIN_MSG(WM_IME_STARTCOMPOSITION)
1163         WIN_MSG(WM_IME_ENDCOMPOSITION)
1164         WIN_MSG(WM_IME_COMPOSITION)
1165         WIN_MSG(WM_INITDIALOG)
1166         WIN_MSG(WM_COMMAND)
1167         WIN_MSG(WM_SYSCOMMAND)
1168         WIN_MSG(WM_TIMER)
1169         WIN_MSG(WM_HSCROLL)
1170         WIN_MSG(WM_VSCROLL)
1171         WIN_MSG(WM_INITMENU)
1172         WIN_MSG(WM_INITMENUPOPUP)
1173         WIN_MSG(WM_MENUSELECT)
1174         WIN_MSG(WM_MENUCHAR)
1175         WIN_MSG(WM_ENTERIDLE)
1176         FMT_MSG(0x0122, "WM_MENURBUTTONUP")
1177         FMT_MSG(0x0123, "WM_MENUDRAG")
1178         FMT_MSG(0x0124, "WM_MENUGETOBJECT")
1179         FMT_MSG(0x0125, "WM_UNINITMENUPOPUP")
1180         FMT_MSG(0x0126, "WM_MENUCOMMAND")
1181         WIN_MSG(WM_CTLCOLORMSGBOX)
1182         WIN_MSG(WM_CTLCOLOREDIT)
1183         WIN_MSG(WM_CTLCOLORLISTBOX)
1184         WIN_MSG(WM_CTLCOLORBTN)
1185         WIN_MSG(WM_CTLCOLORDLG)
1186         WIN_MSG(WM_CTLCOLORSCROLLBAR)
1187         WIN_MSG(WM_CTLCOLORSTATIC)
1188         WIN_MSG(WM_MOUSEMOVE)
1189         WIN_MSG(WM_LBUTTONDOWN)
1190         WIN_MSG(WM_LBUTTONUP)
1191         WIN_MSG(WM_LBUTTONDBLCLK)
1192         WIN_MSG(WM_RBUTTONDOWN)
1193         WIN_MSG(WM_RBUTTONUP)
1194         WIN_MSG(WM_RBUTTONDBLCLK)
1195         WIN_MSG(WM_MBUTTONDOWN)
1196         WIN_MSG(WM_MBUTTONUP)
1197         WIN_MSG(WM_MBUTTONDBLCLK)
1198         WIN_MSG(WM_XBUTTONDBLCLK)
1199         WIN_MSG(WM_XBUTTONDOWN)
1200         WIN_MSG(WM_XBUTTONUP)
1201         WIN_MSG(WM_MOUSEWHEEL)
1202         WIN_MSG(WM_PARENTNOTIFY)
1203         WIN_MSG(WM_ENTERMENULOOP)
1204         WIN_MSG(WM_EXITMENULOOP)
1205         WIN_MSG(WM_NEXTMENU)
1206         WIN_MSG(WM_SIZING)
1207         WIN_MSG(WM_CAPTURECHANGED)
1208         WIN_MSG(WM_MOVING)
1209         WIN_MSG(WM_POWERBROADCAST)
1210         WIN_MSG(WM_DEVICECHANGE)
1211         WIN_MSG(WM_MDICREATE)
1212         WIN_MSG(WM_MDIDESTROY)
1213         WIN_MSG(WM_MDIACTIVATE)
1214         WIN_MSG(WM_MDIRESTORE)
1215         WIN_MSG(WM_MDINEXT)
1216         WIN_MSG(WM_MDIMAXIMIZE)
1217         WIN_MSG(WM_MDITILE)
1218         WIN_MSG(WM_MDICASCADE)
1219         WIN_MSG(WM_MDIICONARRANGE)
1220         WIN_MSG(WM_MDIGETACTIVE)
1221         WIN_MSG(WM_MDISETMENU)
1222         WIN_MSG(WM_ENTERSIZEMOVE)
1223         WIN_MSG(WM_EXITSIZEMOVE)
1224         WIN_MSG(WM_DROPFILES)
1225         WIN_MSG(WM_MDIREFRESHMENU)
1226         WIN_MSG(WM_IME_SETCONTEXT)
1227         WIN_MSG(WM_IME_NOTIFY)
1228         WIN_MSG(WM_IME_CONTROL)
1229         WIN_MSG(WM_IME_COMPOSITIONFULL)
1230         WIN_MSG(WM_IME_SELECT)
1231         WIN_MSG(WM_IME_CHAR)
1232         FMT_MSG(WM_IME_REQUEST)
1233         WIN_MSG(WM_IME_KEYDOWN)
1234         WIN_MSG(WM_IME_KEYUP)
1235         FMT_MSG(0x02A1, "WM_MOUSEHOVER")
1236         FMT_MSG(0x02A3, "WM_MOUSELEAVE")
1237         WIN_MSG(WM_CUT)
1238         WIN_MSG(WM_COPY)
1239         WIN_MSG(WM_PASTE)
1240         WIN_MSG(WM_CLEAR)
1241         WIN_MSG(WM_UNDO)
1242         WIN_MSG(WM_RENDERFORMAT)
1243         WIN_MSG(WM_RENDERALLFORMATS)
1244         WIN_MSG(WM_DESTROYCLIPBOARD)
1245         WIN_MSG(WM_DRAWCLIPBOARD)
1246         WIN_MSG(WM_PAINTCLIPBOARD)
1247         WIN_MSG(WM_VSCROLLCLIPBOARD)
1248         WIN_MSG(WM_SIZECLIPBOARD)
1249         WIN_MSG(WM_ASKCBFORMATNAME)
1250         WIN_MSG(WM_CHANGECBCHAIN)
1251         WIN_MSG(WM_HSCROLLCLIPBOARD)
1252         WIN_MSG(WM_QUERYNEWPALETTE)
1253         WIN_MSG(WM_PALETTEISCHANGING)
1254         WIN_MSG(WM_PALETTECHANGED)
1255         WIN_MSG(WM_HOTKEY)
1256         WIN_MSG(WM_PRINT)
1257         WIN_MSG(WM_PRINTCLIENT)
1258         WIN_MSG(WM_HANDHELDFIRST)
1259         WIN_MSG(WM_HANDHELDLAST)
1260         WIN_MSG(WM_AFXFIRST)
1261         WIN_MSG(WM_AFXLAST)
1262         WIN_MSG(WM_PENWINFIRST)
1263         WIN_MSG(WM_PENWINLAST)
1264         WIN_MSG(WM_AWT_COMPONENT_CREATE)
1265         WIN_MSG(WM_AWT_DESTROY_WINDOW)
1266         WIN_MSG(WM_AWT_MOUSEENTER)
1267         WIN_MSG(WM_AWT_MOUSEEXIT)
1268         WIN_MSG(WM_AWT_COMPONENT_SHOW)
1269         WIN_MSG(WM_AWT_COMPONENT_HIDE)
1270         WIN_MSG(WM_AWT_COMPONENT_SETFOCUS)
1271         WIN_MSG(WM_AWT_WINDOW_SETACTIVE)
1272         WIN_MSG(WM_AWT_LIST_SETMULTISELECT)
1273         WIN_MSG(WM_AWT_HANDLE_EVENT)
1274         WIN_MSG(WM_AWT_PRINT_COMPONENT)
1275         WIN_MSG(WM_AWT_RESHAPE_COMPONENT)
1276         WIN_MSG(WM_AWT_SETALWAYSONTOP)
1277         WIN_MSG(WM_AWT_BEGIN_VALIDATE)
1278         WIN_MSG(WM_AWT_END_VALIDATE)
1279         WIN_MSG(WM_AWT_FORWARD_CHAR)
1280         WIN_MSG(WM_AWT_FORWARD_BYTE)
1281         WIN_MSG(WM_AWT_SET_SCROLL_INFO)
1282         WIN_MSG(WM_AWT_CREATECONTEXT)
1283         WIN_MSG(WM_AWT_DESTROYCONTEXT)
1284         WIN_MSG(WM_AWT_ASSOCIATECONTEXT)
1285         WIN_MSG(WM_AWT_GET_DEFAULT_IME_HANDLER)
1286         WIN_MSG(WM_AWT_HANDLE_NATIVE_IME_EVENT)
1287         WIN_MSG(WM_AWT_PRE_KEYDOWN)
1288         WIN_MSG(WM_AWT_PRE_KEYUP)
1289         WIN_MSG(WM_AWT_PRE_SYSKEYDOWN)
1290         WIN_MSG(WM_AWT_PRE_SYSKEYUP)
1291         WIN_MSG(WM_AWT_ENDCOMPOSITION,)
1292         WIN_MSG(WM_AWT_DISPOSE,)
1293         WIN_MSG(WM_AWT_DELETEOBJECT,)
1294         WIN_MSG(WM_AWT_SETCONVERSIONSTATUS,)
1295         WIN_MSG(WM_AWT_GETCONVERSIONSTATUS,)
1296         WIN_MSG(WM_AWT_SETOPENSTATUS,)
1297         WIN_MSG(WM_AWT_GETOPENSTATUS)
1298         WIN_MSG(WM_AWT_ACTIVATEKEYBOARDLAYOUT)
1299         WIN_MSG(WM_AWT_OPENCANDIDATEWINDOW)
1300         WIN_MSG(WM_AWT_DLG_SHOWMODAL,)
1301         WIN_MSG(WM_AWT_DLG_ENDMODAL,)
1302         WIN_MSG(WM_AWT_SETCURSOR,)
1303         WIN_MSG(WM_AWT_WAIT_FOR_SINGLE_OBJECT,)
1304         WIN_MSG(WM_AWT_INVOKE_METHOD,)
1305         WIN_MSG(WM_AWT_INVOKE_VOID_METHOD,)
1306         WIN_MSG(WM_AWT_EXECUTE_SYNC,)
1307         WIN_MSG(WM_AWT_CURSOR_SYNC)
1308         WIN_MSG(WM_AWT_GETDC)
1309         WIN_MSG(WM_AWT_RELEASEDC)
1310         WIN_MSG(WM_AWT_RELEASE_ALL_DCS)
1311         WIN_MSG(WM_AWT_SHOWCURSOR)
1312         WIN_MSG(WM_AWT_HIDECURSOR)
1313         WIN_MSG(WM_AWT_CREATE_PRINTED_PIXELS)
1314         WIN_MSG(WM_AWT_OBJECTLISTCLEANUP)
1315         default:
1316             sprintf(szBuf, "0x%8.8x(%s):Unknown message 0x%8.8x\n",
1317                 hwnd, szComment, message);
1318             break;
1319     }
1320     printf(szBuf);
1321 }
1322 
1323 #endif /* SPY_MESSAGES */
1324 
1325 /*
1326  * Dispatch messages for this window class--general component
1327  */
1328 LRESULT AwtComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
1329 {
1330     CounterHelper ch(&m_MessagesProcessing);
1331 
1332     JNILocalFrame lframe(AwtToolkit::GetEnv(), 10);
1333     SpyWinMessage(GetHWnd(), message,
1334         (message == WM_AWT_RELEASE_ALL_DCS) ? TEXT("Disposed Component") : GetClassName());
1335 
1336     LRESULT retValue = 0;
1337     MsgRouting mr = mrDoDefault;
1338     AwtToolkit::GetInstance().eventNumber++;
1339 
1340     static BOOL ignoreNextLBTNUP = FALSE; //Ignore next LBUTTONUP msg?
1341 
1342     lastMessage = message;
1343 
1344     if (message == WmAwtIsComponent) {
1345     // special message to identify AWT HWND's without using
1346     // resource hogging ::SetProp
1347         return (LRESULT)TRUE;
1348     }
1349 
1350     DWORD curPos = 0;
1351 
1352     UINT switchMessage = message;
1353     switch (switchMessage) {
1354       case WM_AWT_GETDC:
1355       {
1356             HDC hDC;
1357             // First, release the DCs scheduled for deletion
1358             ReleaseDCList(GetHWnd(), passiveDCList);
1359 
1360             GetDCReturnStruct *returnStruct = new GetDCReturnStruct;
1361             returnStruct->gdiLimitReached = FALSE;
1362             if (AwtGDIObject::IncrementIfAvailable()) {
1363                 hDC = ::GetDCEx(GetHWnd(), NULL,
1364                                 DCX_CACHE | DCX_CLIPCHILDREN |
1365                                 DCX_CLIPSIBLINGS);
1366                 if (hDC != NULL) {
1367                     // Add new DC to list of DC's associated with this Component
1368                     activeDCList.AddDC(hDC, GetHWnd());
1369                 } else {
1370                     // Creation failed; decrement counter in AwtGDIObject
1371                     AwtGDIObject::Decrement();
1372                 }
1373             } else {
1374                 hDC = NULL;
1375                 returnStruct->gdiLimitReached = TRUE;
1376             }
1377             returnStruct->hDC = hDC;
1378             retValue = (LRESULT)returnStruct;
1379             mr = mrConsume;
1380             break;
1381       }
1382       case WM_AWT_RELEASEDC:
1383       {
1384             HDC hDC = (HDC)wParam;
1385             MoveDCToPassiveList(hDC);
1386             ReleaseDCList(GetHWnd(), passiveDCList);
1387             mr = mrConsume;
1388             break;
1389       }
1390       case WM_AWT_RELEASE_ALL_DCS:
1391       {
1392             // Called during Component destruction.  Gets current list of
1393             // DC's associated with Component and releases each DC.
1394             ReleaseDCList(GetHWnd(), activeDCList);
1395             ReleaseDCList(GetHWnd(), passiveDCList);
1396             mr = mrConsume;
1397             break;
1398       }
1399       case WM_AWT_SHOWCURSOR:
1400           ::ShowCursor(TRUE);
1401           break;
1402       case WM_AWT_HIDECURSOR:
1403           ::ShowCursor(FALSE);
1404           break;
1405       case WM_CREATE: mr = WmCreate(); break;
1406       case WM_CLOSE:      mr = WmClose(); break;
1407       case WM_DESTROY:    mr = WmDestroy(); break;
1408       case WM_NCDESTROY:  mr = WmNcDestroy(); break;
1409 
1410       case WM_ERASEBKGND:
1411           mr = WmEraseBkgnd((HDC)wParam, *(BOOL*)&retValue); break;
1412       case WM_PAINT:
1413           CheckFontSmoothingSettings(GetHWnd());
1414           /* Set draw state */
1415           SetDrawState(GetDrawState() | JAWT_LOCK_CLIP_CHANGED);
1416           mr = WmPaint((HDC)wParam);
1417           break;
1418 
1419       case WM_GETMINMAXINFO:
1420           mr = WmGetMinMaxInfo((LPMINMAXINFO)lParam);
1421           break;
1422 
1423       case WM_WINDOWPOSCHANGING:
1424       {
1425           // We process this message so that we can synchronize access to
1426           // a moving window.  The Scale/Blt functions in Win32BlitLoops
1427           // take the same windowMoveLock to ensure that a window is not
1428           // moving while we are trying to copy pixels into it.
1429           WINDOWPOS *lpPosInfo = (WINDOWPOS *)lParam;
1430           if ((lpPosInfo->flags & (SWP_NOMOVE | SWP_NOSIZE)) !=
1431               (SWP_NOMOVE | SWP_NOSIZE))
1432           {
1433               // Move or Size command.
1434               // Windows tends to send erroneous events that the window
1435               // is about to move when the coordinates are exactly the
1436               // same as the last time.  This can cause problems with
1437               // our windowMoveLock CriticalSection because we enter it
1438               // here and never get to WM_WINDOWPOSCHANGED to release it.
1439               // So make sure this is a real move/size event before bothering
1440               // to grab the critical section.
1441               BOOL takeLock = FALSE;
1442               if (!(lpPosInfo->flags & SWP_NOMOVE) &&
1443                   ((windowMoveLockPosX != lpPosInfo->x) ||
1444                    (windowMoveLockPosY != lpPosInfo->y)))
1445               {
1446                   // Real move event
1447                   takeLock = TRUE;
1448                   windowMoveLockPosX = lpPosInfo->x;
1449                   windowMoveLockPosY = lpPosInfo->y;
1450               }
1451               if (!(lpPosInfo->flags & SWP_NOSIZE) &&
1452                   ((windowMoveLockPosCX != lpPosInfo->cx) ||
1453                    (windowMoveLockPosCY != lpPosInfo->cy)))
1454               {
1455                   // Real size event
1456                   takeLock = TRUE;
1457                   windowMoveLockPosCX = lpPosInfo->cx;
1458                   windowMoveLockPosCY = lpPosInfo->cy;
1459               }
1460               if (takeLock) {
1461                   if (!windowMoveLockHeld) {
1462                       windowMoveLock.Enter();
1463                       windowMoveLockHeld = TRUE;
1464                   }
1465               }
1466           }
1467           mr = WmWindowPosChanging(lParam);
1468           break;
1469       }
1470       case WM_WINDOWPOSCHANGED:
1471       {
1472           // Release lock grabbed in the POSCHANGING message
1473           if (windowMoveLockHeld) {
1474               windowMoveLockHeld = FALSE;
1475               windowMoveLock.Leave();
1476           }
1477           mr = WmWindowPosChanged(lParam);
1478           break;
1479       }
1480       case WM_MOVE: {
1481           RECT r;
1482           ::GetWindowRect(GetHWnd(), &r);
1483           mr = WmMove(r.left, r.top);
1484           break;
1485       }
1486       case WM_SIZE:
1487       {
1488           RECT r;
1489           // fix 4128317 : use GetClientRect for full 32-bit int precision and
1490           // to avoid negative client area dimensions overflowing 16-bit params - robi
1491           ::GetClientRect( GetHWnd(), &r );
1492           mr = WmSize(static_cast<UINT>(wParam), r.right - r.left, r.bottom - r.top);
1493           //mr = WmSize(wParam, LOWORD(lParam), HIWORD(lParam));
1494           SetCompositionWindow(r);
1495           break;
1496       }
1497       case WM_SIZING:
1498           mr = WmSizing();
1499           break;
1500       case WM_SHOWWINDOW:
1501           mr = WmShowWindow(static_cast<BOOL>(wParam),
1502                             static_cast<UINT>(lParam)); break;
1503       case WM_SYSCOMMAND:
1504           mr = WmSysCommand(static_cast<UINT>(wParam & 0xFFF0),
1505                             GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
1506           break;
1507       case WM_EXITSIZEMOVE:
1508           mr = WmExitSizeMove();
1509           break;
1510       // Bug #4039858 (Selecting menu item causes bogus mouse click event)
1511       case WM_ENTERMENULOOP:
1512           mr = WmEnterMenuLoop((BOOL)wParam);
1513           sm_bMenuLoop = TRUE;
1514           // we need to release grab if menu is shown
1515           if (AwtWindow::GetGrabbedWindow() != NULL) {
1516               AwtWindow::GetGrabbedWindow()->Ungrab();
1517           }
1518           break;
1519       case WM_EXITMENULOOP:
1520           mr = WmExitMenuLoop((BOOL)wParam);
1521           sm_bMenuLoop = FALSE;
1522           break;
1523 
1524       // We don't expect any focus messages on non-proxy component,
1525       // except those that came from Java.
1526       case WM_SETFOCUS:
1527           if (sm_inSynthesizeFocus) {
1528               mr = WmSetFocus((HWND)wParam);
1529           } else {
1530               mr = mrConsume;
1531           }
1532           break;
1533       case WM_KILLFOCUS:
1534           if (sm_inSynthesizeFocus) {
1535               mr = WmKillFocus((HWND)wParam);
1536           } else {
1537               mr = mrConsume;
1538           }
1539           break;
1540       case WM_ACTIVATE: {
1541           UINT nState = LOWORD(wParam);
1542           BOOL fMinimized = (BOOL)HIWORD(wParam);
1543           mr = mrConsume;
1544 
1545           if (!sm_suppressFocusAndActivation &&
1546               (!fMinimized || (nState == WA_INACTIVE)))
1547           {
1548               mr = WmActivate(nState, fMinimized, (HWND)lParam);
1549 
1550               // When the window is deactivated, send WM_IME_ENDCOMPOSITION
1551               // message to deactivate the composition window so that
1552               // it won't receive keyboard input focus.
1553               HIMC hIMC;
1554               HWND hwnd = ImmGetHWnd();
1555               if ((hIMC = ImmGetContext(hwnd)) != NULL) {
1556                   ImmReleaseContext(hwnd, hIMC);
1557                   DefWindowProc(WM_IME_ENDCOMPOSITION, 0, 0);
1558               }
1559           }
1560           break;
1561       }
1562       case WM_MOUSEACTIVATE: {
1563           AwtWindow *window = GetContainer();
1564           if (window && window->IsFocusableWindow()) {
1565               // AWT/Swing will later request focus to a proper component
1566               // on handling the Java mouse event. Anyway, we have to
1567               // activate the window here as it works both for AWT & Swing.
1568               // Do it in our own fassion,
1569               window->AwtSetActiveWindow(TRUE, LOWORD(lParam)/*hittest*/);
1570           }
1571           mr = mrConsume;
1572           retValue = MA_NOACTIVATE;
1573           break;
1574       }
1575       case WM_CTLCOLORMSGBOX:
1576       case WM_CTLCOLOREDIT:
1577       case WM_CTLCOLORLISTBOX:
1578       case WM_CTLCOLORBTN:
1579       case WM_CTLCOLORDLG:
1580       case WM_CTLCOLORSCROLLBAR:
1581       case WM_CTLCOLORSTATIC:
1582           mr = WmCtlColor((HDC)wParam, (HWND)lParam,
1583                           message-WM_CTLCOLORMSGBOX+CTLCOLOR_MSGBOX,
1584                           *(HBRUSH*)&retValue);
1585           break;
1586       case WM_HSCROLL:
1587           mr = WmHScroll(LOWORD(wParam), HIWORD(wParam), (HWND)lParam);
1588           break;
1589       case WM_VSCROLL:
1590           mr = WmVScroll(LOWORD(wParam), HIWORD(wParam), (HWND)lParam);
1591           break;
1592       // 4664415: We're seeing a WM_LBUTTONUP when the user releases the
1593       // mouse button after a WM_NCLBUTTONDBLCLK.  We want to ignore this
1594       // WM_LBUTTONUP, so we set a flag in WM_NCLBUTTONDBLCLK and look for the
1595       // flag on a WM_LBUTTONUP.  -bchristi
1596       case WM_NCLBUTTONDBLCLK:
1597           mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON | DBL_CLICK);
1598           if (mr == mrDoDefault) {
1599               ignoreNextLBTNUP = TRUE;
1600           }
1601           break;
1602       case WM_NCLBUTTONDOWN:
1603           mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON);
1604           ignoreNextLBTNUP = FALSE;
1605           break;
1606       case WM_NCLBUTTONUP:
1607           mr = WmNcMouseUp(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), LEFT_BUTTON);
1608           break;
1609       case WM_NCRBUTTONDOWN:
1610            mr = WmNcMouseDown(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), RIGHT_BUTTON);
1611            break;
1612       case WM_LBUTTONUP:
1613           if (ignoreNextLBTNUP) {
1614               ignoreNextLBTNUP = FALSE;
1615               return mrDoDefault;
1616           }
1617           //fall-through
1618       case WM_LBUTTONDOWN:
1619           ignoreNextLBTNUP = FALSE;
1620           //fall-through
1621       case WM_LBUTTONDBLCLK:
1622       case WM_RBUTTONDOWN:
1623       case WM_RBUTTONDBLCLK:
1624       case WM_RBUTTONUP:
1625       case WM_MBUTTONDOWN:
1626       case WM_MBUTTONDBLCLK:
1627       case WM_MBUTTONUP:
1628       case WM_XBUTTONDBLCLK:
1629       case WM_XBUTTONDOWN:
1630       case WM_XBUTTONUP:
1631       case WM_MOUSEMOVE:
1632       case WM_MOUSEWHEEL:
1633       case WM_AWT_MOUSEENTER:
1634       case WM_AWT_MOUSEEXIT:
1635           curPos = ::GetMessagePos();
1636           POINT myPos;
1637           myPos.x = GET_X_LPARAM(curPos);
1638           myPos.y = GET_Y_LPARAM(curPos);
1639           ::ScreenToClient(GetHWnd(), &myPos);
1640           switch(switchMessage) {
1641           case WM_AWT_MOUSEENTER:
1642               mr = WmMouseEnter(static_cast<UINT>(wParam), myPos.x, myPos.y);
1643               break;
1644           case WM_LBUTTONDOWN:
1645           case WM_LBUTTONDBLCLK:
1646               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1647                                LEFT_BUTTON);
1648               break;
1649           case WM_LBUTTONUP:
1650               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1651                              LEFT_BUTTON);
1652               break;
1653           case WM_MOUSEMOVE:
1654               mr = WmMouseMove(static_cast<UINT>(wParam), myPos.x, myPos.y);
1655               break;
1656           case WM_MBUTTONDOWN:
1657           case WM_MBUTTONDBLCLK:
1658               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1659                                MIDDLE_BUTTON);
1660               break;
1661           case WM_XBUTTONDOWN:
1662           case WM_XBUTTONDBLCLK:
1663               if (AwtToolkit::GetInstance().areExtraMouseButtonsEnabled()) {
1664                   if (HIWORD(wParam) == 1) {
1665                       mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1666                                        X1_BUTTON);
1667                   }
1668                   if (HIWORD(wParam) == 2) {
1669                       mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1670                                        X2_BUTTON);
1671                   }
1672               }
1673               break;
1674           case WM_XBUTTONUP:
1675               if (AwtToolkit::GetInstance().areExtraMouseButtonsEnabled()) {
1676                   if (HIWORD(wParam) == 1) {
1677                       mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1678                                      X1_BUTTON);
1679                   }
1680                   if (HIWORD(wParam) == 2) {
1681                       mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1682                                      X2_BUTTON);
1683                   }
1684               }
1685               break;
1686           case WM_RBUTTONDOWN:
1687           case WM_RBUTTONDBLCLK:
1688               mr = WmMouseDown(static_cast<UINT>(wParam), myPos.x, myPos.y,
1689                                RIGHT_BUTTON);
1690               break;
1691           case WM_RBUTTONUP:
1692               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1693                              RIGHT_BUTTON);
1694               break;
1695           case WM_MBUTTONUP:
1696               mr = WmMouseUp(static_cast<UINT>(wParam), myPos.x, myPos.y,
1697                              MIDDLE_BUTTON);
1698               break;
1699           case WM_AWT_MOUSEEXIT:
1700               mr = WmMouseExit(static_cast<UINT>(wParam), myPos.x, myPos.y);
1701               break;
1702           case  WM_MOUSEWHEEL:
1703               mr = WmMouseWheel(GET_KEYSTATE_WPARAM(wParam),
1704                                 GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
1705                                 GET_WHEEL_DELTA_WPARAM(wParam));
1706               break;
1707           }
1708           break;
1709       case WM_SETCURSOR:
1710           mr = mrDoDefault;
1711           if (LOWORD(lParam) == HTCLIENT) {
1712               if (AwtComponent* comp =
1713                                     AwtComponent::GetComponent((HWND)wParam)) {
1714                   AwtCursor::UpdateCursor(comp);
1715                   mr = mrConsume;
1716               }
1717           }
1718           break;
1719 
1720       case WM_KEYDOWN:
1721           mr = WmKeyDown(static_cast<UINT>(wParam),
1722                          LOWORD(lParam), HIWORD(lParam), FALSE);
1723           break;
1724       case WM_KEYUP:
1725           mr = WmKeyUp(static_cast<UINT>(wParam),
1726                        LOWORD(lParam), HIWORD(lParam), FALSE);
1727           break;
1728       case WM_SYSKEYDOWN:
1729           mr = WmKeyDown(static_cast<UINT>(wParam),
1730                          LOWORD(lParam), HIWORD(lParam), TRUE);
1731           break;
1732       case WM_SYSKEYUP:
1733           mr = WmKeyUp(static_cast<UINT>(wParam),
1734                        LOWORD(lParam), HIWORD(lParam), TRUE);
1735           break;
1736       case WM_IME_SETCONTEXT:
1737           // lParam is passed as pointer and it can be modified.
1738           mr = WmImeSetContext(static_cast<BOOL>(wParam), &lParam);
1739           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1740           break;
1741       case WM_IME_NOTIFY:
1742           mr = WmImeNotify(wParam, lParam);
1743           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1744           break;
1745       case WM_IME_STARTCOMPOSITION:
1746           mr = WmImeStartComposition();
1747           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1748           break;
1749       case WM_IME_ENDCOMPOSITION:
1750           mr = WmImeEndComposition();
1751           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1752           break;
1753       case WM_IME_COMPOSITION: {
1754           WORD dbcschar = static_cast<WORD>(wParam);
1755           mr = WmImeComposition(dbcschar, lParam);
1756           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1757           break;
1758       }
1759       case WM_IME_CONTROL:
1760       case WM_IME_COMPOSITIONFULL:
1761       case WM_IME_SELECT:
1762       case WM_IME_KEYUP:
1763       case WM_IME_KEYDOWN:
1764       case WM_IME_REQUEST:
1765           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1766           break;
1767       case WM_CHAR:
1768           mr = WmChar(static_cast<UINT>(wParam),
1769                       LOWORD(lParam), HIWORD(lParam), FALSE);
1770           break;
1771       case WM_SYSCHAR:
1772           mr = WmChar(static_cast<UINT>(wParam),
1773                       LOWORD(lParam), HIWORD(lParam), TRUE);
1774           break;
1775       case WM_IME_CHAR:
1776           mr = WmIMEChar(static_cast<UINT>(wParam),
1777                          LOWORD(lParam), HIWORD(lParam), FALSE);
1778           break;
1779 
1780       case WM_INPUTLANGCHANGEREQUEST: {
1781           DTRACE_PRINTLN4("WM_INPUTLANGCHANGEREQUEST: hwnd = 0x%X (%s);"//
1782                           "0x%08X -> 0x%08X",
1783                           GetHWnd(), GetClassName(),
1784                           (UINT_PTR)GetKeyboardLayout(), (UINT_PTR)lParam);
1785           // 4267428: make sure keyboard layout is turned undead.
1786           static BYTE keyboardState[AwtToolkit::KB_STATE_SIZE];
1787           AwtToolkit::GetKeyboardState(keyboardState);
1788           WORD ignored;
1789           ::ToAsciiEx(VK_SPACE, ::MapVirtualKey(VK_SPACE, 0),
1790                       keyboardState, &ignored, 0, GetKeyboardLayout());
1791 
1792           // Set this flag to block ActivateKeyboardLayout from
1793           // WInputMethod.activate()
1794           g_bUserHasChangedInputLang = TRUE;
1795           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1796           break;
1797       }
1798       case WM_INPUTLANGCHANGE:
1799           DTRACE_PRINTLN3("WM_INPUTLANGCHANGE: hwnd = 0x%X (%s);"//
1800                           "new = 0x%08X",
1801                           GetHWnd(), GetClassName(), (UINT)lParam);
1802           mr = WmInputLangChange(static_cast<UINT>(wParam), reinterpret_cast<HKL>(lParam));
1803           CallProxyDefWindowProc(message, wParam, lParam, retValue, mr);
1804           // should return non-zero if we process this message
1805           retValue = 1;
1806           break;
1807 
1808       case WM_AWT_FORWARD_CHAR:
1809           mr = WmForwardChar(LOWORD(wParam), lParam, HIWORD(wParam));
1810           break;
1811 
1812       case WM_AWT_FORWARD_BYTE:
1813           mr = HandleEvent( (MSG *) lParam, (BOOL) wParam);
1814           break;
1815 
1816       case WM_PASTE:
1817           mr = WmPaste();
1818           break;
1819       case WM_TIMER:
1820           mr = WmTimer(wParam);
1821           break;
1822 
1823       case WM_COMMAND:
1824           mr = WmCommand(LOWORD(wParam), (HWND)lParam, HIWORD(wParam));
1825           break;
1826       case WM_COMPAREITEM:
1827           mr = WmCompareItem(static_cast<UINT>(wParam),
1828                              *(COMPAREITEMSTRUCT*)lParam, retValue);
1829           break;
1830       case WM_DELETEITEM:
1831           mr = WmDeleteItem(static_cast<UINT>(wParam),
1832                             *(DELETEITEMSTRUCT*)lParam);
1833           break;
1834       case WM_DRAWITEM:
1835           mr = WmDrawItem(static_cast<UINT>(wParam),
1836                           *(DRAWITEMSTRUCT*)lParam);
1837           break;
1838       case WM_MEASUREITEM:
1839           mr = WmMeasureItem(static_cast<UINT>(wParam),
1840                              *(MEASUREITEMSTRUCT*)lParam);
1841           break;
1842 
1843       case WM_AWT_HANDLE_EVENT:
1844           mr = HandleEvent( (MSG *) lParam, (BOOL) wParam);
1845           break;
1846 
1847       case WM_PRINT:
1848           mr = WmPrint((HDC)wParam, lParam);
1849           break;
1850       case WM_PRINTCLIENT:
1851           mr = WmPrintClient((HDC)wParam, lParam);
1852           break;
1853 
1854       case WM_NCCALCSIZE:
1855           mr = WmNcCalcSize((BOOL)wParam, (LPNCCALCSIZE_PARAMS)lParam,
1856                             retValue);
1857           break;
1858       case WM_NCPAINT:
1859           mr = WmNcPaint((HRGN)wParam);
1860           break;
1861       case WM_NCHITTEST:
1862           mr = WmNcHitTest(LOWORD(lParam), HIWORD(lParam), retValue);
1863           break;
1864 
1865       case WM_AWT_RESHAPE_COMPONENT: {
1866           RECT* r = (RECT*)lParam;
1867           WPARAM checkEmbedded = wParam;
1868           if (checkEmbedded == CHECK_EMBEDDED && IsEmbeddedFrame()) {
1869               ::OffsetRect(r, -r->left, -r->top);
1870           }
1871           Reshape(r->left, r->top, r->right - r->left, r->bottom - r->top);
1872           delete r;
1873           mr = mrConsume;
1874           break;
1875       }
1876 
1877       case WM_AWT_SETALWAYSONTOP: {
1878         AwtWindow* w = (AwtWindow*)lParam;
1879         BOOL value = (BOOL)wParam;
1880         UINT flags = SWP_NOMOVE | SWP_NOSIZE;
1881         // transient windows shouldn't change the owner window's position in the z-order
1882         if (w->IsRetainingHierarchyZOrder()) {
1883             flags |= SWP_NOOWNERZORDER;
1884         }
1885         ::SetWindowPos(w->GetHWnd(), (value != 0 ? HWND_TOPMOST : HWND_NOTOPMOST),
1886                        0,0,0,0, flags);
1887         break;
1888       }
1889 
1890       case WM_AWT_BEGIN_VALIDATE:
1891           BeginValidate();
1892           mr = mrConsume;
1893           break;
1894       case WM_AWT_END_VALIDATE:
1895           EndValidate();
1896           mr = mrConsume;
1897           break;
1898 
1899       case WM_PALETTEISCHANGING:
1900           mr = WmPaletteIsChanging((HWND)wParam);
1901           mr = mrDoDefault;
1902           break;
1903       case WM_QUERYNEWPALETTE:
1904           mr = WmQueryNewPalette(retValue);
1905           break;
1906       case WM_PALETTECHANGED:
1907           mr = WmPaletteChanged((HWND)wParam);
1908           break;
1909       case WM_STYLECHANGED:
1910           mr = WmStyleChanged(static_cast<int>(wParam), (LPSTYLESTRUCT)lParam);
1911           break;
1912       case WM_SETTINGCHANGE:
1913           CheckFontSmoothingSettings(NULL);
1914           mr = WmSettingChange(static_cast<UINT>(wParam), (LPCTSTR)lParam);
1915           break;
1916       case WM_CONTEXTMENU:
1917           mr = WmContextMenu((HWND)wParam,
1918                              GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
1919           break;
1920 
1921           /*
1922            * These messages are used to route Win32 calls to the
1923            * creating thread, since these calls fail unless executed
1924            * there.
1925            */
1926       case WM_AWT_COMPONENT_SHOW:
1927           Show();
1928           mr = mrConsume;
1929           break;
1930       case WM_AWT_COMPONENT_HIDE:
1931           Hide();
1932           mr = mrConsume;
1933           break;
1934 
1935       case WM_AWT_COMPONENT_SETFOCUS:
1936           if ((BOOL)wParam) {
1937               retValue = SynthesizeWmSetFocus(GetHWnd(), NULL);
1938           } else {
1939               retValue = SynthesizeWmKillFocus(GetHWnd(), NULL);
1940           }
1941           mr = mrConsume;
1942           break;
1943       case WM_AWT_WINDOW_SETACTIVE:
1944           retValue = (LRESULT)((AwtWindow*)this)->AwtSetActiveWindow((BOOL)wParam);
1945           mr = mrConsume;
1946           break;
1947 
1948       case WM_AWT_SET_SCROLL_INFO: {
1949           SCROLLINFO *si = (SCROLLINFO *) lParam;
1950           ::SetScrollInfo(GetHWnd(), (int) wParam, si, TRUE);
1951           delete si;
1952           mr = mrConsume;
1953           break;
1954       }
1955       case WM_AWT_CREATE_PRINTED_PIXELS: {
1956           CreatePrintedPixelsStruct* cpps = (CreatePrintedPixelsStruct*)wParam;
1957           SIZE loc = { cpps->srcx, cpps->srcy };
1958           SIZE size = { cpps->srcw, cpps->srch };
1959           retValue = (LRESULT)CreatePrintedPixels(loc, size, cpps->alpha);
1960           mr = mrConsume;
1961           break;
1962       }
1963       case WM_UNDOCUMENTED_CLICKMENUBAR:
1964       {
1965           if (::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()))) {
1966               mr = mrConsume;
1967           }
1968       }
1969     }
1970 
1971     /*
1972      * If not a specific Consume, it was a specific DoDefault, or a
1973      * PassAlong (since the default is the next in chain), then call the
1974      * default proc.
1975      */
1976     if (mr != mrConsume) {
1977         retValue = DefWindowProc(message, wParam, lParam);
1978     }
1979 
1980     return retValue;
1981 }
1982 /*
1983  * Call this instance's default window proc, or if none set, call the stock
1984  * Window's one.
1985  */
1986 LRESULT AwtComponent::DefWindowProc(UINT msg, WPARAM wParam, LPARAM lParam)
1987 {
1988     return ComCtl32Util::GetInstance().DefWindowProc(m_DefWindowProc, GetHWnd(), msg, wParam, lParam);
1989 }
1990 
1991 /*
1992  * This message should only be received when a window is destroyed by
1993  * Windows, and not Java.  Window termination has been reworked so
1994  * this method should never be called during termination.
1995  */
1996 MsgRouting AwtComponent::WmDestroy()
1997 {
1998     return mrConsume;
1999 }
2000 
2001 /*
2002  * This message should only be received when a window is destroyed by
2003  * Windows, and not Java. It is sent only after child windows were destroyed.
2004  */
2005 MsgRouting AwtComponent::WmNcDestroy()
2006 {
2007     if (m_peerObject != NULL) { // is not being terminating
2008         // Stay in this handler until AwtComponent::Dispose is called.
2009         m_bPauseDestroy = TRUE;
2010 
2011         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
2012         // Post invocation event for WObjectPeer.dispose to EDT
2013         env->CallVoidMethod(m_peerObject, AwtComponent::disposeLaterMID);
2014         // Wait until AwtComponent::Dispose is called
2015         AwtToolkit::GetInstance().PumpToDestroy(this);
2016     }
2017 
2018     return mrConsume;
2019 }
2020 
2021 MsgRouting AwtComponent::WmGetMinMaxInfo(LPMINMAXINFO lpmmi)
2022 {
2023     return mrDoDefault;
2024 }
2025 
2026 MsgRouting AwtComponent::WmMove(int x, int y)
2027 {
2028     SetDrawState(GetDrawState() | static_cast<jint>(JAWT_LOCK_BOUNDS_CHANGED)
2029         | static_cast<jint>(JAWT_LOCK_CLIP_CHANGED));
2030     return mrDoDefault;
2031 }
2032 
2033 MsgRouting AwtComponent::WmSize(UINT type, int w, int h)
2034 {
2035     SetDrawState(GetDrawState() | static_cast<jint>(JAWT_LOCK_BOUNDS_CHANGED)
2036         | static_cast<jint>(JAWT_LOCK_CLIP_CHANGED));
2037     return mrDoDefault;
2038 }
2039 
2040 MsgRouting AwtComponent::WmSizing()
2041 {
2042     return mrDoDefault;
2043 }
2044 
2045 MsgRouting AwtComponent::WmSysCommand(UINT uCmdType, int xPos, int yPos)
2046 {
2047     return mrDoDefault;
2048 }
2049 
2050 MsgRouting AwtComponent::WmExitSizeMove()
2051 {
2052     return mrDoDefault;
2053 }
2054 
2055 MsgRouting AwtComponent::WmEnterMenuLoop(BOOL isTrackPopupMenu)
2056 {
2057     return mrDoDefault;
2058 }
2059 
2060 MsgRouting AwtComponent::WmExitMenuLoop(BOOL isTrackPopupMenu)
2061 {
2062     return mrDoDefault;
2063 }
2064 
2065 MsgRouting AwtComponent::WmShowWindow(BOOL show, UINT status)
2066 {
2067     return mrDoDefault;
2068 }
2069 
2070 MsgRouting AwtComponent::WmSetFocus(HWND hWndLostFocus)
2071 {
2072     m_wheelRotationAmount = 0;
2073     return mrDoDefault;
2074 }
2075 
2076 MsgRouting AwtComponent::WmKillFocus(HWND hWndGotFocus)
2077 {
2078     m_wheelRotationAmount = 0;
2079     return mrDoDefault;
2080 }
2081 
2082 MsgRouting AwtComponent::WmCtlColor(HDC hDC, HWND hCtrl,
2083                                     UINT ctlColor, HBRUSH& retBrush)
2084 {
2085     AwtComponent* child = AwtComponent::GetComponent(hCtrl);
2086     if (child) {
2087         ::SetBkColor(hDC, child->GetBackgroundColor());
2088         ::SetTextColor(hDC, child->GetColor());
2089         retBrush = child->GetBackgroundBrush();
2090         return mrConsume;
2091     }
2092     return mrDoDefault;
2093 /*
2094     switch (ctlColor) {
2095         case CTLCOLOR_MSGBOX:
2096         case CTLCOLOR_EDIT:
2097         case CTLCOLOR_LISTBOX:
2098         case CTLCOLOR_BTN:
2099         case CTLCOLOR_DLG:
2100         case CTLCOLOR_SCROLLBAR:
2101         case CTLCOLOR_STATIC:
2102     }
2103 */
2104 }
2105 
2106 MsgRouting AwtComponent::WmHScroll(UINT scrollCode, UINT pos,
2107                                    HWND hScrollbar) {
2108     if (hScrollbar && hScrollbar != GetHWnd()) {
2109         /* the last test should never happen */
2110         AwtComponent* sb = GetComponent(hScrollbar);
2111         if (sb) {
2112             sb->WmHScroll(scrollCode, pos, hScrollbar);
2113         }
2114     }
2115     return mrDoDefault;
2116 }
2117 
2118 MsgRouting AwtComponent::WmVScroll(UINT scrollCode, UINT pos, HWND hScrollbar)
2119 {
2120     if (hScrollbar && hScrollbar != GetHWnd()) {
2121         /* the last test should never happen */
2122         AwtComponent* sb = GetComponent(hScrollbar);
2123         if (sb) {
2124             sb->WmVScroll(scrollCode, pos, hScrollbar);
2125         }
2126     }
2127     return mrDoDefault;
2128 }
2129 
2130 
2131 MsgRouting AwtComponent::WmPaint(HDC)
2132 {
2133     /* Get the rectangle that covers all update regions, if any exist. */
2134     RECT r;
2135     if (::GetUpdateRect(GetHWnd(), &r, FALSE)) {
2136         if ((r.right-r.left) > 0 && (r.bottom-r.top) > 0 &&
2137             m_peerObject != NULL && m_callbacksEnabled) {
2138             /*
2139              * Always call handlePaint, because the underlying control
2140              * will have painted itself (the "background") before any
2141              * paint method is called.
2142              */
2143             DoCallback("handlePaint", "(IIII)V",
2144                        r.left, r.top, r.right-r.left, r.bottom-r.top);
2145         }
2146     }
2147     return mrDoDefault;
2148 }
2149 
2150 void AwtComponent::PaintUpdateRgn(const RECT *insets)
2151 {
2152     // Fix 4530093: Don't Validate if can't actually paint
2153     if (m_peerObject == NULL || !m_callbacksEnabled) {
2154 
2155         // Fix 4745222: If we don't ValidateRgn,  windows will keep sending
2156         // WM_PAINT messages until we do. This causes java to go into
2157         // a tight loop that increases CPU to 100% and starves main
2158         // thread which needs to complete initialization, but cant.
2159         ::ValidateRgn(GetHWnd(), NULL);
2160 
2161         return;
2162     }
2163 
2164     HRGN rgn = ::CreateRectRgn(0,0,1,1);
2165     int updated = ::GetUpdateRgn(GetHWnd(), rgn, FALSE);
2166     /*
2167      * Now remove all update regions from this window -- do it
2168      * here instead of after the Java upcall, in case any new
2169      * updating is requested.
2170      */
2171     ::ValidateRgn(GetHWnd(), NULL);
2172 
2173     if (updated == COMPLEXREGION || updated == SIMPLEREGION) {
2174         if (insets != NULL) {
2175             ::OffsetRgn(rgn, insets->left, insets->top);
2176         }
2177         DWORD size = ::GetRegionData(rgn, 0, NULL);
2178         if (size == 0) {
2179             ::DeleteObject((HGDIOBJ)rgn);
2180             return;
2181         }
2182         char* buffer = new char[size]; // safe because sizeof(char)==1
2183         memset(buffer, 0, size);
2184         LPRGNDATA rgndata = (LPRGNDATA)buffer;
2185         rgndata->rdh.dwSize = sizeof(RGNDATAHEADER);
2186         rgndata->rdh.iType = RDH_RECTANGLES;
2187         int retCode = ::GetRegionData(rgn, size, rgndata);
2188         VERIFY(retCode);
2189         if (retCode == 0) {
2190             delete [] buffer;
2191             ::DeleteObject((HGDIOBJ)rgn);
2192             return;
2193         }
2194         /*
2195          * Updating rects are divided into mostly vertical and mostly horizontal
2196          * Each group is united together and if not empty painted separately
2197          */
2198         RECT* r = (RECT*)(buffer + rgndata->rdh.dwSize);
2199         RECT* un[2] = {0, 0};
2200     DWORD i;
2201     for (i = 0; i < rgndata->rdh.nCount; i++, r++) {
2202             int width = r->right-r->left;
2203             int height = r->bottom-r->top;
2204             if (width > 0 && height > 0) {
2205                 int toAdd = (width > height) ? 0: 1;
2206                 if (un[toAdd] != 0) {
2207                     ::UnionRect(un[toAdd], un[toAdd], r);
2208                 } else {
2209                     un[toAdd] = r;
2210                 }
2211             }
2212         }
2213         for(i = 0; i < 2; i++) {
2214             if (un[i] != 0) {
2215                 DoCallback("handleExpose", "(IIII)V", un[i]->left, un[i]->top,
2216                     un[i]->right-un[i]->left, un[i]->bottom-un[i]->top);



2217             }
2218         }
2219         delete [] buffer;
2220     }
2221     ::DeleteObject((HGDIOBJ)rgn);
2222 }
2223 
2224 MsgRouting AwtComponent::WmMouseEnter(UINT flags, int x, int y)
2225 {
2226     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_ENTERED,
2227                    ::JVM_CurrentTimeMillis(NULL, 0), x, y, GetJavaModifiers(), 0, JNI_FALSE);
2228     if ((flags & ALL_MK_BUTTONS) == 0) {
2229         AwtCursor::UpdateCursor(this);
2230     }
2231     sm_cursorOn = GetHWnd();
2232     return mrConsume;   /* Don't pass our synthetic event on! */
2233 }
2234 
2235 MSG*
2236 AwtComponent::CreateMessage(UINT message, WPARAM wParam, LPARAM lParam,
2237                             int x = 0, int y = 0)
2238 {
2239     MSG* pMsg = new MSG;
2240     InitMessage(pMsg, message, wParam, lParam, x, y);
2241     return pMsg;
2242 }
2243 
2244 
2245 jint
2246 AwtComponent::GetDrawState(HWND hwnd) {
2247     return (jint)(INT_PTR)(::GetProp(hwnd, DrawingStateProp));
2248 }
2249 
2250 void
2251 AwtComponent::SetDrawState(HWND hwnd, jint state) {
2252     ::SetProp(hwnd, DrawingStateProp, (HANDLE)(INT_PTR)state);
2253 }
2254 
2255 void
2256 AwtComponent::InitMessage(MSG* msg, UINT message, WPARAM wParam, LPARAM lParam,
2257                             int x = 0, int y = 0)
2258 {
2259     msg->message = message;
2260     msg->wParam = wParam;
2261     msg->lParam = lParam;
2262     msg->time = ::GetMessageTime();
2263     msg->pt.x = x;
2264     msg->pt.y = y;
2265 }
2266 
2267 MsgRouting AwtComponent::WmNcMouseDown(WPARAM hitTest, int x, int y, int button) {
2268     return mrDoDefault;
2269 }
2270 MsgRouting AwtComponent::WmNcMouseUp(WPARAM hitTest, int x, int y, int button) {
2271     return mrDoDefault;
2272 }
2273 
2274 MsgRouting AwtComponent::WmWindowPosChanging(LPARAM windowPos) {
2275     return mrDoDefault;
2276 }
2277 MsgRouting AwtComponent::WmWindowPosChanged(LPARAM windowPos) {
2278     return mrDoDefault;
2279 }
2280 
2281 /* Double-click variables. */
2282 static jlong multiClickTime = ::GetDoubleClickTime();
2283 static int multiClickMaxX = ::GetSystemMetrics(SM_CXDOUBLECLK);
2284 static int multiClickMaxY = ::GetSystemMetrics(SM_CYDOUBLECLK);
2285 static AwtComponent* lastClickWnd = NULL;
2286 static jlong lastTime = 0;
2287 static int lastClickX = 0;
2288 static int lastClickY = 0;
2289 static int lastButton = 0;
2290 static int clickCount = 0;
2291 
2292 // A static method that makes the clickCount available in the derived classes
2293 // overriding WmMouseDown().
2294 int AwtComponent::GetClickCount()
2295 {
2296     return clickCount;
2297 }
2298 
2299 MsgRouting AwtComponent::WmMouseDown(UINT flags, int x, int y, int button)
2300 {
2301     jlong now = ::JVM_CurrentTimeMillis(NULL, 0);
2302 
2303     if (lastClickWnd == this &&
2304         lastButton == button &&
2305         (now - lastTime) <= multiClickTime &&
2306         abs(x - lastClickX) <= multiClickMaxX &&
2307         abs(y - lastClickY) <= multiClickMaxY)
2308     {
2309         clickCount++;
2310     } else {
2311         clickCount = 1;
2312         lastClickWnd = this;
2313         lastButton = button;
2314         lastClickX = x;
2315         lastClickY = y;
2316     }
2317     /*
2318      *Set appropriate bit of the mask on WM_MOUSE_DOWN message.
2319      */
2320     m_mouseButtonClickAllowed |= GetButtonMK(button);
2321     lastTime = now;
2322 
2323     MSG msg;
2324     InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2325 
2326     AwtWindow *toplevel = GetContainer();
2327     if (toplevel && !toplevel->IsSimpleWindow()) {
2328         /*
2329          * The frame should be focused by click in case it is
2330          * the active window but not the focused window. See 6886678.
2331          */
2332         if (toplevel->GetHWnd() == ::GetActiveWindow() &&
2333             toplevel->GetHWnd() != AwtComponent::GetFocusedWindow())
2334         {
2335             toplevel->AwtSetActiveWindow();
2336         }
2337     }
2338 
2339     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_PRESSED, now, x, y,
2340                    GetJavaModifiers(), clickCount, JNI_FALSE,
2341                    GetButton(button), &msg);
2342     /*
2343      * NOTE: this call is intentionally placed after all other code,
2344      * since AwtComponent::WmMouseDown() assumes that the cached id of the
2345      * latest retrieved message (see lastMessage in awt_Component.cpp)
2346      * matches the mouse message being processed.
2347      * SetCapture() sends WM_CAPTURECHANGED and breaks that
2348      * assumption.
2349      */
2350     SetDragCapture(flags);
2351 
2352     AwtWindow * owner = (AwtWindow*)GetComponent(GetTopLevelParentForWindow(GetHWnd()));
2353     if (AwtWindow::GetGrabbedWindow() != NULL && owner != NULL) {
2354         if (!AwtWindow::GetGrabbedWindow()->IsOneOfOwnersOf(owner)) {
2355             AwtWindow::GetGrabbedWindow()->Ungrab();
2356         }
2357     }
2358     return mrConsume;
2359 }
2360 
2361 MsgRouting AwtComponent::WmMouseUp(UINT flags, int x, int y, int button)
2362 {
2363     MSG msg;
2364     InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2365 
2366     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_RELEASED, ::JVM_CurrentTimeMillis(NULL, 0),
2367                    x, y, GetJavaModifiers(), clickCount,
2368                    (GetButton(button) == java_awt_event_MouseEvent_BUTTON3 ?
2369                     TRUE : FALSE), GetButton(button), &msg);
2370     /*
2371      * If no movement, then report a click following the button release.
2372      * When WM_MOUSEUP comes to a window without previous WM_MOUSEDOWN,
2373      * spurous MOUSE_CLICK is about to happen. See 6430553.
2374      */
2375     if ((m_mouseButtonClickAllowed & GetButtonMK(button)) != 0) { //CLICK allowed
2376         SendMouseEvent(java_awt_event_MouseEvent_MOUSE_CLICKED,
2377                        ::JVM_CurrentTimeMillis(NULL, 0), x, y, GetJavaModifiers(),
2378                        clickCount, JNI_FALSE, GetButton(button));
2379     }
2380     // Exclude button from allowed to generate CLICK messages
2381     m_mouseButtonClickAllowed &= ~GetButtonMK(button);
2382 
2383     if ((flags & ALL_MK_BUTTONS) == 0) {
2384         // only update if all buttons have been released
2385         AwtCursor::UpdateCursor(this);
2386     }
2387     /*
2388      * NOTE: this call is intentionally placed after all other code,
2389      * since AwtComponent::WmMouseUp() assumes that the cached id of the
2390      * latest retrieved message (see lastMessage in awt_Component.cpp)
2391      * matches the mouse message being processed.
2392      * ReleaseCapture() sends WM_CAPTURECHANGED and breaks that
2393      * assumption.
2394      */
2395     ReleaseDragCapture(flags);
2396 
2397     return mrConsume;
2398 }
2399 
2400 MsgRouting AwtComponent::WmMouseMove(UINT flags, int x, int y)
2401 {
2402     static AwtComponent* lastComp = NULL;
2403     static int lastX = 0;
2404     static int lastY = 0;
2405 
2406     /*
2407      * Only report mouse move and drag events if a move or drag
2408      * actually happened -- Windows sends a WM_MOUSEMOVE in case the
2409      * app wants to modify the cursor.
2410      */
2411     if (lastComp != this || x != lastX || y != lastY) {
2412         lastComp = this;
2413         lastX = x;
2414         lastY = y;
2415         BOOL extraButtonsEnabled = AwtToolkit::GetInstance().areExtraMouseButtonsEnabled();
2416         if (((flags & (ALL_MK_BUTTONS)) != 0) ||
2417             (extraButtonsEnabled && (flags & (X_BUTTONS)) != 0))
2418 //        if (( extraButtonsEnabled && ( (flags & (ALL_MK_BUTTONS | X_BUTTONS)) != 0 )) ||
2419 //            ( !extraButtonsEnabled && (((flags & (ALL_MK_BUTTONS)) != 0 )) && ((flags & (X_BUTTONS)) == 0) ))
2420         {
2421             // 6404008 : if Dragged event fired we shouldn't fire
2422             // Clicked event: m_firstDragSent set to TRUE.
2423             // This is a partial backout of 5039416 fix.
2424             MSG msg;
2425             InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2426             SendMouseEvent(java_awt_event_MouseEvent_MOUSE_DRAGGED, ::JVM_CurrentTimeMillis(NULL, 0), x, y,
2427                            GetJavaModifiers(), 0, JNI_FALSE,
2428                            java_awt_event_MouseEvent_NOBUTTON, &msg);
2429             //dragging means no more CLICKs until next WM_MOUSE_DOWN/WM_MOUSE_UP message sequence
2430             m_mouseButtonClickAllowed = 0;
2431         } else {
2432             MSG msg;
2433             InitMessage(&msg, lastMessage, flags, MAKELPARAM(x, y), x, y);
2434             SendMouseEvent(java_awt_event_MouseEvent_MOUSE_MOVED, ::JVM_CurrentTimeMillis(NULL, 0), x, y,
2435                            GetJavaModifiers(), 0, JNI_FALSE,
2436                            java_awt_event_MouseEvent_NOBUTTON, &msg);
2437         }
2438     }
2439 
2440     return mrConsume;
2441 }
2442 
2443 MsgRouting AwtComponent::WmMouseExit(UINT flags, int x, int y)
2444 {
2445     SendMouseEvent(java_awt_event_MouseEvent_MOUSE_EXITED, ::JVM_CurrentTimeMillis(NULL, 0), x,
2446                    y, GetJavaModifiers(), 0, JNI_FALSE);
2447     sm_cursorOn = NULL;
2448     return mrConsume;   /* Don't pass our synthetic event on! */
2449 }
2450 
2451 MsgRouting AwtComponent::WmMouseWheel(UINT flags, int x, int y,
2452                                       int wheelRotation)
2453 {
2454     // convert coordinates to be Component-relative, not screen relative
2455     // for wheeling when outside the window, this works similar to
2456     // coordinates during a drag
2457     POINT eventPt;
2458     eventPt.x = x;
2459     eventPt.y = y;
2460     DTRACE_PRINT2("  original coords: %i,%i\n", x, y);
2461     ::ScreenToClient(GetHWnd(), &eventPt);
2462     DTRACE_PRINT2("  new coords: %i,%i\n\n", eventPt.x, eventPt.y);
2463 
2464     // set some defaults
2465     jint scrollType = java_awt_event_MouseWheelEvent_WHEEL_UNIT_SCROLL;
2466     jint scrollLines = 3;
2467 
2468     BOOL result;
2469     UINT platformLines;
2470 
2471     m_wheelRotationAmount += wheelRotation;
2472 
2473     // AWT interprets wheel rotation differently than win32, so we need to
2474     // decode wheel amount.
2475     jint roundedWheelRotation = m_wheelRotationAmount / (-1 * WHEEL_DELTA);
2476     jdouble preciseWheelRotation = (jdouble) wheelRotation / (-1 * WHEEL_DELTA);
2477 
2478     MSG msg;
2479     result = ::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
2480                                     &platformLines, 0);
2481     InitMessage(&msg, lastMessage, MAKEWPARAM(flags, wheelRotation),
2482                 MAKELPARAM(x, y));
2483 
2484     if (result) {
2485         if (platformLines == WHEEL_PAGESCROLL) {
2486             scrollType = java_awt_event_MouseWheelEvent_WHEEL_BLOCK_SCROLL;
2487             scrollLines = 1;
2488         }
2489         else {
2490             scrollType = java_awt_event_MouseWheelEvent_WHEEL_UNIT_SCROLL;
2491             scrollLines = platformLines;
2492         }
2493     }
2494 
2495     DTRACE_PRINTLN("calling SendMouseWheelEvent");
2496 
2497     SendMouseWheelEvent(java_awt_event_MouseEvent_MOUSE_WHEEL, ::JVM_CurrentTimeMillis(NULL, 0),
2498                         eventPt.x, eventPt.y, GetJavaModifiers(), 0, 0, scrollType,
2499                         scrollLines, roundedWheelRotation, preciseWheelRotation, &msg);
2500 
2501     m_wheelRotationAmount %= WHEEL_DELTA;
2502     // this message could be propagated up to the parent chain
2503     // by the mouse message post processors
2504     return mrConsume;
2505 }
2506 
2507 jint AwtComponent::GetKeyLocation(UINT wkey, UINT flags) {
2508     // Rector+Newcomer page 413
2509     // The extended keys are the Alt and Control on the right of
2510     // the space bar, the non-Numpad arrow keys, the non-Numpad
2511     // Insert, PageUp, etc. keys, and the Numpad Divide and Enter keys.
2512     // Note that neither Shift key is extended.
2513     // Although not listed in Rector+Newcomer, both Windows keys
2514     // (91 and 92) are extended keys, the Context Menu key
2515     // (property key or application key - 93) is extended,
2516     // and so is the NumLock key.
2517 
2518     // wkey is the wParam, flags is the HIWORD of the lParam
2519 
2520     // "Extended" bit is 24th in lParam, so it's 8th in flags = HIWORD(lParam)
2521     BOOL extended = ((1<<8) & flags);
2522 
2523     if (IsNumPadKey(wkey, extended)) {
2524         return java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD;
2525     }
2526 
2527     switch (wkey) {
2528       case VK_SHIFT:
2529         return AwtComponent::GetShiftKeyLocation(wkey, flags);
2530       case VK_CONTROL: // fall through
2531       case VK_MENU:
2532         if (extended) {
2533             return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
2534         } else {
2535             return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2536         }
2537       case VK_LWIN:
2538         return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2539       case VK_RWIN:
2540         return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
2541       default:
2542         break;
2543     }
2544 
2545     // REMIND: if we add keycodes for the windows keys, we'll have to
2546     // include left/right discrimination code for them.
2547 
2548     return java_awt_event_KeyEvent_KEY_LOCATION_STANDARD;
2549 }
2550 
2551 jint AwtComponent::GetShiftKeyLocation(UINT vkey, UINT flags)
2552 {
2553     // init scancodes to safe values
2554     UINT leftShiftScancode = 0;
2555     UINT rightShiftScancode = 0;
2556 
2557     // First 8 bits of flags is the scancode
2558     UINT keyScanCode = flags & 0xFF;
2559 
2560     DTRACE_PRINTLN3(
2561       "AwtComponent::GetShiftKeyLocation  vkey = %d = 0x%x  scan = %d",
2562       vkey, vkey, keyScanCode);
2563 
2564     leftShiftScancode = ::MapVirtualKey(VK_LSHIFT, 0);
2565     rightShiftScancode = ::MapVirtualKey(VK_RSHIFT, 0);
2566 
2567     if (keyScanCode == leftShiftScancode) {
2568         return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2569     }
2570     if (keyScanCode == rightShiftScancode) {
2571         return java_awt_event_KeyEvent_KEY_LOCATION_RIGHT;
2572     }
2573 
2574     DASSERT(false);
2575     // Note: the above should not fail on NT (or 2000)
2576 
2577     // default value
2578     return java_awt_event_KeyEvent_KEY_LOCATION_LEFT;
2579 }
2580 
2581 /* Returns Java extended InputEvent modifieres.
2582  * Since ::GetKeyState returns current state and Java modifiers represent
2583  * state before event, modifier on changed key are inverted.
2584  */
2585 jint
2586 AwtComponent::GetJavaModifiers()
2587 {
2588     jint modifiers = 0;
2589 
2590     if (HIBYTE(::GetKeyState(VK_CONTROL)) != 0) {
2591         modifiers |= java_awt_event_InputEvent_CTRL_DOWN_MASK;
2592     }
2593     if (HIBYTE(::GetKeyState(VK_SHIFT)) != 0) {
2594         modifiers |= java_awt_event_InputEvent_SHIFT_DOWN_MASK;
2595     }
2596     if (HIBYTE(::GetKeyState(VK_MENU)) != 0) {
2597         modifiers |= java_awt_event_InputEvent_ALT_DOWN_MASK;
2598     }
2599     if (HIBYTE(::GetKeyState(VK_MBUTTON)) != 0) {
2600        modifiers |= java_awt_event_InputEvent_BUTTON2_DOWN_MASK;
2601     }
2602     if (HIBYTE(::GetKeyState(VK_RBUTTON)) != 0) {
2603         modifiers |= java_awt_event_InputEvent_BUTTON3_DOWN_MASK;
2604     }
2605     if (HIBYTE(::GetKeyState(VK_LBUTTON)) != 0) {
2606         modifiers |= java_awt_event_InputEvent_BUTTON1_DOWN_MASK;
2607     }
2608 
2609     if (HIBYTE(::GetKeyState(VK_XBUTTON1)) != 0) {
2610         modifiers |= masks[3];
2611     }
2612     if (HIBYTE(::GetKeyState(VK_XBUTTON2)) != 0) {
2613         modifiers |= masks[4];
2614     }
2615     return modifiers;
2616 }
2617 
2618 jint
2619 AwtComponent::GetButton(int mouseButton)
2620 {
2621     /* Mouse buttons are already set correctly for left/right handedness */
2622     switch(mouseButton) {
2623     case LEFT_BUTTON:
2624         return java_awt_event_MouseEvent_BUTTON1;
2625     case MIDDLE_BUTTON:
2626         return java_awt_event_MouseEvent_BUTTON2;
2627     case RIGHT_BUTTON:
2628         return java_awt_event_MouseEvent_BUTTON3;
2629     case X1_BUTTON: //16 :
2630         //just assign 4 and 5 numbers because MouseEvent class doesn't contain const identifier for them now
2631         return 4;
2632     case X2_BUTTON: //32
2633         return 5;
2634     }
2635     return java_awt_event_MouseEvent_NOBUTTON;
2636 }
2637 
2638 UINT
2639 AwtComponent::GetButtonMK(int mouseButton)
2640 {
2641     switch(mouseButton) {
2642     case LEFT_BUTTON:
2643         return MK_LBUTTON;
2644     case MIDDLE_BUTTON:
2645         return MK_MBUTTON;
2646     case RIGHT_BUTTON:
2647         return MK_RBUTTON;
2648     case X1_BUTTON:
2649         return MK_XBUTTON1;
2650     case X2_BUTTON:
2651         return MK_XBUTTON2;
2652     }
2653     return 0;
2654 }
2655 
2656 // FIXME: Keyboard related stuff has grown so big and hairy that we
2657 // really need to move it into a class of its own.  And, since
2658 // keyboard is a shared resource, AwtComponent is a bad place for it.
2659 
2660 // These constants are defined in the Japanese version of VC++5.0,
2661 // but not the US version
2662 #ifndef VK_CONVERT
2663 #define VK_KANA           0x15
2664 #define VK_KANJI          0x19
2665 #define VK_CONVERT        0x1C
2666 #define VK_NONCONVERT     0x1D
2667 #endif
2668 
2669 #ifndef VK_XBUTTON1
2670 #define VK_XBUTTON1      0x05
2671 #endif
2672 
2673 #ifndef VK_XBUTTON2
2674 #define VK_XBUTTON2      0x06
2675 #endif
2676 
2677 typedef struct {
2678     UINT javaKey;
2679     UINT windowsKey;
2680 } KeyMapEntry;
2681 
2682 // Static table, arranged more or less spatially.
2683 KeyMapEntry keyMapTable[] = {
2684     // Modifier keys
2685     {java_awt_event_KeyEvent_VK_CAPS_LOCK,        VK_CAPITAL},
2686     {java_awt_event_KeyEvent_VK_SHIFT,            VK_SHIFT},
2687     {java_awt_event_KeyEvent_VK_CONTROL,          VK_CONTROL},
2688     {java_awt_event_KeyEvent_VK_ALT,              VK_MENU},
2689     {java_awt_event_KeyEvent_VK_NUM_LOCK,         VK_NUMLOCK},
2690 
2691     // Miscellaneous Windows keys
2692     {java_awt_event_KeyEvent_VK_WINDOWS,          VK_LWIN},
2693     {java_awt_event_KeyEvent_VK_WINDOWS,          VK_RWIN},
2694     {java_awt_event_KeyEvent_VK_CONTEXT_MENU,     VK_APPS},
2695 
2696     // Alphabet
2697     {java_awt_event_KeyEvent_VK_A,                'A'},
2698     {java_awt_event_KeyEvent_VK_B,                'B'},
2699     {java_awt_event_KeyEvent_VK_C,                'C'},
2700     {java_awt_event_KeyEvent_VK_D,                'D'},
2701     {java_awt_event_KeyEvent_VK_E,                'E'},
2702     {java_awt_event_KeyEvent_VK_F,                'F'},
2703     {java_awt_event_KeyEvent_VK_G,                'G'},
2704     {java_awt_event_KeyEvent_VK_H,                'H'},
2705     {java_awt_event_KeyEvent_VK_I,                'I'},
2706     {java_awt_event_KeyEvent_VK_J,                'J'},
2707     {java_awt_event_KeyEvent_VK_K,                'K'},
2708     {java_awt_event_KeyEvent_VK_L,                'L'},
2709     {java_awt_event_KeyEvent_VK_M,                'M'},
2710     {java_awt_event_KeyEvent_VK_N,                'N'},
2711     {java_awt_event_KeyEvent_VK_O,                'O'},
2712     {java_awt_event_KeyEvent_VK_P,                'P'},
2713     {java_awt_event_KeyEvent_VK_Q,                'Q'},
2714     {java_awt_event_KeyEvent_VK_R,                'R'},
2715     {java_awt_event_KeyEvent_VK_S,                'S'},
2716     {java_awt_event_KeyEvent_VK_T,                'T'},
2717     {java_awt_event_KeyEvent_VK_U,                'U'},
2718     {java_awt_event_KeyEvent_VK_V,                'V'},
2719     {java_awt_event_KeyEvent_VK_W,                'W'},
2720     {java_awt_event_KeyEvent_VK_X,                'X'},
2721     {java_awt_event_KeyEvent_VK_Y,                'Y'},
2722     {java_awt_event_KeyEvent_VK_Z,                'Z'},
2723 
2724     // Standard numeric row
2725     {java_awt_event_KeyEvent_VK_0,                '0'},
2726     {java_awt_event_KeyEvent_VK_1,                '1'},
2727     {java_awt_event_KeyEvent_VK_2,                '2'},
2728     {java_awt_event_KeyEvent_VK_3,                '3'},
2729     {java_awt_event_KeyEvent_VK_4,                '4'},
2730     {java_awt_event_KeyEvent_VK_5,                '5'},
2731     {java_awt_event_KeyEvent_VK_6,                '6'},
2732     {java_awt_event_KeyEvent_VK_7,                '7'},
2733     {java_awt_event_KeyEvent_VK_8,                '8'},
2734     {java_awt_event_KeyEvent_VK_9,                '9'},
2735 
2736     // Misc key from main block
2737     {java_awt_event_KeyEvent_VK_ENTER,            VK_RETURN},
2738     {java_awt_event_KeyEvent_VK_SPACE,            VK_SPACE},
2739     {java_awt_event_KeyEvent_VK_BACK_SPACE,       VK_BACK},
2740     {java_awt_event_KeyEvent_VK_TAB,              VK_TAB},
2741     {java_awt_event_KeyEvent_VK_ESCAPE,           VK_ESCAPE},
2742 
2743     // NumPad with NumLock off & extended block (rectangular)
2744     {java_awt_event_KeyEvent_VK_INSERT,           VK_INSERT},
2745     {java_awt_event_KeyEvent_VK_DELETE,           VK_DELETE},
2746     {java_awt_event_KeyEvent_VK_HOME,             VK_HOME},
2747     {java_awt_event_KeyEvent_VK_END,              VK_END},
2748     {java_awt_event_KeyEvent_VK_PAGE_UP,          VK_PRIOR},
2749     {java_awt_event_KeyEvent_VK_PAGE_DOWN,        VK_NEXT},
2750     {java_awt_event_KeyEvent_VK_CLEAR,            VK_CLEAR}, // NumPad 5
2751 
2752     // NumPad with NumLock off & extended arrows block (triangular)
2753     {java_awt_event_KeyEvent_VK_LEFT,             VK_LEFT},
2754     {java_awt_event_KeyEvent_VK_RIGHT,            VK_RIGHT},
2755     {java_awt_event_KeyEvent_VK_UP,               VK_UP},
2756     {java_awt_event_KeyEvent_VK_DOWN,             VK_DOWN},
2757 
2758     // NumPad with NumLock on: numbers
2759     {java_awt_event_KeyEvent_VK_NUMPAD0,          VK_NUMPAD0},
2760     {java_awt_event_KeyEvent_VK_NUMPAD1,          VK_NUMPAD1},
2761     {java_awt_event_KeyEvent_VK_NUMPAD2,          VK_NUMPAD2},
2762     {java_awt_event_KeyEvent_VK_NUMPAD3,          VK_NUMPAD3},
2763     {java_awt_event_KeyEvent_VK_NUMPAD4,          VK_NUMPAD4},
2764     {java_awt_event_KeyEvent_VK_NUMPAD5,          VK_NUMPAD5},
2765     {java_awt_event_KeyEvent_VK_NUMPAD6,          VK_NUMPAD6},
2766     {java_awt_event_KeyEvent_VK_NUMPAD7,          VK_NUMPAD7},
2767     {java_awt_event_KeyEvent_VK_NUMPAD8,          VK_NUMPAD8},
2768     {java_awt_event_KeyEvent_VK_NUMPAD9,          VK_NUMPAD9},
2769 
2770     // NumPad with NumLock on
2771     {java_awt_event_KeyEvent_VK_MULTIPLY,         VK_MULTIPLY},
2772     {java_awt_event_KeyEvent_VK_ADD,              VK_ADD},
2773     {java_awt_event_KeyEvent_VK_SEPARATOR,        VK_SEPARATOR},
2774     {java_awt_event_KeyEvent_VK_SUBTRACT,         VK_SUBTRACT},
2775     {java_awt_event_KeyEvent_VK_DECIMAL,          VK_DECIMAL},
2776     {java_awt_event_KeyEvent_VK_DIVIDE,           VK_DIVIDE},
2777 
2778     // Functional keys
2779     {java_awt_event_KeyEvent_VK_F1,               VK_F1},
2780     {java_awt_event_KeyEvent_VK_F2,               VK_F2},
2781     {java_awt_event_KeyEvent_VK_F3,               VK_F3},
2782     {java_awt_event_KeyEvent_VK_F4,               VK_F4},
2783     {java_awt_event_KeyEvent_VK_F5,               VK_F5},
2784     {java_awt_event_KeyEvent_VK_F6,               VK_F6},
2785     {java_awt_event_KeyEvent_VK_F7,               VK_F7},
2786     {java_awt_event_KeyEvent_VK_F8,               VK_F8},
2787     {java_awt_event_KeyEvent_VK_F9,               VK_F9},
2788     {java_awt_event_KeyEvent_VK_F10,              VK_F10},
2789     {java_awt_event_KeyEvent_VK_F11,              VK_F11},
2790     {java_awt_event_KeyEvent_VK_F12,              VK_F12},
2791     {java_awt_event_KeyEvent_VK_F13,              VK_F13},
2792     {java_awt_event_KeyEvent_VK_F14,              VK_F14},
2793     {java_awt_event_KeyEvent_VK_F15,              VK_F15},
2794     {java_awt_event_KeyEvent_VK_F16,              VK_F16},
2795     {java_awt_event_KeyEvent_VK_F17,              VK_F17},
2796     {java_awt_event_KeyEvent_VK_F18,              VK_F18},
2797     {java_awt_event_KeyEvent_VK_F19,              VK_F19},
2798     {java_awt_event_KeyEvent_VK_F20,              VK_F20},
2799     {java_awt_event_KeyEvent_VK_F21,              VK_F21},
2800     {java_awt_event_KeyEvent_VK_F22,              VK_F22},
2801     {java_awt_event_KeyEvent_VK_F23,              VK_F23},
2802     {java_awt_event_KeyEvent_VK_F24,              VK_F24},
2803 
2804     {java_awt_event_KeyEvent_VK_PRINTSCREEN,      VK_SNAPSHOT},
2805     {java_awt_event_KeyEvent_VK_SCROLL_LOCK,      VK_SCROLL},
2806     {java_awt_event_KeyEvent_VK_PAUSE,            VK_PAUSE},
2807     {java_awt_event_KeyEvent_VK_CANCEL,           VK_CANCEL},
2808     {java_awt_event_KeyEvent_VK_HELP,             VK_HELP},
2809 
2810     // Japanese
2811     {java_awt_event_KeyEvent_VK_CONVERT,          VK_CONVERT},
2812     {java_awt_event_KeyEvent_VK_NONCONVERT,       VK_NONCONVERT},
2813     {java_awt_event_KeyEvent_VK_INPUT_METHOD_ON_OFF, VK_KANJI},
2814     {java_awt_event_KeyEvent_VK_ALPHANUMERIC,     VK_DBE_ALPHANUMERIC},
2815     {java_awt_event_KeyEvent_VK_KATAKANA,         VK_DBE_KATAKANA},
2816     {java_awt_event_KeyEvent_VK_HIRAGANA,         VK_DBE_HIRAGANA},
2817     {java_awt_event_KeyEvent_VK_FULL_WIDTH,       VK_DBE_DBCSCHAR},
2818     {java_awt_event_KeyEvent_VK_HALF_WIDTH,       VK_DBE_SBCSCHAR},
2819     {java_awt_event_KeyEvent_VK_ROMAN_CHARACTERS, VK_DBE_ROMAN},
2820 
2821     {java_awt_event_KeyEvent_VK_UNDEFINED,        0}
2822 };
2823 
2824 
2825 // Dynamic mapping table for OEM VK codes.  This table is refilled
2826 // by BuildDynamicKeyMapTable when keyboard layout is switched.
2827 // (see NT4 DDK src/input/inc/vkoem.h for OEM VK_ values).
2828 struct DynamicKeyMapEntry {
2829     UINT windowsKey;            // OEM VK codes known in advance
2830     UINT javaKey;               // depends on input langauge (kbd layout)
2831 };
2832 
2833 static DynamicKeyMapEntry dynamicKeyMapTable[] = {
2834     {0x00BA,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_1
2835     {0x00BB,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_PLUS
2836     {0x00BC,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_COMMA
2837     {0x00BD,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_MINUS
2838     {0x00BE,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_PERIOD
2839     {0x00BF,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_2
2840     {0x00C0,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_3
2841     {0x00DB,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_4
2842     {0x00DC,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_5
2843     {0x00DD,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_6
2844     {0x00DE,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_7
2845     {0x00DF,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_8
2846     {0x00E2,  java_awt_event_KeyEvent_VK_UNDEFINED}, // VK_OEM_102
2847     {0, 0}
2848 };
2849 
2850 
2851 
2852 // Auxiliary tables used to fill the above dynamic table.  We first
2853 // find the character for the OEM VK code using ::MapVirtualKey and
2854 // then go through these auxiliary tables to map it to Java VK code.
2855 
2856 struct CharToVKEntry {
2857     WCHAR c;
2858     UINT  javaKey;
2859 };
2860 
2861 static const CharToVKEntry charToVKTable[] = {
2862     {L'!',   java_awt_event_KeyEvent_VK_EXCLAMATION_MARK},
2863     {L'"',   java_awt_event_KeyEvent_VK_QUOTEDBL},
2864     {L'#',   java_awt_event_KeyEvent_VK_NUMBER_SIGN},
2865     {L'$',   java_awt_event_KeyEvent_VK_DOLLAR},
2866     {L'&',   java_awt_event_KeyEvent_VK_AMPERSAND},
2867     {L'\'',  java_awt_event_KeyEvent_VK_QUOTE},
2868     {L'(',   java_awt_event_KeyEvent_VK_LEFT_PARENTHESIS},
2869     {L')',   java_awt_event_KeyEvent_VK_RIGHT_PARENTHESIS},
2870     {L'*',   java_awt_event_KeyEvent_VK_ASTERISK},
2871     {L'+',   java_awt_event_KeyEvent_VK_PLUS},
2872     {L',',   java_awt_event_KeyEvent_VK_COMMA},
2873     {L'-',   java_awt_event_KeyEvent_VK_MINUS},
2874     {L'.',   java_awt_event_KeyEvent_VK_PERIOD},
2875     {L'/',   java_awt_event_KeyEvent_VK_SLASH},
2876     {L':',   java_awt_event_KeyEvent_VK_COLON},
2877     {L';',   java_awt_event_KeyEvent_VK_SEMICOLON},
2878     {L'<',   java_awt_event_KeyEvent_VK_LESS},
2879     {L'=',   java_awt_event_KeyEvent_VK_EQUALS},
2880     {L'>',   java_awt_event_KeyEvent_VK_GREATER},
2881     {L'@',   java_awt_event_KeyEvent_VK_AT},
2882     {L'[',   java_awt_event_KeyEvent_VK_OPEN_BRACKET},
2883     {L'\\',  java_awt_event_KeyEvent_VK_BACK_SLASH},
2884     {L']',   java_awt_event_KeyEvent_VK_CLOSE_BRACKET},
2885     {L'^',   java_awt_event_KeyEvent_VK_CIRCUMFLEX},
2886     {L'_',   java_awt_event_KeyEvent_VK_UNDERSCORE},
2887     {L'`',   java_awt_event_KeyEvent_VK_BACK_QUOTE},
2888     {L'{',   java_awt_event_KeyEvent_VK_BRACELEFT},
2889     {L'}',   java_awt_event_KeyEvent_VK_BRACERIGHT},
2890     {0x00A1, java_awt_event_KeyEvent_VK_INVERTED_EXCLAMATION_MARK},
2891     {0x20A0, java_awt_event_KeyEvent_VK_EURO_SIGN}, // ????
2892     {0,0}
2893 };
2894 
2895 // For dead accents some layouts return ASCII punctuation, while some
2896 // return spacing accent chars, so both should be listed.  NB: MS docs
2897 // say that conversion routings return spacing accent character, not
2898 // combining.
2899 static const CharToVKEntry charToDeadVKTable[] = {
2900     {L'`',   java_awt_event_KeyEvent_VK_DEAD_GRAVE},
2901     {L'\'',  java_awt_event_KeyEvent_VK_DEAD_ACUTE},
2902     {0x00B4, java_awt_event_KeyEvent_VK_DEAD_ACUTE},
2903     {L'^',   java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX},
2904     {L'~',   java_awt_event_KeyEvent_VK_DEAD_TILDE},
2905     {0x02DC, java_awt_event_KeyEvent_VK_DEAD_TILDE},
2906     {0x00AF, java_awt_event_KeyEvent_VK_DEAD_MACRON},
2907     {0x02D8, java_awt_event_KeyEvent_VK_DEAD_BREVE},
2908     {0x02D9, java_awt_event_KeyEvent_VK_DEAD_ABOVEDOT},
2909     {L'"',   java_awt_event_KeyEvent_VK_DEAD_DIAERESIS},
2910     {0x00A8, java_awt_event_KeyEvent_VK_DEAD_DIAERESIS},
2911     {0x02DA, java_awt_event_KeyEvent_VK_DEAD_ABOVERING},
2912     {0x02DD, java_awt_event_KeyEvent_VK_DEAD_DOUBLEACUTE},
2913     {0x02C7, java_awt_event_KeyEvent_VK_DEAD_CARON},            // aka hacek
2914     {L',',   java_awt_event_KeyEvent_VK_DEAD_CEDILLA},
2915     {0x00B8, java_awt_event_KeyEvent_VK_DEAD_CEDILLA},
2916     {0x02DB, java_awt_event_KeyEvent_VK_DEAD_OGONEK},
2917     {0x037A, java_awt_event_KeyEvent_VK_DEAD_IOTA},             // ASCII ???
2918     {0x309B, java_awt_event_KeyEvent_VK_DEAD_VOICED_SOUND},
2919     {0x309C, java_awt_event_KeyEvent_VK_DEAD_SEMIVOICED_SOUND},
2920     {0,0}
2921 };
2922 
2923 // The full map of the current keyboard state including
2924 // windows virtual key, scancode, java virtual key, and unicode
2925 // for this key sans modifiers.
2926 // All but first element may be 0.
2927 // XXX in the update releases this is an addition to the unchanged existing code
2928 struct DynPrimaryKeymapEntry {
2929     UINT wkey;
2930     UINT scancode;
2931     UINT jkey;
2932     WCHAR unicode;
2933 };
2934 
2935 static DynPrimaryKeymapEntry dynPrimaryKeymap[256];
2936 
2937 void
2938 AwtComponent::InitDynamicKeyMapTable()
2939 {
2940     static BOOL kbdinited = FALSE;
2941 
2942     if (!kbdinited) {
2943         AwtComponent::BuildDynamicKeyMapTable();
2944         // We cannot build it here since JNI is not available yet:
2945         //AwtComponent::BuildPrimaryDynamicTable();
2946         kbdinited = TRUE;
2947     }
2948 }
2949 
2950 void
2951 AwtComponent::BuildDynamicKeyMapTable()
2952 {
2953     HKL hkl = GetKeyboardLayout();
2954 
2955     DTRACE_PRINTLN2("Building dynamic VK mapping tables: HKL = %08X (CP%d)",
2956                     hkl, AwtComponent::GetCodePage());
2957 
2958     // Will need this to reset layout after dead keys.
2959     UINT spaceScanCode = ::MapVirtualKeyEx(VK_SPACE, 0, hkl);
2960 
2961     // Entries in dynamic table that maps between Java VK and Windows
2962     // VK are built in three steps:
2963     //   1. Map windows VK to ANSI character (cannot map to unicode
2964     //      directly, since ::ToUnicode is not implemented on win9x)
2965     //   2. Convert ANSI char to Unicode char
2966     //   3. Map Unicode char to Java VK via two auxilary tables.
2967 
2968     for (DynamicKeyMapEntry *dynamic = dynamicKeyMapTable;
2969          dynamic->windowsKey != 0;
2970          ++dynamic)
2971     {
2972         // Defaults to VK_UNDEFINED
2973         dynamic->javaKey = java_awt_event_KeyEvent_VK_UNDEFINED;
2974 
2975         BYTE kbdState[AwtToolkit::KB_STATE_SIZE];
2976         AwtToolkit::GetKeyboardState(kbdState);
2977 
2978         kbdState[dynamic->windowsKey] |=  0x80; // Press the key.
2979 
2980         // Unpress modifiers, since they are most likely pressed as
2981         // part of the keyboard switching shortcut.
2982         kbdState[VK_CONTROL] &= ~0x80;
2983         kbdState[VK_SHIFT]   &= ~0x80;
2984         kbdState[VK_MENU]    &= ~0x80;
2985 
2986         char cbuf[2] = { '\0', '\0'};
2987         UINT scancode = ::MapVirtualKeyEx(dynamic->windowsKey, 0, hkl);
2988         int nchars = ::ToAsciiEx(dynamic->windowsKey, scancode, kbdState,
2989                                  (WORD*)cbuf, 0, hkl);
2990 
2991         // Auxiliary table used to map Unicode character to Java VK.
2992         // Will assign a different table for dead keys (below).
2993         const CharToVKEntry *charMap = charToVKTable;
2994 
2995         if (nchars < 0) { // Dead key
2996             // Use a different table for dead chars since different layouts
2997             // return different characters for the same dead key.
2998             charMap = charToDeadVKTable;
2999 
3000             // We also need to reset layout so that next translation
3001             // is unaffected by the dead status.  We do this by
3002             // translating <SPACE> key.
3003             kbdState[dynamic->windowsKey] &= ~0x80;
3004             kbdState[VK_SPACE] |= 0x80;
3005 
3006             char junkbuf[2] = { '\0', '\0'};
3007             ::ToAsciiEx(VK_SPACE, spaceScanCode, kbdState,
3008                         (WORD*)junkbuf, 0, hkl);
3009         }
3010 
3011 #ifdef DEBUG
3012         if (nchars == 0) {
3013             DTRACE_PRINTLN1("VK 0x%02X -> cannot convert to ANSI char",
3014                             dynamic->windowsKey);
3015             continue;
3016         }
3017         else if (nchars > 1) {  // can't happen, see reset code below
3018             DTRACE_PRINTLN3("VK 0x%02X -> converted to <0x%02X,0x%02X>",
3019                             dynamic->windowsKey,
3020                             (UCHAR)cbuf[0], (UCHAR)cbuf[1]);
3021             continue;
3022         }
3023 #endif
3024 
3025         WCHAR ucbuf[2] = { L'\0', L'\0' };
3026         int nconverted = ::MultiByteToWideChar(AwtComponent::GetCodePage(), 0,
3027                                                cbuf, 1, ucbuf, 2);
3028 #ifdef DEBUG
3029         if (nconverted < 0) {
3030             DTRACE_PRINTLN3("VK 0x%02X -> ANSI 0x%02X -> MultiByteToWideChar failed (0x%X)",
3031                             dynamic->windowsKey, (UCHAR)cbuf[0],
3032                             ::GetLastError());
3033             continue;
3034         }
3035 #endif
3036 
3037         WCHAR uc = ucbuf[0];
3038         for (const CharToVKEntry *map = charMap;  map->c != 0;  ++map) {
3039             if (uc == map->c) {
3040                 dynamic->javaKey = map->javaKey;
3041                 break;
3042             }
3043         }
3044 
3045         DTRACE_PRINTLN4("VK 0x%02X -> ANSI 0x%02X -> U+%04X -> Java VK 0x%X",
3046                         dynamic->windowsKey, (UCHAR)cbuf[0], (UINT)ucbuf[0],
3047                         dynamic->javaKey);
3048     } // for each VK_OEM_*
3049 }
3050 
3051 
3052 static BOOL isKanaLockAvailable()
3053 {
3054     // This method is to determine whether the Kana Lock feature is
3055     // available on the attached keyboard.  Kana Lock feature does not
3056     // necessarily require that the real KANA keytop is available on
3057     // keyboard, so using MapVirtualKey(VK_KANA) is not sufficient for testing.
3058     // Instead of that we regard it as Japanese keyboard (w/ Kana Lock) if :-
3059     //
3060     // - the keyboard layout is Japanese (VK_KANA has the same value as VK_HANGUL)
3061     // - the keyboard is Japanese keyboard (keyboard type == 7).
3062     return (LOWORD(GetKeyboardLayout(0)) == MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT))
3063         && (GetKeyboardType(0) == 7);
3064 }
3065 
3066 void AwtComponent::JavaKeyToWindowsKey(UINT javaKey,
3067                                        UINT *windowsKey, UINT *modifiers, UINT originalWindowsKey)
3068 {
3069     // Handle the few cases where a Java VK code corresponds to a Windows
3070     // key/modifier combination or applies only to specific keyboard layouts
3071     switch (javaKey) {
3072         case java_awt_event_KeyEvent_VK_ALL_CANDIDATES:
3073             *windowsKey = VK_CONVERT;
3074             *modifiers = java_awt_event_InputEvent_ALT_DOWN_MASK;
3075             return;
3076         case java_awt_event_KeyEvent_VK_PREVIOUS_CANDIDATE:
3077             *windowsKey = VK_CONVERT;
3078             *modifiers = java_awt_event_InputEvent_SHIFT_DOWN_MASK;
3079             return;
3080         case java_awt_event_KeyEvent_VK_CODE_INPUT:
3081             *windowsKey = VK_DBE_ALPHANUMERIC;
3082             *modifiers = java_awt_event_InputEvent_ALT_DOWN_MASK;
3083             return;
3084         case java_awt_event_KeyEvent_VK_KANA_LOCK:
3085             if (isKanaLockAvailable()) {
3086                 *windowsKey = VK_KANA;
3087                 *modifiers = java_awt_event_InputEvent_CTRL_DOWN_MASK;
3088                 return;
3089             }
3090     }
3091 
3092     // for the general case, use a bi-directional table
3093     for (int i = 0; keyMapTable[i].windowsKey != 0; i++) {
3094         if (keyMapTable[i].javaKey == javaKey) {
3095             *windowsKey = keyMapTable[i].windowsKey;
3096             *modifiers = 0;
3097             return;
3098         }
3099     }
3100 
3101     // Bug 4766655
3102     // Two Windows keys could map to the same Java key, so
3103     // give preference to the originalWindowsKey if it is
3104     // specified (not IGNORE_KEY).
3105     if (originalWindowsKey == IGNORE_KEY) {
3106         for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
3107             if (dynamicKeyMapTable[j].javaKey == javaKey) {
3108                 *windowsKey = dynamicKeyMapTable[j].windowsKey;
3109                 *modifiers = 0;
3110                 return;
3111             }
3112         }
3113     } else {
3114         BOOL found = false;
3115         for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
3116             if (dynamicKeyMapTable[j].javaKey == javaKey) {
3117                 *windowsKey = dynamicKeyMapTable[j].windowsKey;
3118                 *modifiers = 0;
3119                 found = true;
3120                 if (*windowsKey == originalWindowsKey) {
3121                     return;   /* if ideal case found return, else keep looking */
3122                 }
3123             }
3124         }
3125         if (found) {
3126             return;
3127         }
3128     }
3129 
3130     *windowsKey = 0;
3131     *modifiers = 0;
3132     return;
3133 }
3134 
3135 UINT AwtComponent::WindowsKeyToJavaKey(UINT windowsKey, UINT modifiers, UINT character, BOOL isDeadKey)
3136 
3137 {
3138     // Handle the few cases where we need to take the modifier into
3139     // consideration for the Java VK code or where we have to take the keyboard
3140     // layout into consideration so that function keys can get
3141     // recognized in a platform-independent way.
3142     switch (windowsKey) {
3143         case VK_CONVERT:
3144             if ((modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) != 0) {
3145                 return java_awt_event_KeyEvent_VK_ALL_CANDIDATES;
3146             }
3147             if ((modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) != 0) {
3148                 return java_awt_event_KeyEvent_VK_PREVIOUS_CANDIDATE;
3149             }
3150             break;
3151         case VK_DBE_ALPHANUMERIC:
3152             if ((modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) != 0) {
3153                 return java_awt_event_KeyEvent_VK_CODE_INPUT;
3154             }
3155             break;
3156         case VK_KANA:
3157             if (isKanaLockAvailable()) {
3158                 return java_awt_event_KeyEvent_VK_KANA_LOCK;
3159             }
3160             break;
3161     };
3162 
3163     // check dead key
3164     if (isDeadKey) {
3165       for (int i = 0; charToDeadVKTable[i].c != 0; i++) {
3166         if (charToDeadVKTable[i].c == character) {
3167             return charToDeadVKTable[i].javaKey;
3168         }
3169       }
3170     }
3171 
3172     // for the general case, use a bi-directional table
3173     for (int i = 0; keyMapTable[i].windowsKey != 0; i++) {
3174         if (keyMapTable[i].windowsKey == windowsKey) {
3175             return keyMapTable[i].javaKey;
3176         }
3177     }
3178 
3179     for (int j = 0; dynamicKeyMapTable[j].windowsKey != 0; j++) {
3180         if (dynamicKeyMapTable[j].windowsKey == windowsKey) {
3181             if (dynamicKeyMapTable[j].javaKey != java_awt_event_KeyEvent_VK_UNDEFINED) {
3182                 return dynamicKeyMapTable[j].javaKey;
3183             }else{
3184                 break;
3185             }
3186         }
3187     }
3188 
3189     return java_awt_event_KeyEvent_VK_UNDEFINED;
3190 }
3191 
3192 BOOL AwtComponent::IsNavigationKey(UINT wkey) {
3193     switch (wkey) {
3194       case VK_END:
3195       case VK_PRIOR:  // PageUp
3196       case VK_NEXT:  // PageDown
3197       case VK_HOME:
3198       case VK_LEFT:
3199       case VK_UP:
3200       case VK_RIGHT:
3201       case VK_DOWN:
3202           return TRUE;
3203     }
3204     return FALSE;
3205 }
3206 
3207 // determine if a key is a numpad key (distinguishes the numpad
3208 // arrow keys from the non-numpad arrow keys, for example).
3209 BOOL AwtComponent::IsNumPadKey(UINT vkey, BOOL extended)
3210 {
3211     // Note: scancodes are the same for the numpad arrow keys and
3212     // the non-numpad arrow keys (also for PageUp, etc.).
3213     // The scancodes for the numpad divide and the non-numpad slash
3214     // are the same, but the wparams are different
3215 
3216     DTRACE_PRINTLN3("AwtComponent::IsNumPadKey  vkey = %d = 0x%x  extended = %d",
3217       vkey, vkey, extended);
3218 
3219     switch (vkey) {
3220       case VK_CLEAR:  // numpad 5 with numlock off
3221       case VK_NUMPAD0:
3222       case VK_NUMPAD1:
3223       case VK_NUMPAD2:
3224       case VK_NUMPAD3:
3225       case VK_NUMPAD4:
3226       case VK_NUMPAD5:
3227       case VK_NUMPAD6:
3228       case VK_NUMPAD7:
3229       case VK_NUMPAD8:
3230       case VK_NUMPAD9:
3231       case VK_MULTIPLY:
3232       case VK_ADD:
3233       case VK_SEPARATOR:  // numpad ,  not on US kbds
3234       case VK_SUBTRACT:
3235       case VK_DECIMAL:
3236       case VK_DIVIDE:
3237       case VK_NUMLOCK:
3238         return TRUE;
3239         break;
3240       case VK_END:
3241       case VK_PRIOR:  // PageUp
3242       case VK_NEXT:  // PageDown
3243       case VK_HOME:
3244       case VK_LEFT:
3245       case VK_UP:
3246       case VK_RIGHT:
3247       case VK_DOWN:
3248       case VK_INSERT:
3249       case VK_DELETE:
3250         // extended if non-numpad
3251         return (!extended);
3252         break;
3253       case VK_RETURN:  // extended if on numpad
3254         return (extended);
3255         break;
3256       default:
3257         break;
3258     }
3259 
3260     return FALSE;
3261 }
3262 static void
3263 resetKbdState( BYTE kstate[256]) {
3264     BYTE tmpState[256];
3265     WCHAR wc[2];
3266     memmove(tmpState, kstate, sizeof(kstate));
3267     tmpState[VK_SHIFT] = 0;
3268     tmpState[VK_CONTROL] = 0;
3269     tmpState[VK_MENU] = 0;
3270 
3271     ::ToUnicodeEx(VK_SPACE,::MapVirtualKey(VK_SPACE, 0), tmpState, wc, 2, 0,  GetKeyboardLayout(0));
3272 }
3273 
3274 // XXX in the update releases this is an addition to the unchanged existing code
3275 // After the call, a table will have a unicode associated with a windows virtual keycode
3276 // sans modifiers. With some further simplification, one can
3277 // derive java keycode from it, and anyway we will pass this unicode value
3278 // all the way up in a comment to a KeyEvent.
3279 void
3280 AwtComponent::BuildPrimaryDynamicTable() {
3281     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3282     // XXX: how about that?
3283     //CriticalSection::Lock l(GetLock());
3284     //if (GetPeer(env) == NULL) {
3285     //    /* event received during termination. */
3286     //    return;
3287     //}
3288 
3289     HKL hkl = GetKeyboardLayout();
3290     UINT sc = 0;
3291     BYTE kbdState[AwtToolkit::KB_STATE_SIZE];
3292     memset(kbdState, 0, sizeof (kbdState));
3293 
3294     // Use JNI call to obtain java key code. We should keep a list
3295     // of currently available keycodes in a single place.
3296     static jclass extKeyCodesCls;
3297     if( extKeyCodesCls == NULL) {
3298         jclass extKeyCodesClsLocal = env->FindClass("sun/awt/ExtendedKeyCodes");
3299         DASSERT(extKeyCodesClsLocal);
3300         CHECK_NULL(extKeyCodesClsLocal);
3301         extKeyCodesCls = (jclass)env->NewGlobalRef(extKeyCodesClsLocal);
3302         env->DeleteLocalRef(extKeyCodesClsLocal);
3303     }
3304     static jmethodID getExtendedKeyCodeForChar;
3305     if (getExtendedKeyCodeForChar == NULL) {
3306         getExtendedKeyCodeForChar =
3307                   env->GetStaticMethodID(extKeyCodesCls, "getExtendedKeyCodeForChar", "(I)I");
3308         DASSERT(getExtendedKeyCodeForChar);
3309         CHECK_NULL(getExtendedKeyCodeForChar);
3310     }
3311     jint extJKC; //extended Java key code
3312 
3313     for (UINT i = 0; i < 256; i++) {
3314         dynPrimaryKeymap[i].wkey = i;
3315         dynPrimaryKeymap[i].jkey = java_awt_event_KeyEvent_VK_UNDEFINED;
3316         dynPrimaryKeymap[i].unicode = 0;
3317 
3318         if ((sc = MapVirtualKey (i, 0)) == 0) {
3319             dynPrimaryKeymap[i].scancode = 0;
3320             continue;
3321         }
3322         dynPrimaryKeymap[i].scancode = sc;
3323 
3324         // XXX process cases like VK_SHIFT etc.
3325         kbdState[i] = 0x80; // "key pressed".
3326         WCHAR wc[16];
3327         int k = ::ToUnicodeEx(i, sc, kbdState, wc, 16, 0, hkl);
3328         if (k == 1) {
3329             // unicode
3330             dynPrimaryKeymap[i].unicode = wc[0];
3331             if (dynPrimaryKeymap[i].jkey == java_awt_event_KeyEvent_VK_UNDEFINED) {
3332             // Convert unicode to java keycode.
3333                 //dynPrimaryKeymap[i].jkey = ((UINT)(wc[0]) + 0x01000000);
3334                 //
3335                 //XXX If this key in on the keypad, we should force a special value equal to
3336                 //XXX an old java keycode: but how to say if it is a keypad key?
3337                 //XXX We'll do it in WmKeyUp/Down.
3338                 extJKC = env->CallStaticIntMethod(extKeyCodesCls,
3339                                                   getExtendedKeyCodeForChar, (jint)(wc[0]));
3340                 dynPrimaryKeymap[i].jkey = extJKC;
3341             }
3342         }else if (k == -1) {
3343             // dead key: use charToDeadVKTable
3344             dynPrimaryKeymap[i].unicode = wc[0];
3345             resetKbdState( kbdState );
3346             for (const CharToVKEntry *map = charToDeadVKTable;  map->c != 0;  ++map) {
3347                 if (wc[0] == map->c) {
3348                     dynPrimaryKeymap[i].jkey = map->javaKey;
3349                     break;
3350                 }
3351             }
3352         } else if (k == 0) {
3353             // reset
3354             resetKbdState( kbdState );
3355         }else {
3356             // k > 1: this key does generate multiple characters. Ignore it.
3357             // An example: Arabic Lam and Alef ligature.
3358             // There will be no extended keycode and thus shortcuts for this  key.
3359             // XXX shouldn't we reset the kbd state?
3360 #ifdef DEBUG
3361             DTRACE_PRINTLN2("wkey 0x%02X (%d)", i,i);
3362 #endif
3363         }
3364         kbdState[i] = 0; // "key unpressed"
3365     }
3366 }
3367 void
3368 AwtComponent::UpdateDynPrimaryKeymap(UINT wkey, UINT jkeyLegacy, jint keyLocation, UINT modifiers)
3369 {
3370     if( wkey && wkey < 256 ) {
3371         if(keyLocation == java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD) {
3372             // At the creation time,
3373             // dynPrimaryKeymap cannot distinguish between e.g. "/" and "NumPad /"
3374             dynPrimaryKeymap[wkey].jkey = jkeyLegacy;
3375         }
3376         if(dynPrimaryKeymap[wkey].jkey ==  java_awt_event_KeyEvent_VK_UNDEFINED) {
3377             // E.g. it is non-unicode key
3378             dynPrimaryKeymap[wkey].jkey = jkeyLegacy;
3379         }
3380     }
3381 }
3382 
3383 UINT AwtComponent::WindowsKeyToJavaChar(UINT wkey, UINT modifiers, TransOps ops, BOOL &isDeadKey)
3384 {
3385     static Hashtable transTable("VKEY translations");
3386     static Hashtable deadKeyFlagTable("Dead Key Flags");
3387     isDeadKey = FALSE;
3388 
3389     // Try to translate using last saved translation
3390     if (ops == LOAD) {
3391        void* deadKeyFlag = deadKeyFlagTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
3392        void* value = transTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
3393        if (value != NULL) {
3394            isDeadKey = static_cast<BOOL>(reinterpret_cast<INT_PTR>(deadKeyFlag));
3395            return static_cast<UINT>(reinterpret_cast<INT_PTR>(value));
3396        }
3397     }
3398 
3399     // If the windows key is a return, wkey will equal 13 ('\r')
3400     // In this case, we want to return 10 ('\n')
3401     // Since ToAscii would convert VK_RETURN to '\r', we need
3402     // to have a special case here.
3403     if (wkey == VK_RETURN)
3404         return '\n';
3405 
3406     // high order bit in keyboardState indicates whether the key is down
3407     static const BYTE KEY_STATE_DOWN = 0x80;
3408     BYTE    keyboardState[AwtToolkit::KB_STATE_SIZE];
3409     AwtToolkit::GetKeyboardState(keyboardState);
3410 
3411     // apply modifiers to keyboard state if necessary
3412     if (modifiers) {
3413         BOOL shiftIsDown = modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK;
3414         BOOL altIsDown = modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK;
3415         BOOL ctrlIsDown = modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK;
3416 
3417         // Windows treats AltGr as Ctrl+Alt
3418         if (modifiers & java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK) {
3419             altIsDown = TRUE;
3420             ctrlIsDown = TRUE;
3421         }
3422 
3423         if (shiftIsDown) {
3424             keyboardState[VK_SHIFT] |= KEY_STATE_DOWN;
3425         }
3426 
3427         // fix for 4623376,4737679,4501485,4740906,4708221 (4173679/4122715)
3428         // Here we try to resolve a conflict with ::ToAsciiEx's translating
3429         // ALT+number key combinations. kdm@sarc.spb.su
3430         // yan: Do it for navigation keys only, otherwise some AltGr deadkeys fail.
3431         if( IsNavigationKey(wkey) ) {
3432             keyboardState[VK_MENU] &= ~KEY_STATE_DOWN;
3433         }
3434 
3435         if (ctrlIsDown)
3436         {
3437             if (altIsDown) {
3438                 // bugid 4215009: don't mess with AltGr == Ctrl + Alt
3439                 keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
3440             }
3441             else {
3442                 // bugid 4098210: old event model doesn't have KEY_TYPED
3443                 // events, so try to provide a meaningful character for
3444                 // Ctrl+<key>.  Take Ctrl into account only when we know
3445                 // that Ctrl+<key> will be an ASCII control.  Ignore by
3446                 // default.
3447                 keyboardState[VK_CONTROL] &= ~KEY_STATE_DOWN;
3448 
3449                 // Letters have Ctrl+<letter> counterparts.  According to
3450                 // <winuser.h> VK_A through VK_Z are the same as ASCII
3451                 // 'A' through 'Z'.
3452                 if (wkey >= 'A' && wkey <= 'Z') {
3453                     keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
3454                 }
3455                 else {
3456                     // Non-letter controls 033 to 037 are:
3457                     // ^[ (ESC), ^\ (FS), ^] (GS), ^^ (RS), and ^_ (US)
3458 
3459                     // Shift state bits returned by ::VkKeyScan in HIBYTE
3460                     static const UINT _VKS_SHIFT_MASK = 0x01;
3461                     static const UINT _VKS_CTRL_MASK = 0x02;
3462                     static const UINT _VKS_ALT_MASK = 0x04;
3463 
3464                     // Check to see whether there is a meaningful translation
3465                     TCHAR ch;
3466                     short vk;
3467                     for (ch = _T('\033'); ch < _T('\040'); ch++) {
3468                         vk = ::VkKeyScan(ch);
3469                         if (wkey == LOBYTE(vk)) {
3470                             UINT shiftState = HIBYTE(vk);
3471                             if ((shiftState & _VKS_CTRL_MASK) ||
3472                                 (!(shiftState & _VKS_SHIFT_MASK)
3473                                 == !shiftIsDown))
3474                             {
3475                                 keyboardState[VK_CONTROL] |= KEY_STATE_DOWN;
3476                             }
3477                             break;
3478                         }
3479                     }
3480                 }
3481             } // ctrlIsDown && altIsDown
3482         } // ctrlIsDown
3483     } // modifiers
3484 
3485     // instead of creating our own conversion tables, I'll let Win32
3486     // convert the character for me.
3487     WORD wChar[2];
3488     UINT scancode = ::MapVirtualKey(wkey, 0);
3489     int converted = ::ToUnicodeEx(wkey, scancode, keyboardState,
3490                                   wChar, 2, 0, GetKeyboardLayout());
3491 
3492     UINT translation;
3493     BOOL deadKeyFlag = (converted == 2);
3494 
3495     // Dead Key
3496     if (converted < 0) {
3497         translation = java_awt_event_KeyEvent_CHAR_UNDEFINED;
3498     } else
3499     // No translation available -- try known conversions or else punt.
3500     if (converted == 0) {
3501         if (wkey == VK_DELETE) {
3502             translation = '\177';
3503         } else
3504         if (wkey >= VK_NUMPAD0 && wkey <= VK_NUMPAD9) {
3505             translation = '0' + wkey - VK_NUMPAD0;
3506         } else {
3507             translation = java_awt_event_KeyEvent_CHAR_UNDEFINED;
3508         }
3509     } else
3510     // the caller expects a Unicode character.
3511     if (converted > 0) {
3512         translation = wChar[0];
3513     }
3514     if (ops == SAVE) {
3515         transTable.put(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)),
3516                        reinterpret_cast<void*>(static_cast<INT_PTR>(translation)));
3517         if (deadKeyFlag) {
3518             deadKeyFlagTable.put(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)),
3519                          reinterpret_cast<void*>(static_cast<INT_PTR>(deadKeyFlag)));
3520         } else {
3521             deadKeyFlagTable.remove(reinterpret_cast<void*>(static_cast<INT_PTR>(wkey)));
3522         }
3523     }
3524 
3525     isDeadKey = deadKeyFlag;
3526     return translation;
3527 }
3528 
3529 MsgRouting AwtComponent::WmKeyDown(UINT wkey, UINT repCnt,
3530                                    UINT flags, BOOL system)
3531 {
3532     // VK_PROCESSKEY is a special value which means
3533     //          "Current IME wants to consume this KeyEvent"
3534     // Real key code is saved by IMM32.DLL and can be retrieved by
3535     // calling ImmGetVirtualKey();
3536     if (wkey == VK_PROCESSKEY) {
3537         return mrDoDefault;
3538     }
3539     MSG msg;
3540     InitMessage(&msg, (system ? WM_SYSKEYDOWN : WM_KEYDOWN),
3541                              wkey, MAKELPARAM(repCnt, flags));
3542 
3543     UINT modifiers = GetJavaModifiers();
3544     jint keyLocation = GetKeyLocation(wkey, flags);
3545     BOOL isDeadKey = FALSE;
3546     UINT character = WindowsKeyToJavaChar(wkey, modifiers, SAVE, isDeadKey);
3547     UINT jkey = WindowsKeyToJavaKey(wkey, modifiers, character, isDeadKey);
3548     UpdateDynPrimaryKeymap(wkey, jkey, keyLocation, modifiers);
3549 
3550 
3551     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_PRESSED,
3552                              ::JVM_CurrentTimeMillis(NULL, 0), jkey, character,
3553                              modifiers, keyLocation, (jlong)wkey, &msg);
3554 
3555     // bugid 4724007: Windows does not create a WM_CHAR for the Del key
3556     // for some reason, so we need to create the KEY_TYPED event on the
3557     // WM_KEYDOWN.  Use null msg so the character doesn't get sent back
3558     // to the native window for processing (this event is synthesized
3559     // for Java - we don't want Windows trying to process it).
3560     if (jkey == java_awt_event_KeyEvent_VK_DELETE) {
3561         SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
3562                                  ::JVM_CurrentTimeMillis(NULL, 0),
3563                                  java_awt_event_KeyEvent_VK_UNDEFINED,
3564                                  character, modifiers,
3565                                  java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0);
3566     }
3567 
3568     return mrConsume;
3569 }
3570 
3571 MsgRouting AwtComponent::WmKeyUp(UINT wkey, UINT repCnt,
3572                                  UINT flags, BOOL system)
3573 {
3574 
3575     // VK_PROCESSKEY is a special value which means
3576     //          "Current IME wants to consume this KeyEvent"
3577     // Real key code is saved by IMM32.DLL and can be retrieved by
3578     // calling ImmGetVirtualKey();
3579     if (wkey == VK_PROCESSKEY) {
3580         return mrDoDefault;
3581     }
3582     MSG msg;
3583     InitMessage(&msg, (system ? WM_SYSKEYUP : WM_KEYUP),
3584                              wkey, MAKELPARAM(repCnt, flags));
3585 
3586     UINT modifiers = GetJavaModifiers();
3587     jint keyLocation = GetKeyLocation(wkey, flags);
3588     BOOL isDeadKey = FALSE;
3589     UINT character = WindowsKeyToJavaChar(wkey, modifiers, LOAD, isDeadKey);
3590     UINT jkey = WindowsKeyToJavaKey(wkey, modifiers, character, isDeadKey);
3591     UpdateDynPrimaryKeymap(wkey, jkey, keyLocation, modifiers);
3592 
3593     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_RELEASED,
3594                              ::JVM_CurrentTimeMillis(NULL, 0), jkey, character,
3595                              modifiers, keyLocation, (jlong)wkey, &msg);
3596     return mrConsume;
3597 }
3598 
3599 MsgRouting AwtComponent::WmInputLangChange(UINT charset, HKL hKeyboardLayout)
3600 {
3601     // Normally we would be able to use charset and TranslateCharSetInfo
3602     // to get a code page that should be associated with this keyboard
3603     // layout change. However, there seems to be an NT 4.0 bug associated
3604     // with the WM_INPUTLANGCHANGE message, which makes the charset parameter
3605     // unreliable, especially on Asian systems. Our workaround uses the
3606     // keyboard layout handle instead.
3607     m_hkl = hKeyboardLayout;
3608     m_idLang = LOWORD(hKeyboardLayout); // lower word of HKL is LANGID
3609     m_CodePage = LangToCodePage(m_idLang);
3610     BuildDynamicKeyMapTable();  // compute new mappings for VK_OEM
3611     BuildPrimaryDynamicTable();
3612     return mrConsume;           // do not propagate to children
3613 }
3614 
3615 // Convert Language ID to CodePage
3616 UINT AwtComponent::LangToCodePage(LANGID idLang)
3617 {
3618     TCHAR strCodePage[MAX_ACP_STR_LEN];
3619     // use the LANGID to create a LCID
3620     LCID idLocale = MAKELCID(idLang, SORT_DEFAULT);
3621     // get the ANSI code page associated with this locale
3622     if (GetLocaleInfo(idLocale, LOCALE_IDEFAULTANSICODEPAGE, strCodePage, sizeof(strCodePage)/sizeof(TCHAR)) > 0 )
3623         return _ttoi(strCodePage);
3624     else
3625         return GetACP();
3626 }
3627 
3628 
3629 MsgRouting AwtComponent::WmIMEChar(UINT character, UINT repCnt, UINT flags, BOOL system)
3630 {
3631     // We will simply create Java events here.
3632     WCHAR unicodeChar = character;
3633     MSG msg;
3634     InitMessage(&msg, WM_IME_CHAR, character,
3635                               MAKELPARAM(repCnt, flags));
3636 
3637     jint modifiers = GetJavaModifiers();
3638     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
3639                              ::JVM_CurrentTimeMillis(NULL, 0),
3640                              java_awt_event_KeyEvent_VK_UNDEFINED,
3641                              unicodeChar, modifiers,
3642                              java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0,
3643                              &msg);
3644     return mrConsume;
3645 }
3646 
3647 MsgRouting AwtComponent::WmChar(UINT character, UINT repCnt, UINT flags,
3648                                 BOOL system)
3649 {
3650     // Will only get WmChar messages with DBCS if we create them for
3651     // an Edit class in the WmForwardChar method. These synthesized
3652     // DBCS chars are ok to pass on directly to the default window
3653     // procedure. They've already been filtered through the Java key
3654     // event queue. We will never get the trail byte since the edit
3655     // class will PeekMessage(&msg, hwnd, WM_CHAR, WM_CHAR,
3656     // PM_REMOVE).  I would like to be able to pass this character off
3657     // via WM_AWT_FORWARD_BYTE, but the Edit classes don't seem to
3658     // like that.
3659 
3660     // We will simply create Java events here.
3661     UINT message = system ? WM_SYSCHAR : WM_CHAR;
3662 
3663     // The Alt modifier is reported in the 29th bit of the lParam,
3664     // i.e., it is the 13th bit of `flags' (which is HIWORD(lParam)).
3665     bool alt_is_down = (flags & (1<<13)) != 0;
3666 
3667     // Fix for bug 4141621, corrected by fix for bug 6223726: Alt+space doesn't invoke system menu
3668     // We should not pass this particular combination to Java.
3669 
3670     if (system && alt_is_down) {
3671         if (character == VK_SPACE) {
3672             return mrDoDefault;
3673         }
3674     }
3675 
3676     // If this is a WM_CHAR (non-system) message, then the Alt flag
3677     // indicates that the character was typed using an AltGr key
3678     // (which Windows treats as Ctrl+Alt), so in this case we do NOT
3679     // pass the Ctrl and Alt modifiers to Java, but instead we
3680     // replace them with Java's AltGraph modifier.  Note: the AltGraph
3681     // modifier does not exist in 1.1.x releases.
3682     jint modifiers = GetJavaModifiers();
3683     if (!system && alt_is_down) {
3684         // character typed with AltGraph
3685         modifiers &= ~(java_awt_event_InputEvent_ALT_DOWN_MASK
3686                        | java_awt_event_InputEvent_CTRL_DOWN_MASK);
3687         modifiers |= java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK;
3688     }
3689 
3690     WCHAR unicodeChar = character;
3691 
3692     // Kludge: Combine pending single byte with this char for some Chinese IMEs
3693     if (m_PendingLeadByte != 0) {
3694         character = (m_PendingLeadByte & 0x00ff) | (character << 8);
3695         m_PendingLeadByte = 0;
3696         ::MultiByteToWideChar(GetCodePage(), 0, (CHAR*)&character, 2,
3697                           &unicodeChar, 1);
3698     }
3699 
3700     if (unicodeChar == VK_RETURN) {
3701         // Enter key generates \r in windows, but \n is required in java
3702         unicodeChar = java_awt_event_KeyEvent_VK_ENTER;
3703     }
3704     MSG msg;
3705     InitMessage(&msg, message, character,
3706                               MAKELPARAM(repCnt, flags));
3707     SendKeyEventToFocusOwner(java_awt_event_KeyEvent_KEY_TYPED,
3708                              ::JVM_CurrentTimeMillis(NULL, 0),
3709                              java_awt_event_KeyEvent_VK_UNDEFINED,
3710                              unicodeChar, modifiers,
3711                              java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN, (jlong)0,
3712                              &msg);
3713     return mrConsume;
3714 }
3715 
3716 MsgRouting AwtComponent::WmForwardChar(WCHAR character, LPARAM lParam,
3717                                        BOOL synthetic)
3718 {
3719     // just post WM_CHAR with unicode key value
3720     DefWindowProc(WM_CHAR, (WPARAM)character, lParam);
3721     return mrConsume;
3722 }
3723 
3724 MsgRouting AwtComponent::WmPaste()
3725 {
3726     return mrDoDefault;
3727 }
3728 
3729 // support IME Composition messages
3730 void AwtComponent::SetCompositionWindow(RECT& r)
3731 {
3732     HWND hwnd = ImmGetHWnd();
3733     HIMC hIMC = ImmGetContext(hwnd);
3734     if (hIMC == NULL) {
3735         return;
3736     }
3737     COMPOSITIONFORM cf = {CFS_DEFAULT, {0, 0}, {0, 0, 0, 0}};
3738     ImmSetCompositionWindow(hIMC, &cf);
3739     ImmReleaseContext(hwnd, hIMC);
3740 }
3741 
3742 void AwtComponent::OpenCandidateWindow(int x, int y)
3743 {
3744     UINT bits = 1;
3745     POINT p = {0, 0}; // upper left corner of the client area
3746     HWND hWnd = GetHWnd();
3747     HWND hTop = GetTopLevelParentForWindow(hWnd);
3748     ::ClientToScreen(hTop, &p);
3749 
3750     for (int iCandType=0; iCandType<32; iCandType++, bits<<=1) {
3751         if ( m_bitsCandType & bits )
3752             SetCandidateWindow(iCandType, x - p.x, y - p.y);
3753     }
3754     if (m_bitsCandType != 0) {
3755         // REMIND: is there any chance GetProxyFocusOwner() returns NULL here?
3756         ::DefWindowProc(ImmGetHWnd(),
3757                         WM_IME_NOTIFY, IMN_OPENCANDIDATE, m_bitsCandType);
3758     }
3759 }
3760 
3761 void AwtComponent::SetCandidateWindow(int iCandType, int x, int y)
3762 {
3763     HWND hwnd = ImmGetHWnd();
3764     HIMC hIMC = ImmGetContext(hwnd);
3765     CANDIDATEFORM cf;
3766     cf.dwIndex = iCandType;
3767     cf.dwStyle = CFS_CANDIDATEPOS;
3768     cf.ptCurrentPos.x = x;
3769     cf.ptCurrentPos.y = y;
3770 
3771     ImmSetCandidateWindow(hIMC, &cf);
3772     ImmReleaseContext(hwnd, hIMC);
3773 }
3774 
3775 MsgRouting AwtComponent::WmImeSetContext(BOOL fSet, LPARAM *lplParam)
3776 {
3777     // If the Windows input context is disabled, do not let Windows
3778     // display any UIs.
3779     HWND hwnd = ImmGetHWnd();
3780     HIMC hIMC = ImmGetContext(hwnd);
3781     if (hIMC == NULL) {
3782         *lplParam = 0;
3783         return mrDoDefault;
3784     }
3785     ImmReleaseContext(hwnd, hIMC);
3786 
3787     if (fSet) {
3788         LPARAM lParam = *lplParam;
3789         if (!m_useNativeCompWindow) {
3790             // stop to draw native composing window.
3791             *lplParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
3792         }
3793     }
3794     return mrDoDefault;
3795 }
3796 
3797 MsgRouting AwtComponent::WmImeNotify(WPARAM subMsg, LPARAM bitsCandType)
3798 {
3799     if (!m_useNativeCompWindow && subMsg == IMN_OPENCANDIDATE) {
3800         m_bitsCandType = bitsCandType;
3801         InquireCandidatePosition();
3802         return mrConsume;
3803     }
3804     return mrDoDefault;
3805 }
3806 
3807 MsgRouting AwtComponent::WmImeStartComposition()
3808 {
3809     if (m_useNativeCompWindow) {
3810         RECT rc;
3811         ::GetClientRect(GetHWnd(), &rc);
3812         SetCompositionWindow(rc);
3813         return mrDoDefault;
3814     } else
3815         return mrConsume;
3816 }
3817 
3818 MsgRouting AwtComponent::WmImeEndComposition()
3819 {
3820     if (m_useNativeCompWindow)   return mrDoDefault;
3821 
3822     SendInputMethodEvent(
3823         java_awt_event_InputMethodEvent_INPUT_METHOD_TEXT_CHANGED,
3824         NULL, 0, NULL, NULL, 0, NULL, NULL, 0, 0, 0 );
3825     return mrConsume;
3826 }
3827 
3828 MsgRouting AwtComponent::WmImeComposition(WORD wChar, LPARAM flags)
3829 {
3830     if (m_useNativeCompWindow)   return mrDoDefault;
3831 
3832     int*      bndClauseW = NULL;
3833     jstring*  readingClauseW = NULL;
3834     int*      bndAttrW = NULL;
3835     BYTE*     valAttrW = NULL;
3836     int       cClauseW = 0;
3837     AwtInputTextInfor* textInfor = NULL;
3838 
3839     try {
3840         HWND hwnd = ImmGetHWnd();
3841         HIMC hIMC = ImmGetContext(hwnd);
3842         DASSERT(hIMC!=0);
3843 
3844         textInfor = new AwtInputTextInfor;
3845         textInfor->GetContextData(hIMC, flags);
3846         ImmReleaseContext(hwnd, hIMC);
3847 
3848         jstring jtextString = textInfor->GetText();
3849         /* The conditions to send the input method event to AWT EDT are:
3850            1. Whenever there is a composition message sent regarding whether
3851            the composition text is NULL or not. See details at bug 6222692.
3852            2. When there is a committed message sent, in which case, we have to
3853            check whether the committed string is NULL or not. If the committed string
3854            is NULL, there is no need to send any input method event.
3855            (Minor note: 'jtextString' returned is the merged string in the case of
3856            partial commit.)
3857         */
3858         if ((flags & GCS_RESULTSTR && jtextString != NULL) ||
3859             (flags & GCS_COMPSTR)) {
3860             int       cursorPosW = textInfor->GetCursorPosition();
3861             // In order not to delete the readingClauseW in the catch clause,
3862             // calling GetAttributeInfor before GetClauseInfor.
3863             int       cAttrW = textInfor->GetAttributeInfor(bndAttrW, valAttrW);
3864             cClauseW = textInfor->GetClauseInfor(bndClauseW, readingClauseW);
3865 
3866             /* Send INPUT_METHOD_TEXT_CHANGED event to the WInputMethod which in turn sends
3867                the event to AWT EDT.
3868 
3869                The last two paremeters are set to equal since we don't have recommendations for
3870                the visible position within the current composed text. See details at
3871                java.awt.event.InputMethodEvent.
3872             */
3873             SendInputMethodEvent(java_awt_event_InputMethodEvent_INPUT_METHOD_TEXT_CHANGED,
3874                                  jtextString,
3875                                  cClauseW, bndClauseW, readingClauseW,
3876                                  cAttrW, bndAttrW, valAttrW,
3877                                  textInfor->GetCommittedTextLength(),
3878                                  cursorPosW, cursorPosW);
3879         }
3880     } catch (...) {
3881         // since GetClauseInfor and GetAttributeInfor could throw exception, we have to release
3882         // the pointer here.
3883         delete [] bndClauseW;
3884         delete [] readingClauseW;
3885         delete [] bndAttrW;
3886         delete [] valAttrW;
3887         throw;
3888     }
3889 
3890     /* Free the storage allocated. Since jtextString won't be passed from threads
3891      *  to threads, we just use the local ref and it will be deleted within the destructor
3892      *  of AwtInputTextInfor object.
3893      */
3894     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3895     if (cClauseW && readingClauseW) {
3896         for (int i = 0; i < cClauseW; i ++) {
3897             if (readingClauseW[i]) {
3898                 env->DeleteLocalRef(readingClauseW[i]);
3899             }
3900         }
3901     }
3902     delete [] bndClauseW;
3903     delete [] readingClauseW;
3904     delete [] bndAttrW;
3905     delete [] valAttrW;
3906     delete textInfor;
3907 
3908     return mrConsume;
3909 }
3910 
3911 //
3912 // generate and post InputMethodEvent
3913 //
3914 void AwtComponent::SendInputMethodEvent(jint id, jstring text,
3915                                         int cClause, int* rgClauseBoundary, jstring* rgClauseReading,
3916                                         int cAttrBlock, int* rgAttrBoundary, BYTE *rgAttrValue,
3917                                         int commitedTextLength, int caretPos, int visiblePos)
3918 {
3919     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
3920 
3921     // assumption for array type casting
3922     DASSERT(sizeof(int)==sizeof(jint));
3923     DASSERT(sizeof(BYTE)==sizeof(jbyte));
3924 
3925     // caluse information
3926     jintArray clauseBoundary = NULL;
3927     jobjectArray clauseReading = NULL;
3928     if (cClause && rgClauseBoundary && rgClauseReading) {
3929         // convert clause boundary offset array to java array
3930         clauseBoundary = env->NewIntArray(cClause+1);
3931         DASSERT(clauseBoundary);
3932         CHECK_NULL(clauseBoundary);
3933         env->SetIntArrayRegion(clauseBoundary, 0, cClause+1, (jint *)rgClauseBoundary);
3934         DASSERT(!safe_ExceptionOccurred(env));
3935 
3936         // convert clause reading string array to java array
3937         jclass stringCls = JNU_ClassString(env);
3938         DASSERT(stringCls);
3939         CHECK_NULL(stringCls);
3940         clauseReading = env->NewObjectArray(cClause, stringCls, NULL);
3941         DASSERT(clauseReading);
3942         CHECK_NULL(clauseReading);
3943         for (int i=0; i<cClause; i++)   env->SetObjectArrayElement(clauseReading, i, rgClauseReading[i]);
3944         DASSERT(!safe_ExceptionOccurred(env));
3945     }
3946 
3947 
3948     // attrubute value definition in WInputMethod.java must be equal to that in IMM.H
3949     DASSERT(ATTR_INPUT==sun_awt_windows_WInputMethod_ATTR_INPUT);
3950     DASSERT(ATTR_TARGET_CONVERTED==sun_awt_windows_WInputMethod_ATTR_TARGET_CONVERTED);
3951     DASSERT(ATTR_CONVERTED==sun_awt_windows_WInputMethod_ATTR_CONVERTED);
3952     DASSERT(ATTR_TARGET_NOTCONVERTED==sun_awt_windows_WInputMethod_ATTR_TARGET_NOTCONVERTED);
3953     DASSERT(ATTR_INPUT_ERROR==sun_awt_windows_WInputMethod_ATTR_INPUT_ERROR);
3954 
3955     // attribute information
3956     jintArray attrBoundary = NULL;
3957     jbyteArray attrValue = NULL;
3958     if (cAttrBlock && rgAttrBoundary && rgAttrValue) {
3959         // convert attribute boundary offset array to java array
3960         attrBoundary = env->NewIntArray(cAttrBlock+1);
3961         DASSERT(attrBoundary);
3962         CHECK_NULL(attrBoundary);
3963         env->SetIntArrayRegion(attrBoundary, 0, cAttrBlock+1, (jint *)rgAttrBoundary);
3964         DASSERT(!safe_ExceptionOccurred(env));
3965 
3966         // convert attribute value byte array to java array
3967         attrValue = env->NewByteArray(cAttrBlock);
3968         DASSERT(attrValue);
3969         CHECK_NULL(attrValue);
3970         env->SetByteArrayRegion(attrValue, 0, cAttrBlock, (jbyte *)rgAttrValue);
3971         DASSERT(!safe_ExceptionOccurred(env));
3972     }
3973 
3974 
3975     // get global reference of WInputMethod class (run only once)
3976     static jclass wInputMethodCls = NULL;
3977     if (wInputMethodCls == NULL) {
3978         jclass wInputMethodClsLocal = env->FindClass("sun/awt/windows/WInputMethod");
3979         DASSERT(wInputMethodClsLocal);
3980         CHECK_NULL(wInputMethodClsLocal);
3981         wInputMethodCls = (jclass)env->NewGlobalRef(wInputMethodClsLocal);
3982         env->DeleteLocalRef(wInputMethodClsLocal);
3983     }
3984 
3985     // get method ID of sendInputMethodEvent() (run only once)
3986     static jmethodID sendIMEventMid = 0;
3987     if (sendIMEventMid == 0) {
3988         sendIMEventMid =  env->GetMethodID(wInputMethodCls, "sendInputMethodEvent",
3989                                            "(IJLjava/lang/String;[I[Ljava/lang/String;[I[BIII)V");
3990         DASSERT(sendIMEventMid);
3991         CHECK_NULL(sendIMEventMid);
3992     }
3993 
3994     // call m_InputMethod.sendInputMethod()
3995     env->CallVoidMethod(m_InputMethod, sendIMEventMid, id, ::JVM_CurrentTimeMillis(NULL, 0),
3996                         text, clauseBoundary, clauseReading, attrBoundary,
3997                         attrValue, commitedTextLength, caretPos, visiblePos);
3998     if (safe_ExceptionOccurred(env))   env->ExceptionDescribe();
3999     DASSERT(!safe_ExceptionOccurred(env));
4000 
4001 }
4002 
4003 
4004 
4005 //
4006 // Inquires candidate position according to the composed text
4007 //
4008 void AwtComponent::InquireCandidatePosition()
4009 {
4010     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4011 
4012     // get global reference of WInputMethod class (run only once)
4013     static jclass wInputMethodCls = NULL;
4014     if (wInputMethodCls == NULL) {
4015         jclass wInputMethodClsLocal = env->FindClass("sun/awt/windows/WInputMethod");
4016         DASSERT(wInputMethodClsLocal);
4017         CHECK_NULL(wInputMethodClsLocal);
4018         wInputMethodCls = (jclass)env->NewGlobalRef(wInputMethodClsLocal);
4019         env->DeleteLocalRef(wInputMethodClsLocal);
4020     }
4021 
4022     // get method ID of sendInputMethodEvent() (run only once)
4023     static jmethodID inqCandPosMid = 0;
4024     if (inqCandPosMid == 0) {
4025         inqCandPosMid =  env->GetMethodID(wInputMethodCls, "inquireCandidatePosition", "()V");
4026         DASSERT(!safe_ExceptionOccurred(env));
4027         DASSERT(inqCandPosMid);
4028         CHECK_NULL(inqCandPosMid);
4029     }
4030 
4031     // call m_InputMethod.sendInputMethod()
4032     jobject candPos = env->CallObjectMethod(m_InputMethod, inqCandPosMid);
4033     DASSERT(!safe_ExceptionOccurred(env));
4034 }
4035 
4036 HWND AwtComponent::ImmGetHWnd()
4037 {
4038     HWND proxy = GetProxyFocusOwner();
4039     return (proxy != NULL) ? proxy : GetHWnd();
4040 }
4041 
4042 HIMC AwtComponent::ImmAssociateContext(HIMC himc)
4043 {
4044     return ::ImmAssociateContext(ImmGetHWnd(), himc);
4045 }
4046 
4047 HWND AwtComponent::GetProxyFocusOwner()
4048 {
4049     AwtWindow *window = GetContainer();
4050     if (window != 0) {
4051         AwtFrame *owner = window->GetOwningFrameOrDialog();
4052         if (owner != 0) {
4053             return owner->GetProxyFocusOwner();
4054         } else if (!window->IsSimpleWindow()) { // isn't an owned simple window
4055             return ((AwtFrame*)window)->GetProxyFocusOwner();
4056         }
4057     }
4058     return (HWND)NULL;
4059 }
4060 
4061 /* Call DefWindowProc for the focus proxy, if any */
4062 void AwtComponent::CallProxyDefWindowProc(UINT message, WPARAM wParam,
4063     LPARAM lParam, LRESULT &retVal, MsgRouting &mr)
4064 {
4065     if (mr != mrConsume)  {
4066         HWND proxy = GetProxyFocusOwner();
4067         if (proxy != NULL && ::IsWindowEnabled(proxy)) {
4068             retVal = ComCtl32Util::GetInstance().DefWindowProc(NULL, proxy, message, wParam, lParam);
4069             mr = mrConsume;
4070         }
4071     }
4072 }
4073 
4074 MsgRouting AwtComponent::WmCommand(UINT id, HWND hWndChild, UINT notifyCode)
4075 {
4076     /* Menu/Accelerator */
4077     if (hWndChild == 0) {
4078         AwtObject* obj = AwtToolkit::GetInstance().LookupCmdID(id);
4079         if (obj == NULL) {
4080             return mrConsume;
4081         }
4082         DASSERT(((AwtMenuItem*)obj)->GetID() == id);
4083         obj->DoCommand();
4084         return mrConsume;
4085     }
4086     /* Child id notification */
4087     else {
4088         AwtComponent* child = AwtComponent::GetComponent(hWndChild);
4089         if (child) {
4090             child->WmNotify(notifyCode);
4091         }
4092     }
4093     return mrDoDefault;
4094 }
4095 
4096 MsgRouting AwtComponent::WmNotify(UINT notifyCode)
4097 {
4098     return mrDoDefault;
4099 }
4100 
4101 MsgRouting AwtComponent::WmCompareItem(UINT ctrlId,
4102                                        COMPAREITEMSTRUCT &compareInfo,
4103                                        LRESULT &result)
4104 {
4105     AwtComponent* child = AwtComponent::GetComponent(compareInfo.hwndItem);
4106     if (child == this) {
4107         /* DoCallback("handleItemDelete", */
4108     }
4109     else if (child) {
4110         return child->WmCompareItem(ctrlId, compareInfo, result);
4111     }
4112     return mrConsume;
4113 }
4114 
4115 MsgRouting AwtComponent::WmDeleteItem(UINT ctrlId,
4116                                       DELETEITEMSTRUCT &deleteInfo)
4117 {
4118     /*
4119      * Workaround for NT 4.0 bug -- if SetWindowPos is called on a AwtList
4120      * window, a WM_DELETEITEM message is sent to its parent with a window
4121      * handle of one of the list's child windows.  The property lookup
4122      * succeeds, but the HWNDs don't match.
4123      */
4124     if (deleteInfo.hwndItem == NULL) {
4125         return mrConsume;
4126     }
4127     AwtComponent* child = (AwtComponent *)AwtComponent::GetComponent(deleteInfo.hwndItem);
4128 
4129     if (child && child->GetHWnd() != deleteInfo.hwndItem) {
4130         return mrConsume;
4131     }
4132 
4133     if (child == this) {
4134         /*DoCallback("handleItemDelete", */
4135     }
4136     else if (child) {
4137         return child->WmDeleteItem(ctrlId, deleteInfo);
4138     }
4139     return mrConsume;
4140 }
4141 
4142 MsgRouting AwtComponent::WmDrawItem(UINT ctrlId, DRAWITEMSTRUCT &drawInfo)
4143 {
4144     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4145 
4146     if (drawInfo.CtlType == ODT_MENU) {
4147         if (drawInfo.itemData != 0) {
4148             AwtMenu* menu = (AwtMenu*)(drawInfo.itemData);
4149             menu->DrawItem(drawInfo);
4150         }
4151     } else {
4152         return OwnerDrawItem(ctrlId, drawInfo);
4153     }
4154     return mrConsume;
4155 }
4156 
4157 MsgRouting AwtComponent::WmMeasureItem(UINT ctrlId,
4158                                        MEASUREITEMSTRUCT &measureInfo)
4159 {
4160     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4161 
4162     if (measureInfo.CtlType == ODT_MENU) {
4163         if (measureInfo.itemData != 0) {
4164             AwtMenu* menu = (AwtMenu*)(measureInfo.itemData);
4165             HDC hDC = ::GetDC(GetHWnd());
4166             /* menu->MeasureItem(env, hDC, measureInfo); */
4167             menu->MeasureItem(hDC, measureInfo);
4168             ::ReleaseDC(GetHWnd(), hDC);
4169         }
4170     } else {
4171         return OwnerMeasureItem(ctrlId, measureInfo);
4172     }
4173     return mrConsume;
4174 }
4175 
4176 MsgRouting AwtComponent::OwnerDrawItem(UINT ctrlId,
4177     DRAWITEMSTRUCT &drawInfo)
4178 {
4179     AwtComponent* child = AwtComponent::GetComponent(drawInfo.hwndItem);
4180     if (child == this) {
4181         /* DoCallback("handleItemDelete", */
4182     } else if (child != NULL) {
4183         return child->WmDrawItem(ctrlId, drawInfo);
4184     }
4185     return mrConsume;
4186 }
4187 
4188 MsgRouting AwtComponent::OwnerMeasureItem(UINT ctrlId,
4189     MEASUREITEMSTRUCT &measureInfo)
4190 {
4191     HWND  hChild = ::GetDlgItem(GetHWnd(), measureInfo.CtlID);
4192     AwtComponent* child = AwtComponent::GetComponent(hChild);
4193     /*
4194      * If the parent cannot find the child's instance from its handle,
4195      * maybe the child is in its creation.  So the child must be searched
4196      * from the list linked before the child's creation.
4197      */
4198     if (child == NULL) {
4199         child = SearchChild((UINT)ctrlId);
4200     }
4201 
4202     if (child == this) {
4203     /* DoCallback("handleItemDelete",  */
4204     }
4205     else if (child) {
4206         return child->WmMeasureItem(ctrlId, measureInfo);
4207     }
4208     return mrConsume;
4209 }
4210 
4211 /* for WmDrawItem method of Label, Button and Checkbox */
4212 void AwtComponent::DrawWindowText(HDC hDC, jobject font, jstring text,
4213                                   int x, int y)
4214 {
4215     int nOldBkMode = ::SetBkMode(hDC,TRANSPARENT);
4216     DASSERT(nOldBkMode != 0);
4217     AwtFont::drawMFString(hDC, font, text, x, y, GetCodePage());
4218     VERIFY(::SetBkMode(hDC,nOldBkMode));
4219 }
4220 
4221 /*
4222  * Draw text in gray (the color being set to COLOR_GRAYTEXT) when the
4223  * component is disabled.  Used only for label, checkbox and button in
4224  * OWNER_DRAW.  It draws the text in emboss.
4225  */
4226 void AwtComponent::DrawGrayText(HDC hDC, jobject font, jstring text,
4227                                 int x, int y)
4228 {
4229     ::SetTextColor(hDC, ::GetSysColor(COLOR_BTNHILIGHT));
4230     AwtComponent::DrawWindowText(hDC, font, text, x+1, y+1);
4231     ::SetTextColor(hDC, ::GetSysColor(COLOR_BTNSHADOW));
4232     AwtComponent::DrawWindowText(hDC, font, text, x, y);
4233 }
4234 
4235 /* for WmMeasureItem method of List and Choice */
4236 jstring AwtComponent::GetItemString(JNIEnv *env, jobject target, jint index)
4237 {
4238     jstring str = (jstring)JNU_CallMethodByName(env, NULL, target, "getItemImpl",
4239                                                 "(I)Ljava/lang/String;",
4240                                                 index).l;
4241     DASSERT(!safe_ExceptionOccurred(env));
4242     return str;
4243 }
4244 
4245 /* for WmMeasureItem method of List and Choice */
4246 void AwtComponent::MeasureListItem(JNIEnv *env,
4247                                    MEASUREITEMSTRUCT &measureInfo)
4248 {
4249     if (env->EnsureLocalCapacity(1) < 0) {
4250         return;
4251     }
4252     jobject dimension = PreferredItemSize(env);
4253     DASSERT(dimension);
4254     measureInfo.itemWidth =
4255       env->GetIntField(dimension, AwtDimension::widthID);
4256     measureInfo.itemHeight =
4257       env->GetIntField(dimension, AwtDimension::heightID);
4258     env->DeleteLocalRef(dimension);
4259 }
4260 
4261 /* for WmDrawItem method of List and Choice */
4262 void AwtComponent::DrawListItem(JNIEnv *env, DRAWITEMSTRUCT &drawInfo)
4263 {
4264     if (env->EnsureLocalCapacity(3) < 0) {
4265         return;
4266     }
4267     jobject peer = GetPeer(env);
4268     jobject target = env->GetObjectField(peer, AwtObject::targetID);
4269 
4270     HDC hDC = drawInfo.hDC;
4271     RECT rect = drawInfo.rcItem;
4272 
4273     BOOL bEnabled = isEnabled();
4274     BOOL unfocusableChoice = (drawInfo.itemState & ODS_COMBOBOXEDIT) && !IsFocusable();
4275     DWORD crBack, crText;
4276     if (drawInfo.itemState & ODS_SELECTED){
4277         /* Set background and text colors for selected item */
4278         crBack = ::GetSysColor (COLOR_HIGHLIGHT);
4279         crText = ::GetSysColor (COLOR_HIGHLIGHTTEXT);
4280     } else {
4281         /* Set background and text colors for unselected item */
4282         crBack = GetBackgroundColor();
4283         crText = bEnabled ? GetColor() : ::GetSysColor(COLOR_GRAYTEXT);
4284     }
4285     if (unfocusableChoice) {
4286         //6190728. Shouldn't draw selection field (edit control) of an owner-drawn combo box.
4287         crBack = GetBackgroundColor();
4288         crText = bEnabled ? GetColor() : ::GetSysColor(COLOR_GRAYTEXT);
4289     }
4290 
4291     /* Fill item rectangle with background color */
4292     HBRUSH hbrBack = ::CreateSolidBrush (crBack);
4293     DASSERT(hbrBack);
4294     /* 6190728. Shouldn't draw any kind of rectangle around selection field
4295      * (edit control) of an owner-drawn combo box while unfocusable
4296      */
4297     if (!unfocusableChoice){
4298         VERIFY(::FillRect (hDC, &rect, hbrBack));
4299     }
4300     VERIFY(::DeleteObject (hbrBack));
4301 
4302     /* Set current background and text colors */
4303     ::SetBkColor (hDC, crBack);
4304     ::SetTextColor (hDC, crText);
4305 
4306     /*draw string (with left margin of 1 point) */
4307     if ((int) (drawInfo.itemID) >= 0) {
4308             jobject font = GET_FONT(target, peer);
4309             jstring text = GetItemString(env, target, drawInfo.itemID);
4310             if (env->ExceptionCheck()) {
4311                 env->DeleteLocalRef(font);
4312                 env->DeleteLocalRef(target);
4313                 return;
4314             }
4315             SIZE size = AwtFont::getMFStringSize(hDC, font, text);
4316             AwtFont::drawMFString(hDC, font, text,
4317                                   (GetRTL()) ? rect.right - size.cx - 1
4318                                              : rect.left + 1,
4319                                   (rect.top + rect.bottom - size.cy) / 2,
4320                                   GetCodePage());
4321             env->DeleteLocalRef(font);
4322             env->DeleteLocalRef(text);
4323     }
4324     if ((drawInfo.itemState & ODS_FOCUS)  &&
4325         (drawInfo.itemAction & (ODA_FOCUS | ODA_DRAWENTIRE))) {
4326       if (!unfocusableChoice){
4327           if(::DrawFocusRect(hDC, &rect) == 0)
4328               VERIFY(::GetLastError() == 0);
4329       }
4330     }
4331     env->DeleteLocalRef(target);
4332 }
4333 
4334 /* for MeasureListItem method and WmDrawItem method of Checkbox */
4335 jint AwtComponent::GetFontHeight(JNIEnv *env)
4336 {
4337     if (env->EnsureLocalCapacity(4) < 0) {
4338         return NULL;
4339     }
4340     jobject self = GetPeer(env);
4341     jobject target = env->GetObjectField(self, AwtObject::targetID);
4342 
4343     jobject font = GET_FONT(target, self);
4344     jobject toolkit = env->CallObjectMethod(target,
4345                                             AwtComponent::getToolkitMID);
4346 
4347     DASSERT(!safe_ExceptionOccurred(env));
4348 
4349     jobject fontMetrics =
4350         env->CallObjectMethod(toolkit, AwtToolkit::getFontMetricsMID, font);
4351 
4352     DASSERT(!safe_ExceptionOccurred(env));
4353 
4354     jint height = env->CallIntMethod(fontMetrics, AwtFont::getHeightMID);
4355     DASSERT(!safe_ExceptionOccurred(env));
4356 
4357     env->DeleteLocalRef(target);
4358     env->DeleteLocalRef(font);
4359     env->DeleteLocalRef(toolkit);
4360     env->DeleteLocalRef(fontMetrics);
4361 
4362     return height;
4363 }
4364 
4365 // If you override WmPrint, make sure to save a copy of the DC on the GDI
4366 // stack to be restored in WmPrintClient. Windows mangles the DC in
4367 // ::DefWindowProc.
4368 MsgRouting AwtComponent::WmPrint(HDC hDC, LPARAM flags)
4369 {
4370     /*
4371      * DefWindowProc for WM_PRINT changes DC parameters, so we have
4372      * to restore it ourselves. Otherwise it will cause problems
4373      * when several components are printed to the same DC.
4374      */
4375     int nOriginalDC = ::SaveDC(hDC);
4376     DASSERT(nOriginalDC != 0);
4377 
4378     if (flags & PRF_NONCLIENT) {
4379 
4380         VERIFY(::SaveDC(hDC));
4381 
4382         DefWindowProc(WM_PRINT, (WPARAM)hDC,
4383                       (flags & (PRF_NONCLIENT
4384                                 | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
4385 
4386         VERIFY(::RestoreDC(hDC, -1));
4387 
4388         // Special case for components with a sunken border. Windows does not
4389         // print the border correctly on PCL printers, so we have to do it ourselves.
4390         if (GetStyleEx() & WS_EX_CLIENTEDGE) {
4391             RECT r;
4392             VERIFY(::GetWindowRect(GetHWnd(), &r));
4393             VERIFY(::OffsetRect(&r, -r.left, -r.top));
4394             VERIFY(::DrawEdge(hDC, &r, EDGE_SUNKEN, BF_RECT));
4395         }
4396     }
4397 
4398     if (flags & PRF_CLIENT) {
4399 
4400         /*
4401          * Special case for components with a sunken border.
4402          * Windows prints a client area without offset to a border width.
4403          * We will first print the non-client area with the original offset,
4404          * then the client area with a corrected offset.
4405          */
4406         if (GetStyleEx() & WS_EX_CLIENTEDGE) {
4407 
4408             int nEdgeWidth = ::GetSystemMetrics(SM_CXEDGE);
4409             int nEdgeHeight = ::GetSystemMetrics(SM_CYEDGE);
4410 
4411             VERIFY(::OffsetWindowOrgEx(hDC, -nEdgeWidth, -nEdgeHeight, NULL));
4412 
4413             // Save a copy of the DC for WmPrintClient
4414             VERIFY(::SaveDC(hDC));
4415 
4416             DefWindowProc(WM_PRINT, (WPARAM) hDC,
4417                           (flags & (PRF_CLIENT
4418                                     | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
4419 
4420             VERIFY(::OffsetWindowOrgEx(hDC, nEdgeWidth, nEdgeHeight, NULL));
4421 
4422         } else {
4423 
4424             // Save a copy of the DC for WmPrintClient
4425             VERIFY(::SaveDC(hDC));
4426             DefWindowProc(WM_PRINT, (WPARAM) hDC,
4427                           (flags & (PRF_CLIENT
4428                                     | PRF_CHECKVISIBLE | PRF_ERASEBKGND)));
4429         }
4430     }
4431 
4432     if (flags & (PRF_CHILDREN | PRF_OWNED)) {
4433         DefWindowProc(WM_PRINT, (WPARAM) hDC,
4434                       (flags & ~PRF_CLIENT & ~PRF_NONCLIENT));
4435     }
4436 
4437     VERIFY(::RestoreDC(hDC, nOriginalDC));
4438 
4439     return mrConsume;
4440 }
4441 
4442 // If you override WmPrintClient, make sure to obtain a valid copy of
4443 // the DC from the GDI stack. The copy of the DC should have been placed
4444 // there by WmPrint. Windows mangles the DC in ::DefWindowProc.
4445 MsgRouting AwtComponent::WmPrintClient(HDC hDC, LPARAM)
4446 {
4447     // obtain valid DC from GDI stack
4448     ::RestoreDC(hDC, -1);
4449 
4450     return mrDoDefault;
4451 }
4452 
4453 MsgRouting AwtComponent::WmNcCalcSize(BOOL fCalcValidRects,
4454                                       LPNCCALCSIZE_PARAMS lpncsp,
4455                                       LRESULT &retVal)
4456 {
4457     return mrDoDefault;
4458 }
4459 
4460 MsgRouting AwtComponent::WmNcPaint(HRGN hrgn)
4461 {
4462     return mrDoDefault;
4463 }
4464 
4465 MsgRouting AwtComponent::WmNcHitTest(UINT x, UINT y, LRESULT &retVal)
4466 {
4467     return mrDoDefault;
4468 }
4469 
4470 /**
4471  * WmQueryNewPalette is called whenever our component is coming to
4472  * the foreground; this gives us an opportunity to install our
4473  * custom palette.  If this install actually changes entries in
4474  * the system palette, then we get a further call to WmPaletteChanged
4475  * (but note that we only need to realize our palette once).
4476  */
4477 MsgRouting AwtComponent::WmQueryNewPalette(LRESULT &retVal)
4478 {
4479     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
4480     m_QueryNewPaletteCalled = TRUE;
4481     HDC hDC = ::GetDC(GetHWnd());
4482     DASSERT(hDC);
4483     AwtWin32GraphicsDevice::SelectPalette(hDC, screen);
4484     AwtWin32GraphicsDevice::RealizePalette(hDC, screen);
4485     ::ReleaseDC(GetHWnd(), hDC);
4486     // We must realize the palettes of all of our DC's
4487     // There is sometimes a problem where the realization of
4488     // our temporary hDC here does not actually do what
4489     // we want.  Not clear why, but presumably fallout from
4490     // our use of several simultaneous hDC's.
4491     activeDCList.RealizePalettes(screen);
4492     // Do not invalidate here; if the palette
4493     // has not changed we will get an extra repaint
4494     retVal = TRUE;
4495 
4496     return mrDoDefault;
4497 }
4498 
4499 /**
4500  * We should not need to track this event since we handle our
4501  * palette management effectively in the WmQueryNewPalette and
4502  * WmPaletteChanged methods.  However, there seems to be a bug
4503  * on some win32 systems (e.g., NT4) whereby the palette
4504  * immediately after a displayChange is not yet updated to its
4505  * final post-display-change values (hence we adjust our palette
4506  * using the wrong system palette entries), then the palette is
4507  * updated, but a WM_PALETTECHANGED message is never sent.
4508  * By tracking the ISCHANGING message as well (and by tracking
4509  * displayChange events in the AwtToolkit object), we can account
4510  * for this error by forcing our WmPaletteChanged method to be
4511  * called and thereby realizing our logical palette and updating
4512  * our dynamic colorModel object.
4513  */
4514 MsgRouting AwtComponent::WmPaletteIsChanging(HWND hwndPalChg)
4515 {
4516     if (AwtToolkit::GetInstance().HasDisplayChanged()) {
4517         WmPaletteChanged(hwndPalChg);
4518         AwtToolkit::GetInstance().ResetDisplayChanged();
4519     }
4520     return mrDoDefault;
4521 }
4522 
4523 MsgRouting AwtComponent::WmPaletteChanged(HWND hwndPalChg)
4524 {
4525     // We need to re-realize our palette here (unless we're the one
4526     // that was realizing it in the first place).  That will let us match the
4527     // remaining colors in the system palette as best we can.  We always
4528     // invalidate because the palette will have changed when we receive this
4529     // message.
4530 
4531     int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(GetHWnd());
4532     if (hwndPalChg != GetHWnd()) {
4533         HDC hDC = ::GetDC(GetHWnd());
4534         DASSERT(hDC);
4535         AwtWin32GraphicsDevice::SelectPalette(hDC, screen);
4536         AwtWin32GraphicsDevice::RealizePalette(hDC, screen);
4537         ::ReleaseDC(GetHWnd(), hDC);
4538         // We must realize the palettes of all of our DC's
4539         activeDCList.RealizePalettes(screen);
4540     }
4541     if (AwtWin32GraphicsDevice::UpdateSystemPalette(screen)) {
4542         AwtWin32GraphicsDevice::UpdateDynamicColorModel(screen);
4543     }
4544     Invalidate(NULL);
4545     return mrDoDefault;
4546 }
4547 
4548 MsgRouting AwtComponent::WmStyleChanged(int wStyleType, LPSTYLESTRUCT lpss)
4549 {
4550     DASSERT(!IsBadReadPtr(lpss, sizeof(STYLESTRUCT)));
4551     return mrDoDefault;
4552 }
4553 
4554 MsgRouting AwtComponent::WmSettingChange(UINT wFlag, LPCTSTR pszSection)
4555 {
4556     DASSERT(!IsBadStringPtr(pszSection, 20));
4557     DTRACE_PRINTLN2("WM_SETTINGCHANGE: wFlag=%d pszSection=%s", (int)wFlag, pszSection);
4558     return mrDoDefault;
4559 }
4560 
4561 HDC AwtComponent::GetDCFromComponent()
4562 {
4563     GetDCReturnStruct *hdcStruct =
4564         (GetDCReturnStruct*)SendMessage(WM_AWT_GETDC);
4565     HDC hdc;
4566     if (hdcStruct) {
4567         if (hdcStruct->gdiLimitReached) {
4568             if (jvm != NULL) {
4569                 JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4570                 if (env != NULL && !safe_ExceptionOccurred(env)) {
4571                     JNU_ThrowByName(env, "java/awt/AWTError",
4572                         "HDC creation failure - " \
4573                         "exceeded maximum GDI resources");
4574                 }
4575             }
4576         }
4577         hdc = hdcStruct->hDC;
4578         delete hdcStruct;
4579     } else {
4580         hdc = NULL;
4581     }
4582     return hdc;
4583 }
4584 
4585 void AwtComponent::FillBackground(HDC hMemoryDC, SIZE &size)
4586 {
4587     RECT eraseR = { 0, 0, size.cx, size.cy };
4588     VERIFY(::FillRect(hMemoryDC, &eraseR, GetBackgroundBrush()));
4589 }
4590 
4591 void AwtComponent::FillAlpha(void *bitmapBits, SIZE &size, BYTE alpha)
4592 {
4593     if (!bitmapBits) {
4594         return;
4595     }
4596 
4597     DWORD* dest = (DWORD*)bitmapBits;
4598     //XXX: might be optimized to use one loop (cy*cx -> 0)
4599     for (int i = 0; i < size.cy; i++ ) {
4600         for (int j = 0; j < size.cx; j++ ) {
4601             ((BYTE*)(dest++))[3] = alpha;
4602         }
4603     }
4604 }
4605 




























4606 jintArray AwtComponent::CreatePrintedPixels(SIZE &loc, SIZE &size, int alpha) {
4607     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4608 
4609     if (!::IsWindowVisible(GetHWnd())) {
4610         return NULL;
4611     }
4612 
4613     HDC hdc = GetDCFromComponent();
4614     if (!hdc) {
4615         return NULL;
4616     }
4617     HDC hMemoryDC = ::CreateCompatibleDC(hdc);
4618     void *bitmapBits = NULL;
4619     HBITMAP hBitmap = BitmapUtil::CreateARGBBitmap(size.cx, size.cy, &bitmapBits);
4620     HBITMAP hOldBitmap = (HBITMAP)::SelectObject(hMemoryDC, hBitmap);
4621     SendMessage(WM_AWT_RELEASEDC, (WPARAM)hdc);
4622 
4623     FillBackground(hMemoryDC, size);
4624 
4625     VERIFY(::SetWindowOrgEx(hMemoryDC, loc.cx, loc.cy, NULL));
4626 
4627     // Don't bother with PRF_CHECKVISIBLE because we called IsWindowVisible
4628     // above.
4629     SendMessage(WM_PRINT, (WPARAM)hMemoryDC, PRF_CLIENT | PRF_NONCLIENT);
4630 
4631     // First make sure the system completed any drawing to the bitmap.
4632     ::GdiFlush();
4633 
4634     // WM_PRINT does not fill the alpha-channel of the ARGB bitmap
4635     // leaving it equal to zero. Hence we need to fill it manually. Otherwise
4636     // the pixels will be considered transparent when interpreting the data.
4637     FillAlpha(bitmapBits, size, alpha);
4638 
4639     ::SelectObject(hMemoryDC, hOldBitmap);
4640 
4641     BITMAPINFO bmi;
4642     memset(&bmi, 0, sizeof(BITMAPINFO));
4643     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
4644     bmi.bmiHeader.biWidth = size.cx;
4645     bmi.bmiHeader.biHeight = -size.cy;
4646     bmi.bmiHeader.biPlanes = 1;
4647     bmi.bmiHeader.biBitCount = 32;
4648     bmi.bmiHeader.biCompression = BI_RGB;
4649 
4650     jobject localPixelArray = env->NewIntArray(size.cx * size.cy);
4651     jintArray pixelArray = NULL;
4652     if (localPixelArray != NULL) {
4653         pixelArray = (jintArray)env->NewGlobalRef(localPixelArray);
4654         env->DeleteLocalRef(localPixelArray); localPixelArray = NULL;
4655 
4656         jboolean isCopy;
4657         jint *pixels = env->GetIntArrayElements(pixelArray, &isCopy);
4658 
4659         ::GetDIBits(hMemoryDC, hBitmap, 0, size.cy, (LPVOID)pixels, &bmi,
4660                     DIB_RGB_COLORS);
4661 
4662         env->ReleaseIntArrayElements(pixelArray, pixels, 0);
4663     }
4664 
4665     VERIFY(::DeleteObject(hBitmap));
4666     VERIFY(::DeleteDC(hMemoryDC));
4667 
4668     return pixelArray;
4669 }
4670 
4671 void* AwtComponent::SetNativeFocusOwner(void *self) {
4672     if (self == NULL) {
4673         // It means that the KFM wants to set focus to null
4674         sm_focusOwner = NULL;
4675         return NULL;
4676     }
4677 
4678     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4679 
4680     AwtComponent *c = NULL;
4681     jobject peer = (jobject)self;
4682 
4683     PDATA pData;
4684     JNI_CHECK_NULL_GOTO(peer, "peer", ret);
4685     pData = JNI_GET_PDATA(peer);
4686     if (pData == NULL) {
4687         goto ret;
4688     }
4689     c = (AwtComponent *)pData;
4690 
4691 ret:
4692     if (c && ::IsWindow(c->GetHWnd())) {
4693         sm_focusOwner = c->GetHWnd();
4694     } else {
4695         sm_focusOwner = NULL;
4696     }
4697     env->DeleteGlobalRef(peer);
4698     return NULL;
4699 }
4700 
4701 void* AwtComponent::GetNativeFocusedWindow() {
4702     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4703     AwtComponent *comp =
4704         AwtComponent::GetComponent(AwtComponent::GetFocusedWindow());
4705     return (comp != NULL) ? comp->GetTargetAsGlobalRef(env) : NULL;
4706 }
4707 
4708 void* AwtComponent::GetNativeFocusOwner() {
4709     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4710     AwtComponent *comp =
4711         AwtComponent::GetComponent(AwtComponent::sm_focusOwner);
4712     return (comp != NULL) ? comp->GetTargetAsGlobalRef(env) : NULL;
4713 }
4714 
4715 AwtComponent* AwtComponent::SearchChild(UINT id) {
4716     ChildListItem* child;
4717     for (child = m_childList; child != NULL;child = child->m_next) {
4718         if (child->m_ID == id)
4719             return child->m_Component;
4720     }
4721     /*
4722      * DASSERT(FALSE);
4723      * This should not be happend if all children are recorded
4724      */
4725     return NULL;        /* make compiler happy */
4726 }
4727 
4728 void AwtComponent::RemoveChild(UINT id) {
4729     ChildListItem* child = m_childList;
4730     ChildListItem* lastChild = NULL;
4731     while (child != NULL) {
4732         if (child->m_ID == id) {
4733             if (lastChild == NULL) {
4734                 m_childList = child->m_next;
4735             } else {
4736                 lastChild->m_next = child->m_next;
4737             }
4738             child->m_next = NULL;
4739             DASSERT(child != NULL);
4740             delete child;
4741             return;
4742         }
4743         lastChild = child;
4744         child = child->m_next;
4745     }
4746 }
4747 
4748 void AwtComponent::SendKeyEvent(jint id, jlong when, jint raw, jint cooked,
4749                                 jint modifiers, jint keyLocation, jlong nativeCode, MSG *pMsg)
4750 {
4751     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4752     CriticalSection::Lock l(GetLock());
4753     if (GetPeer(env) == NULL) {
4754         /* event received during termination. */
4755         return;
4756     }
4757 
4758     static jclass keyEventCls;
4759     if (keyEventCls == NULL) {
4760         jclass keyEventClsLocal = env->FindClass("java/awt/event/KeyEvent");
4761         DASSERT(keyEventClsLocal);
4762         if (keyEventClsLocal == NULL) {
4763             /* exception already thrown */
4764             return;
4765         }
4766         keyEventCls = (jclass)env->NewGlobalRef(keyEventClsLocal);
4767         env->DeleteLocalRef(keyEventClsLocal);
4768     }
4769 
4770     static jmethodID keyEventConst;
4771     if (keyEventConst == NULL) {
4772         keyEventConst =  env->GetMethodID(keyEventCls, "<init>",
4773                                           "(Ljava/awt/Component;IJIICI)V");
4774         DASSERT(keyEventConst);
4775         CHECK_NULL(keyEventConst);
4776     }
4777     if (env->EnsureLocalCapacity(2) < 0) {
4778         return;
4779     }
4780     jobject target = GetTarget(env);
4781     jobject keyEvent = env->NewObject(keyEventCls, keyEventConst, target,
4782                                       id, when, modifiers, raw, cooked,
4783                                       keyLocation);
4784     if (safe_ExceptionOccurred(env)) env->ExceptionDescribe();
4785     DASSERT(!safe_ExceptionOccurred(env));
4786     DASSERT(keyEvent != NULL);
4787     if (keyEvent == NULL) {
4788         env->DeleteLocalRef(target);
4789         return;
4790     }
4791     env->SetLongField(keyEvent, AwtKeyEvent::rawCodeID, nativeCode);
4792     if( nativeCode && nativeCode < 256 ) {
4793         env->SetLongField(keyEvent, AwtKeyEvent::primaryLevelUnicodeID, (jlong)(dynPrimaryKeymap[nativeCode].unicode));
4794         env->SetLongField(keyEvent, AwtKeyEvent::extendedKeyCodeID, (jlong)(dynPrimaryKeymap[nativeCode].jkey));
4795         if( nativeCode < 255 ) {
4796             env->SetLongField(keyEvent, AwtKeyEvent::scancodeID, (jlong)(dynPrimaryKeymap[nativeCode].scancode));
4797         }else if( pMsg != NULL ) {
4798             // unknown key with virtual keycode 0xFF.
4799             // Its scancode is not in the table, pickup it from the message.
4800             env->SetLongField(keyEvent, AwtKeyEvent::scancodeID, (jlong)(HIWORD(pMsg->lParam) & 0xFF));
4801         }
4802     }
4803     if (pMsg != NULL) {
4804         AwtAWTEvent::saveMSG(env, pMsg, keyEvent);
4805     }
4806     SendEvent(keyEvent);
4807 
4808     env->DeleteLocalRef(keyEvent);
4809     env->DeleteLocalRef(target);
4810 }
4811 
4812 void
4813 AwtComponent::SendKeyEventToFocusOwner(jint id, jlong when,
4814                                        jint raw, jint cooked,
4815                                        jint modifiers, jint keyLocation,
4816                                        jlong nativeCode,
4817                                        MSG *msg)
4818 {
4819     /*
4820      * if focus owner is null, but focused window isn't
4821      * we will send key event to focused window
4822      */
4823     HWND hwndTarget = ((sm_focusOwner != NULL) ? sm_focusOwner : AwtComponent::GetFocusedWindow());
4824 
4825     if (hwndTarget == GetHWnd()) {
4826         SendKeyEvent(id, when, raw, cooked, modifiers, keyLocation, nativeCode, msg);
4827     } else {
4828         AwtComponent *target = NULL;
4829         if (hwndTarget != NULL) {
4830             target = AwtComponent::GetComponent(hwndTarget);
4831             if (target == NULL) {
4832                 target = this;
4833             }
4834         }
4835         if (target != NULL) {
4836             target->SendKeyEvent(id, when, raw, cooked, modifiers,
4837               keyLocation, nativeCode, msg);
4838         }
4839     }
4840 }
4841 
4842 void AwtComponent::SetDragCapture(UINT flags)
4843 {
4844     // don't want to interfere with other controls
4845     if (::GetCapture() == NULL) {
4846         ::SetCapture(GetHWnd());
4847     }
4848 }
4849 
4850 void AwtComponent::ReleaseDragCapture(UINT flags)
4851 {
4852     if ((::GetCapture() == GetHWnd()) && ((flags & ALL_MK_BUTTONS) == 0)) {
4853         // user has released all buttons, so release the capture
4854         ::ReleaseCapture();
4855     }
4856 }
4857 
4858 void AwtComponent::SendMouseEvent(jint id, jlong when, jint x, jint y,
4859                                   jint modifiers, jint clickCount,
4860                                   jboolean popupTrigger, jint button,
4861                                   MSG *pMsg)
4862 {
4863     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4864     CriticalSection::Lock l(GetLock());
4865     if (GetPeer(env) == NULL) {
4866         /* event received during termination. */
4867         return;
4868     }
4869 
4870     static jclass mouseEventCls;
4871     if (mouseEventCls == NULL) {
4872         jclass mouseEventClsLocal =
4873             env->FindClass("java/awt/event/MouseEvent");
4874         CHECK_NULL(mouseEventClsLocal);
4875         mouseEventCls = (jclass)env->NewGlobalRef(mouseEventClsLocal);
4876         env->DeleteLocalRef(mouseEventClsLocal);
4877     }
4878     RECT insets;
4879     GetInsets(&insets);
4880 
4881     static jmethodID mouseEventConst;
4882     if (mouseEventConst == NULL) {
4883         mouseEventConst =
4884             env->GetMethodID(mouseEventCls, "<init>",
4885                  "(Ljava/awt/Component;IJIIIIIIZI)V");
4886         DASSERT(mouseEventConst);
4887         CHECK_NULL(mouseEventConst);
4888     }
4889     if (env->EnsureLocalCapacity(2) < 0) {
4890         return;
4891     }
4892     jobject target = GetTarget(env);
4893     DWORD curMousePos = ::GetMessagePos();
4894     int xAbs = GET_X_LPARAM(curMousePos);
4895     int yAbs = GET_Y_LPARAM(curMousePos);
4896     jobject mouseEvent = env->NewObject(mouseEventCls, mouseEventConst,
4897                                         target,
4898                                         id, when, modifiers,
4899                                         x+insets.left, y+insets.top,
4900                                         xAbs, yAbs,

4901                                         clickCount, popupTrigger, button);
4902 
4903     if (safe_ExceptionOccurred(env)) {
4904         env->ExceptionDescribe();
4905         env->ExceptionClear();
4906     }
4907 
4908     DASSERT(mouseEvent != NULL);
4909     CHECK_NULL(mouseEvent);
4910     if (pMsg != 0) {
4911         AwtAWTEvent::saveMSG(env, pMsg, mouseEvent);
4912     }
4913     SendEvent(mouseEvent);
4914 
4915     env->DeleteLocalRef(mouseEvent);
4916     env->DeleteLocalRef(target);
4917 }
4918 
4919 void
4920 AwtComponent::SendMouseWheelEvent(jint id, jlong when, jint x, jint y,
4921                                   jint modifiers, jint clickCount,
4922                                   jboolean popupTrigger, jint scrollType,
4923                                   jint scrollAmount, jint roundedWheelRotation,
4924                                   jdouble preciseWheelRotation, MSG *pMsg)
4925 {
4926     /* Code based not so loosely on AwtComponent::SendMouseEvent */
4927     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4928     CriticalSection::Lock l(GetLock());
4929     if (GetPeer(env) == NULL) {
4930         /* event received during termination. */
4931         return;
4932     }
4933 
4934     static jclass mouseWheelEventCls;
4935     if (mouseWheelEventCls == NULL) {
4936         jclass mouseWheelEventClsLocal =
4937             env->FindClass("java/awt/event/MouseWheelEvent");
4938         CHECK_NULL(mouseWheelEventClsLocal);
4939         mouseWheelEventCls = (jclass)env->NewGlobalRef(mouseWheelEventClsLocal);
4940         env->DeleteLocalRef(mouseWheelEventClsLocal);
4941     }
4942     RECT insets;
4943     GetInsets(&insets);
4944 
4945     static jmethodID mouseWheelEventConst;
4946     if (mouseWheelEventConst == NULL) {
4947         mouseWheelEventConst =
4948             env->GetMethodID(mouseWheelEventCls, "<init>",
4949                            "(Ljava/awt/Component;IJIIIIIIZIIID)V");
4950         DASSERT(mouseWheelEventConst);
4951         CHECK_NULL(mouseWheelEventConst);
4952     }
4953     if (env->EnsureLocalCapacity(2) < 0) {
4954         return;
4955     }
4956     jobject target = GetTarget(env);
4957     DWORD curMousePos = ::GetMessagePos();
4958     int xAbs = GET_X_LPARAM(curMousePos);
4959     int yAbs = GET_Y_LPARAM(curMousePos);
4960 
4961     DTRACE_PRINTLN("creating MWE in JNI");
4962 
4963     jobject mouseWheelEvent = env->NewObject(mouseWheelEventCls,
4964                                              mouseWheelEventConst,
4965                                              target,
4966                                              id, when, modifiers,
4967                                              x+insets.left, y+insets.top,
4968                                              xAbs, yAbs,


4969                                              clickCount, popupTrigger,
4970                                              scrollType, scrollAmount,
4971                                              roundedWheelRotation, preciseWheelRotation);
4972 
4973     DASSERT(mouseWheelEvent != NULL);
4974     if (mouseWheelEvent == NULL || safe_ExceptionOccurred(env)) {
4975         env->ExceptionDescribe();
4976         env->ExceptionClear();
4977         env->DeleteLocalRef(target);
4978         return;
4979     }
4980     if (pMsg != NULL) {
4981         AwtAWTEvent::saveMSG(env, pMsg, mouseWheelEvent);
4982     }
4983     SendEvent(mouseWheelEvent);
4984 
4985     env->DeleteLocalRef(mouseWheelEvent);
4986     env->DeleteLocalRef(target);
4987 }
4988 
4989 void AwtComponent::SendFocusEvent(jint id, HWND opposite)
4990 {
4991     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
4992 
4993     CriticalSection::Lock l(GetLock());
4994     if (GetPeer(env) == NULL) {
4995         /* event received during termination. */
4996         return;
4997     }
4998 
4999     static jclass focusEventCls;
5000     if (focusEventCls == NULL) {
5001         jclass focusEventClsLocal
5002             = env->FindClass("java/awt/event/FocusEvent");
5003         DASSERT(focusEventClsLocal);
5004         CHECK_NULL(focusEventClsLocal);
5005         focusEventCls = (jclass)env->NewGlobalRef(focusEventClsLocal);
5006         env->DeleteLocalRef(focusEventClsLocal);
5007     }
5008 
5009     static jmethodID focusEventConst;
5010     if (focusEventConst == NULL) {
5011         focusEventConst =
5012             env->GetMethodID(focusEventCls, "<init>",
5013                              "(Ljava/awt/Component;IZLjava/awt/Component;)V");
5014         DASSERT(focusEventConst);
5015         CHECK_NULL(focusEventConst);
5016     }
5017 
5018     static jclass sequencedEventCls;
5019     if (sequencedEventCls == NULL) {
5020         jclass sequencedEventClsLocal =
5021             env->FindClass("java/awt/SequencedEvent");
5022         DASSERT(sequencedEventClsLocal);
5023         CHECK_NULL(sequencedEventClsLocal);
5024         sequencedEventCls =
5025             (jclass)env->NewGlobalRef(sequencedEventClsLocal);
5026         env->DeleteLocalRef(sequencedEventClsLocal);
5027     }
5028 
5029     static jmethodID sequencedEventConst;
5030     if (sequencedEventConst == NULL) {
5031         sequencedEventConst =
5032             env->GetMethodID(sequencedEventCls, "<init>",
5033                              "(Ljava/awt/AWTEvent;)V");
5034         DASSERT(sequencedEventConst);
5035         CHECK_NULL(sequencedEventConst);
5036     }
5037 
5038     if (env->EnsureLocalCapacity(3) < 0) {
5039         return;
5040     }
5041 
5042     jobject target = GetTarget(env);
5043     jobject jOpposite = NULL;
5044     if (opposite != NULL) {
5045         AwtComponent *awtOpposite = AwtComponent::GetComponent(opposite);
5046         if (awtOpposite != NULL) {
5047             jOpposite = awtOpposite->GetTarget(env);
5048         }
5049     }
5050     jobject focusEvent = env->NewObject(focusEventCls, focusEventConst,
5051                                         target, id, JNI_FALSE, jOpposite);
5052     DASSERT(!safe_ExceptionOccurred(env));
5053     DASSERT(focusEvent != NULL);
5054     if (jOpposite != NULL) {
5055         env->DeleteLocalRef(jOpposite); jOpposite = NULL;
5056     }
5057     env->DeleteLocalRef(target); target = NULL;
5058     CHECK_NULL(focusEvent);
5059 
5060     jobject sequencedEvent = env->NewObject(sequencedEventCls,
5061                                             sequencedEventConst,
5062                                             focusEvent);
5063     DASSERT(!safe_ExceptionOccurred(env));
5064     DASSERT(sequencedEvent != NULL);
5065     env->DeleteLocalRef(focusEvent); focusEvent = NULL;
5066     CHECK_NULL(sequencedEvent);
5067     SendEvent(sequencedEvent);
5068 
5069     env->DeleteLocalRef(sequencedEvent);
5070 }
5071 
5072 /*
5073  * Forward a filtered event directly to the subclassed window.
5074  * This method is needed so that DefWindowProc is invoked on the
5075  * component's owning thread.
5076  */
5077 MsgRouting AwtComponent::HandleEvent(MSG *msg, BOOL)
5078 {
5079     DefWindowProc(msg->message, msg->wParam, msg->lParam);
5080     delete msg;
5081     return mrConsume;
5082 }
5083 
5084 /* Post a WM_AWT_HANDLE_EVENT message which invokes HandleEvent
5085    on the toolkit thread. This method may pre-filter the messages. */
5086 BOOL AwtComponent::PostHandleEventMessage(MSG *msg, BOOL synthetic)
5087 {
5088     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5089     // We should cut off keyboard events to disabled components
5090     // to avoid the components responding visually to keystrokes when disabled.
5091     // we shouldn't cut off WM_SYS* messages as they aren't used for normal activity
5092     // but to activate menus, close windows, etc
5093     switch(msg->message) {
5094         case WM_KEYDOWN:
5095         case WM_KEYUP:
5096         case WM_CHAR:
5097         case WM_DEADCHAR:
5098             {
5099                 if (!isRecursivelyEnabled()) {
5100                     goto quit;
5101                 }
5102                 break;
5103             }
5104     }
5105     if (PostMessage(GetHWnd(), WM_AWT_HANDLE_EVENT,
5106         (WPARAM) synthetic, (LPARAM) msg)) {
5107             return TRUE;
5108     } else {
5109         JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
5110     }
5111 quit:
5112     delete msg;
5113     return FALSE;
5114 }
5115 
5116 void AwtComponent::SynthesizeKeyMessage(JNIEnv *env, jobject keyEvent)
5117 {
5118     jint id = (env)->GetIntField(keyEvent, AwtAWTEvent::idID);
5119     UINT message;
5120     switch (id) {
5121       case java_awt_event_KeyEvent_KEY_PRESSED:
5122           message = WM_KEYDOWN;
5123           break;
5124       case java_awt_event_KeyEvent_KEY_RELEASED:
5125           message = WM_KEYUP;
5126           break;
5127       case java_awt_event_KeyEvent_KEY_TYPED:
5128           message = WM_CHAR;
5129           break;
5130       default:
5131           return;
5132     }
5133 
5134     /*
5135      * KeyEvent.modifiers aren't supported -- the Java apppwd must send separate
5136      * KEY_PRESSED and KEY_RELEASED events for the modifier virtual keys.
5137      */
5138     if (id == java_awt_event_KeyEvent_KEY_TYPED) {
5139         // WM_CHAR message must be posted using WM_AWT_FORWARD_CHAR
5140         // (for Edit control)
5141         jchar keyChar = (jchar)
5142           (env)->GetCharField(keyEvent, AwtKeyEvent::keyCharID);
5143 
5144         // Bugid 4724007.  If it is a Delete character, don't send the fake
5145         // KEY_TYPED we created back to the native window: Windows doesn't
5146         // expect a WM_CHAR for Delete in TextFields, so it tries to enter a
5147         // character after deleting.
5148         if (keyChar == '\177') { // the Delete character
5149             return;
5150         }
5151 
5152         // Disable forwarding WM_CHAR messages to disabled components
5153         if (isRecursivelyEnabled()) {
5154             if (!::PostMessage(GetHWnd(), WM_AWT_FORWARD_CHAR,
5155                 MAKEWPARAM(keyChar, TRUE), 0)) {
5156                 JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
5157             }
5158         }
5159     } else {
5160         jint keyCode =
5161           (env)->GetIntField(keyEvent, AwtKeyEvent::keyCodeID);
5162         UINT key, modifiers;
5163         AwtComponent::JavaKeyToWindowsKey(keyCode, &key, &modifiers);
5164         MSG* msg = CreateMessage(message, key, 0);
5165         PostHandleEventMessage(msg, TRUE);
5166     }
5167 }
5168 
5169 void AwtComponent::SynthesizeMouseMessage(JNIEnv *env, jobject mouseEvent)
5170 {
5171     /*    DebugBreak(); */
5172     jint button = (env)->GetIntField(mouseEvent, AwtMouseEvent::buttonID);
5173     jint modifiers = (env)->GetIntField(mouseEvent, AwtInputEvent::modifiersID);
5174 
5175     WPARAM wParam = 0;
5176     WORD wLow = 0;
5177     jint wheelAmt = 0;
5178     jint id = (env)->GetIntField(mouseEvent, AwtAWTEvent::idID);
5179     UINT message;
5180     switch (id) {
5181       case java_awt_event_MouseEvent_MOUSE_PRESSED: {
5182           switch (button) {
5183             case java_awt_event_MouseEvent_BUTTON1:
5184                 message = WM_LBUTTONDOWN; break;
5185             case java_awt_event_MouseEvent_BUTTON3:
5186                 message = WM_MBUTTONDOWN; break;
5187             case java_awt_event_MouseEvent_BUTTON2:
5188                 message = WM_RBUTTONDOWN; break;
5189           }
5190           break;
5191       }
5192       case java_awt_event_MouseEvent_MOUSE_RELEASED: {
5193           switch (button) {
5194             case java_awt_event_MouseEvent_BUTTON1:
5195                 message = WM_LBUTTONUP; break;
5196             case java_awt_event_MouseEvent_BUTTON3:
5197                 message = WM_MBUTTONUP; break;
5198             case java_awt_event_MouseEvent_BUTTON2:
5199                 message = WM_RBUTTONUP; break;
5200           }
5201           break;
5202       }
5203       case java_awt_event_MouseEvent_MOUSE_MOVED:
5204           /* MOUSE_DRAGGED events must first have sent a MOUSE_PRESSED event. */
5205       case java_awt_event_MouseEvent_MOUSE_DRAGGED:
5206           message = WM_MOUSEMOVE;
5207           break;
5208       case java_awt_event_MouseEvent_MOUSE_WHEEL:
5209           if (modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK) {
5210               wLow |= MK_CONTROL;
5211           }
5212           if (modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) {
5213               wLow |= MK_SHIFT;
5214           }
5215           if (modifiers & java_awt_event_InputEvent_BUTTON1_DOWN_MASK) {
5216               wLow |= MK_LBUTTON;
5217           }
5218           if (modifiers & java_awt_event_InputEvent_BUTTON2_DOWN_MASK) {
5219               wLow |= MK_RBUTTON;
5220           }
5221           if (modifiers & java_awt_event_InputEvent_BUTTON3_DOWN_MASK) {
5222               wLow |= MK_MBUTTON;
5223           }
5224           if (modifiers & X1_BUTTON) {
5225               wLow |= GetButtonMK(X1_BUTTON);
5226           }
5227           if (modifiers & X2_BUTTON) {
5228               wLow |= GetButtonMK(X2_BUTTON);
5229           }
5230 
5231           wheelAmt = (jint)JNU_CallMethodByName(env,
5232                                                NULL,
5233                                                mouseEvent,
5234                                                "getWheelRotation",
5235                                                "()I").i;
5236           DASSERT(!safe_ExceptionOccurred(env));
5237           JNU_CHECK_EXCEPTION(env);
5238           DTRACE_PRINTLN1("wheelAmt = %i\n", wheelAmt);
5239 
5240           // convert Java wheel amount value to Win32
5241           wheelAmt *= -1 * WHEEL_DELTA;
5242 
5243           message = WM_MOUSEWHEEL;
5244           wParam = MAKEWPARAM(wLow, wheelAmt);
5245 
5246           break;
5247       default:
5248           return;
5249     }
5250     jint x = (env)->GetIntField(mouseEvent, AwtMouseEvent::xID);
5251     jint y = (env)->GetIntField(mouseEvent, AwtMouseEvent::yID);
5252     MSG* msg = CreateMessage(message, wParam, MAKELPARAM(x, y), x, y);
5253     PostHandleEventMessage(msg, TRUE);
5254 }
5255 
5256 BOOL AwtComponent::InheritsNativeMouseWheelBehavior() {return false;}
5257 
5258 void AwtComponent::Invalidate(RECT* r)
5259 {
5260     ::InvalidateRect(GetHWnd(), r, FALSE);
5261 }
5262 
5263 void AwtComponent::BeginValidate()
5264 {
5265     DASSERT(m_validationNestCount >= 0 &&
5266            m_validationNestCount < 1000); // sanity check
5267 
5268     if (m_validationNestCount == 0) {
5269     // begin deferred window positioning if we're not inside
5270     // another Begin/EndValidate pair
5271         DASSERT(m_hdwp == NULL);
5272         m_hdwp = ::BeginDeferWindowPos(32);
5273     }
5274 
5275     m_validationNestCount++;
5276 }
5277 
5278 void AwtComponent::EndValidate()
5279 {
5280     DASSERT(m_validationNestCount > 0 &&
5281            m_validationNestCount < 1000); // sanity check
5282     DASSERT(m_hdwp != NULL);
5283 
5284     m_validationNestCount--;
5285     if (m_validationNestCount == 0) {
5286     // if this call to EndValidate is not nested inside another
5287     // Begin/EndValidate pair, end deferred window positioning
5288         ::EndDeferWindowPos(m_hdwp);
5289         m_hdwp = NULL;
5290     }
5291 }
5292 
5293 /**
5294  * HWND, AwtComponent and Java Peer interaction
5295  */
5296 
5297 /*
5298  *Link the C++, Java peer, and HWNDs together.
5299  */
5300 void AwtComponent::LinkObjects(JNIEnv *env, jobject peer)
5301 {
5302     /*
5303      * Bind all three objects together thru this C++ object, two-way to each:
5304      *     JavaPeer <-> C++ <-> HWND
5305      *
5306      * C++ -> JavaPeer
5307      */
5308     if (m_peerObject == NULL) {
5309         // This may have already been set up by CreateHWnd
5310         // And we don't want to create two references so we
5311         // will leave the prior one alone
5312         m_peerObject = env->NewGlobalRef(peer);
5313     }
5314     /* JavaPeer -> HWND */
5315     env->SetLongField(peer, AwtComponent::hwndID, reinterpret_cast<jlong>(m_hwnd));
5316 
5317     /* JavaPeer -> C++ */
5318     JNI_SET_PDATA(peer, this);
5319 
5320     /* HWND -> C++ */
5321     SetComponentInHWND();
5322 }
5323 
5324 /* Cleanup above linking */
5325 void AwtComponent::UnlinkObjects()
5326 {
5327     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5328     if (m_peerObject) {
5329         env->SetLongField(m_peerObject, AwtComponent::hwndID, 0);
5330         JNI_SET_PDATA(m_peerObject, static_cast<PDATA>(NULL));
5331         JNI_SET_DESTROYED(m_peerObject);
5332         env->DeleteGlobalRef(m_peerObject);
5333         m_peerObject = NULL;
5334     }
5335 }
5336 
5337 void AwtComponent::Enable(BOOL bEnable)
5338 {
5339     if (bEnable && IsTopLevel()) {
5340         // we should not enable blocked toplevels
5341         bEnable = !::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()));
5342     }
5343     // Shouldn't trigger native focus change
5344     // (only the proxy may be the native focus owner).
5345     ::EnableWindow(GetHWnd(), bEnable);
5346 
5347     CriticalSection::Lock l(GetLock());
5348     VerifyState();
5349 }
5350 
5351 /*
5352  * associate an AwtDropTarget with this AwtComponent
5353  */
5354 
5355 AwtDropTarget* AwtComponent::CreateDropTarget(JNIEnv* env) {
5356     m_dropTarget = new AwtDropTarget(env, this);
5357     m_dropTarget->RegisterTarget(TRUE);
5358     return m_dropTarget;
5359 }
5360 
5361 /*
5362  * disassociate an AwtDropTarget with this AwtComponent
5363  */
5364 
5365 void AwtComponent::DestroyDropTarget() {
5366     if (m_dropTarget != NULL) {
5367         m_dropTarget->RegisterTarget(FALSE);
5368         m_dropTarget->Release();
5369         m_dropTarget = NULL;
5370     }
5371 }
5372 
5373 BOOL AwtComponent::IsFocusingMouseMessage(MSG *pMsg) {
5374     return pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_LBUTTONDBLCLK;
5375 }
5376 
5377 BOOL AwtComponent::IsFocusingKeyMessage(MSG *pMsg) {
5378     return pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_SPACE;
5379 }
5380 
5381 void AwtComponent::_Show(void *param)
5382 {
5383     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5384 
5385     jobject self = (jobject)param;
5386 
5387     AwtComponent *p;
5388 
5389     PDATA pData;
5390     JNI_CHECK_PEER_GOTO(self, ret);
5391     p = (AwtComponent *)pData;
5392     if (::IsWindow(p->GetHWnd()))
5393     {
5394         p->SendMessage(WM_AWT_COMPONENT_SHOW);
5395     }
5396 ret:
5397     env->DeleteGlobalRef(self);
5398 }
5399 
5400 void AwtComponent::_Hide(void *param)
5401 {
5402     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5403 
5404     jobject self = (jobject)param;
5405 
5406     AwtComponent *p;
5407 
5408     PDATA pData;
5409     JNI_CHECK_PEER_GOTO(self, ret);
5410     p = (AwtComponent *)pData;
5411     if (::IsWindow(p->GetHWnd()))
5412     {
5413         p->SendMessage(WM_AWT_COMPONENT_HIDE);
5414     }
5415 ret:
5416     env->DeleteGlobalRef(self);
5417 }
5418 
5419 void AwtComponent::_Enable(void *param)
5420 {
5421     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5422 
5423     jobject self = (jobject)param;
5424 
5425     AwtComponent *p;
5426 
5427     PDATA pData;
5428     JNI_CHECK_PEER_GOTO(self, ret);
5429     p = (AwtComponent *)pData;
5430     if (::IsWindow(p->GetHWnd()))
5431     {
5432         p->Enable(TRUE);
5433     }
5434 ret:
5435     env->DeleteGlobalRef(self);
5436 }
5437 
5438 void AwtComponent::_Disable(void *param)
5439 {
5440     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5441 
5442     jobject self = (jobject)param;
5443 
5444     AwtComponent *p;
5445 
5446     PDATA pData;
5447     JNI_CHECK_PEER_GOTO(self, ret);
5448     p = (AwtComponent *)pData;
5449     if (::IsWindow(p->GetHWnd()))
5450     {
5451         p->Enable(FALSE);
5452     }
5453 ret:
5454     env->DeleteGlobalRef(self);
5455 }
5456 
5457 jobject AwtComponent::_GetLocationOnScreen(void *param)
5458 {
5459     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5460 
5461     jobject self = (jobject)param;
5462 
5463     jobject result = NULL;
5464     AwtComponent *p;
5465 
5466     PDATA pData;
5467     JNI_CHECK_PEER_GOTO(self, ret);
5468     p = (AwtComponent *)pData;
5469     if (::IsWindow(p->GetHWnd()))
5470     {
5471         RECT rect;
5472         VERIFY(::GetWindowRect(p->GetHWnd(),&rect));
5473         result = JNU_NewObjectByName(env, "java/awt/Point", "(II)V",
5474             rect.left, rect.top);

5475     }
5476 ret:
5477     env->DeleteGlobalRef(self);
5478 
5479     if (result != NULL)
5480     {
5481         jobject resultGlobalRef = env->NewGlobalRef(result);
5482         env->DeleteLocalRef(result);
5483         return resultGlobalRef;
5484     }
5485     else
5486     {
5487         return NULL;
5488     }
5489 }
5490 
5491 void AwtComponent::_Reshape(void *param)
5492 {
5493     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5494 
5495     ReshapeStruct *rs = (ReshapeStruct*)param;
5496     jobject self = rs->component;
5497     jint x = rs->x;
5498     jint y = rs->y;
5499     jint w = rs->w;
5500     jint h = rs->h;
5501 
5502     AwtComponent *p;
5503 
5504     PDATA pData;
5505     JNI_CHECK_PEER_GOTO(self, ret);
5506     p = (AwtComponent *)pData;
5507     if (::IsWindow(p->GetHWnd()))
5508     {
5509         RECT* r = new RECT;
5510         ::SetRect(r, x, y, x + w, y + h);
5511         p->SendMessage(WM_AWT_RESHAPE_COMPONENT, CHECK_EMBEDDED, (LPARAM)r);
5512     }
5513 ret:
5514     env->DeleteGlobalRef(self);
5515 
5516     delete rs;
5517 }
5518 
5519 void AwtComponent::_ReshapeNoCheck(void *param)
5520 {
5521     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5522 
5523     ReshapeStruct *rs = (ReshapeStruct*)param;
5524     jobject self = rs->component;
5525     jint x = rs->x;
5526     jint y = rs->y;
5527     jint w = rs->w;
5528     jint h = rs->h;
5529 
5530     AwtComponent *p;
5531 
5532     PDATA pData;
5533     JNI_CHECK_PEER_GOTO(self, ret);
5534     p = (AwtComponent *)pData;
5535     if (::IsWindow(p->GetHWnd()))
5536     {
5537         RECT* r = new RECT;
5538         ::SetRect(r, x, y, x + w, y + h);
5539         p->SendMessage(WM_AWT_RESHAPE_COMPONENT, DONT_CHECK_EMBEDDED, (LPARAM)r);
5540     }
5541 ret:
5542     env->DeleteGlobalRef(self);
5543 
5544     delete rs;
5545 }
5546 
5547 void AwtComponent::_NativeHandleEvent(void *param)
5548 {
5549     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5550 
5551     NativeHandleEventStruct *nhes = (NativeHandleEventStruct *)param;
5552     jobject self = nhes->component;
5553     jobject event = nhes->event;
5554 
5555     AwtComponent *p;
5556 
5557     PDATA pData;
5558     JNI_CHECK_NULL_GOTO(self, "peer", ret);
5559     pData = JNI_GET_PDATA(self);
5560     if (pData == NULL) {
5561         env->DeleteGlobalRef(self);
5562         if (event != NULL) {
5563             env->DeleteGlobalRef(event);
5564         }
5565         delete nhes;
5566         return;
5567     }
5568     JNI_CHECK_NULL_GOTO(event, "null AWTEvent", ret);
5569 
5570     p = (AwtComponent *)pData;
5571     if (::IsWindow(p->GetHWnd()))
5572     {
5573         if (env->EnsureLocalCapacity(1) < 0) {
5574             env->DeleteGlobalRef(self);
5575             env->DeleteGlobalRef(event);
5576             delete nhes;
5577             return;
5578         }
5579         jbyteArray bdata = (jbyteArray)(env)->GetObjectField(event, AwtAWTEvent::bdataID);
5580         int id = (env)->GetIntField(event, AwtAWTEvent::idID);
5581         DASSERT(!safe_ExceptionOccurred(env));
5582         if (bdata != 0) {
5583             MSG msg;
5584             (env)->GetByteArrayRegion(bdata, 0, sizeof(MSG), (jbyte *)&msg);
5585             (env)->DeleteLocalRef(bdata);
5586             static BOOL keyDownConsumed = FALSE;
5587             static BOOL bCharChanged = FALSE;
5588             static WCHAR modifiedChar;
5589             WCHAR unicodeChar;
5590 
5591             /* Remember if a KEY_PRESSED event is consumed, as an old model
5592              * program won't consume a subsequent KEY_TYPED event.
5593              */
5594             jboolean consumed =
5595                 (env)->GetBooleanField(event, AwtAWTEvent::consumedID);
5596             DASSERT(!safe_ExceptionOccurred(env));
5597 
5598             if (consumed) {
5599                 keyDownConsumed = (id == java_awt_event_KeyEvent_KEY_PRESSED);
5600                 env->DeleteGlobalRef(self);
5601                 env->DeleteGlobalRef(event);
5602                 delete nhes;
5603                 return;
5604 
5605             } else if (id == java_awt_event_KeyEvent_KEY_PRESSED) {
5606                 // Fix for 6637607: reset consuming
5607                 keyDownConsumed = FALSE;
5608             }
5609 
5610             /* Consume a KEY_TYPED event if a KEY_PRESSED had been, to support
5611              * the old model.
5612              */
5613             if ((id == java_awt_event_KeyEvent_KEY_TYPED) && keyDownConsumed) {
5614                 keyDownConsumed = FALSE;
5615                 env->DeleteGlobalRef(self);
5616                 env->DeleteGlobalRef(event);
5617                 delete nhes;
5618                 return;
5619             }
5620 
5621             /* Modify any event parameters, if necessary. */
5622             if (self && pData &&
5623                 id >= java_awt_event_KeyEvent_KEY_FIRST &&
5624                 id <= java_awt_event_KeyEvent_KEY_LAST) {
5625 
5626                     AwtComponent* p = (AwtComponent*)pData;
5627 
5628                     jint keyCode =
5629                       (env)->GetIntField(event, AwtKeyEvent::keyCodeID);
5630                     jchar keyChar =
5631                       (env)->GetCharField(event, AwtKeyEvent::keyCharID);
5632                     jint modifiers =
5633                       (env)->GetIntField(event, AwtInputEvent::modifiersID);
5634 
5635                     DASSERT(!safe_ExceptionOccurred(env));
5636 
5637                 /* Check to see whether the keyCode or modifiers were changed
5638                    on the keyPressed event, and tweak the following keyTyped
5639                    event (if any) accodingly.  */
5640                 switch (id) {
5641                 case java_awt_event_KeyEvent_KEY_PRESSED:
5642                 {
5643                     UINT winKey = (UINT)msg.wParam;
5644                     bCharChanged = FALSE;
5645 
5646                     if (winKey == VK_PROCESSKEY) {
5647                         // Leave it up to IME
5648                         break;
5649                     }
5650 
5651                     if (keyCode != java_awt_event_KeyEvent_VK_UNDEFINED) {
5652                         UINT newWinKey, ignored;
5653                         p->JavaKeyToWindowsKey(keyCode, &newWinKey, &ignored, winKey);
5654                         if (newWinKey != 0) {
5655                             winKey = newWinKey;
5656                         }
5657                     }
5658 
5659                     BOOL isDeadKey = FALSE;
5660                     modifiedChar = p->WindowsKeyToJavaChar(winKey, modifiers, AwtComponent::NONE, isDeadKey);
5661                     bCharChanged = (keyChar != modifiedChar);
5662                 }
5663                 break;
5664 
5665                 case java_awt_event_KeyEvent_KEY_RELEASED:
5666                 {
5667                     keyDownConsumed = FALSE;
5668                     bCharChanged = FALSE;
5669                 }
5670                 break;
5671 
5672                 case java_awt_event_KeyEvent_KEY_TYPED:
5673                 {
5674                     if (bCharChanged)
5675                     {
5676                         unicodeChar = modifiedChar;
5677                     }
5678                     else
5679                     {
5680                         unicodeChar = keyChar;
5681                     }
5682                     bCharChanged = FALSE;
5683 
5684                     // Disable forwarding KEY_TYPED messages to peers of
5685                     // disabled components
5686                     if (p->isRecursivelyEnabled()) {
5687                         // send the character back to the native window for
5688                         // processing. The WM_AWT_FORWARD_CHAR handler will send
5689                         // this character to DefWindowProc
5690                         if (!::PostMessage(p->GetHWnd(), WM_AWT_FORWARD_CHAR,
5691                             MAKEWPARAM(unicodeChar, FALSE), msg.lParam)) {
5692                             JNU_ThrowInternalError(env, "Message not posted, native event queue may be full.");
5693                         }
5694                     }
5695                     env->DeleteGlobalRef(self);
5696                     env->DeleteGlobalRef(event);
5697                     delete nhes;
5698                     return;
5699                 }
5700                 break;
5701 
5702                 default:
5703                     break;
5704                 }
5705             }
5706 
5707             // ignore all InputMethodEvents
5708             if (self && (pData = JNI_GET_PDATA(self)) &&
5709                 id >= java_awt_event_InputMethodEvent_INPUT_METHOD_FIRST &&
5710                 id <= java_awt_event_InputMethodEvent_INPUT_METHOD_LAST) {
5711                 env->DeleteGlobalRef(self);
5712                 env->DeleteGlobalRef(event);
5713                 delete nhes;
5714                 return;
5715             }
5716 
5717             // Create copy for local msg
5718             MSG* pCopiedMsg = new MSG;
5719             memmove(pCopiedMsg, &msg, sizeof(MSG));
5720             // Event handler deletes msg
5721             p->PostHandleEventMessage(pCopiedMsg, FALSE);
5722 
5723             env->DeleteGlobalRef(self);
5724             env->DeleteGlobalRef(event);
5725             delete nhes;
5726             return;
5727         }
5728 
5729         /* Forward any valid synthesized events.  Currently only mouse and
5730          * key events are supported.
5731          */
5732         if (self == NULL || (pData = JNI_GET_PDATA(self)) == NULL) {
5733             env->DeleteGlobalRef(self);
5734             env->DeleteGlobalRef(event);
5735             delete nhes;
5736             return;
5737         }
5738 
5739         AwtComponent* p = (AwtComponent*)pData;
5740         if (id >= java_awt_event_KeyEvent_KEY_FIRST &&
5741             id <= java_awt_event_KeyEvent_KEY_LAST) {
5742             p->SynthesizeKeyMessage(env, event);
5743         } else if (id >= java_awt_event_MouseEvent_MOUSE_FIRST &&
5744                    id <= java_awt_event_MouseEvent_MOUSE_LAST) {
5745             p->SynthesizeMouseMessage(env, event);
5746         }
5747     }
5748 
5749 ret:
5750     if (self != NULL) {
5751         env->DeleteGlobalRef(self);
5752     }
5753     if (event != NULL) {
5754         env->DeleteGlobalRef(event);
5755     }
5756 
5757     delete nhes;
5758 }
5759 
5760 void AwtComponent::_SetForeground(void *param)
5761 {
5762     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5763 
5764     SetColorStruct *scs = (SetColorStruct *)param;
5765     jobject self = scs->component;
5766     jint rgb = scs->rgb;
5767 
5768     AwtComponent *c = NULL;
5769 
5770     PDATA pData;
5771     JNI_CHECK_PEER_GOTO(self, ret);
5772     c = (AwtComponent *)pData;
5773     if (::IsWindow(c->GetHWnd()))
5774     {
5775         c->SetColor(PALETTERGB((rgb>>16)&0xff,
5776                                (rgb>>8)&0xff,
5777                                (rgb)&0xff));
5778         c->VerifyState();
5779     }
5780 ret:
5781     env->DeleteGlobalRef(self);
5782 
5783     delete scs;
5784 }
5785 
5786 void AwtComponent::_SetBackground(void *param)
5787 {
5788     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5789 
5790     SetColorStruct *scs = (SetColorStruct *)param;
5791     jobject self = scs->component;
5792     jint rgb = scs->rgb;
5793 
5794     AwtComponent *c = NULL;
5795 
5796     PDATA pData;
5797     JNI_CHECK_PEER_GOTO(self, ret);
5798     c = (AwtComponent *)pData;
5799     if (::IsWindow(c->GetHWnd()))
5800     {
5801         c->SetBackgroundColor(PALETTERGB((rgb>>16)&0xff,
5802                                          (rgb>>8)&0xff,
5803                                          (rgb)&0xff));
5804         c->VerifyState();
5805     }
5806 ret:
5807     env->DeleteGlobalRef(self);
5808 
5809     delete scs;
5810 }
5811 
5812 void AwtComponent::_SetFont(void *param)
5813 {
5814     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5815 
5816     SetFontStruct *sfs = (SetFontStruct *)param;
5817     jobject self = sfs->component;
5818     jobject font = sfs->font;
5819 
5820     AwtComponent *c = NULL;
5821 
5822     PDATA pData;
5823     JNI_CHECK_PEER_GOTO(self, ret);
5824     JNI_CHECK_NULL_GOTO(font, "null font", ret);
5825     c = (AwtComponent *)pData;
5826     if (::IsWindow(c->GetHWnd()))
5827     {
5828         AwtFont *awtFont = (AwtFont *)env->GetLongField(font, AwtFont::pDataID);
5829         if (awtFont == NULL) {
5830             /*arguments of AwtFont::Create are changed for multifont component */
5831             awtFont = AwtFont::Create(env, font);
5832         }
5833         env->SetLongField(font, AwtFont::pDataID, (jlong)awtFont);
5834 
5835         c->SetFont(awtFont);
5836     }
5837 ret:
5838     env->DeleteGlobalRef(self);
5839     env->DeleteGlobalRef(font);
5840 
5841     delete sfs;
5842 }
5843 
5844 // Sets or kills focus for a component.
5845 void AwtComponent::_SetFocus(void *param)
5846 {
5847     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5848 
5849     SetFocusStruct *sfs = (SetFocusStruct *)param;
5850     jobject self = sfs->component;
5851     jboolean doSetFocus = sfs->doSetFocus;
5852 
5853     AwtComponent *c = NULL;
5854 
5855     PDATA pData;
5856     JNI_CHECK_NULL_GOTO(self, "peer", ret);
5857     pData = JNI_GET_PDATA(self);
5858     if (pData == NULL) {
5859         // do nothing just return false
5860         goto ret;
5861     }
5862 
5863     c = (AwtComponent *)pData;
5864     if (::IsWindow(c->GetHWnd())) {
5865         c->SendMessage(WM_AWT_COMPONENT_SETFOCUS, (WPARAM)doSetFocus, 0);
5866     }
5867 ret:
5868     env->DeleteGlobalRef(self);
5869 
5870     delete sfs;
5871 }
5872 
5873 void AwtComponent::_Start(void *param)
5874 {
5875     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5876 
5877     jobject self = (jobject)param;
5878 
5879     AwtComponent *c = NULL;
5880 
5881     PDATA pData;
5882     JNI_CHECK_PEER_GOTO(self, ret);
5883     c = (AwtComponent *)pData;
5884     if (::IsWindow(c->GetHWnd()))
5885     {
5886         jobject target = c->GetTarget(env);
5887 
5888         /* Disable window if specified -- windows are enabled by default. */
5889         jboolean enabled = (jboolean)env->GetBooleanField(target,
5890                                                           AwtComponent::enabledID);
5891         if (!enabled) {
5892             ::EnableWindow(c->GetHWnd(), FALSE);
5893         }
5894 
5895         /* The peer is now ready for callbacks, since this is the last
5896          * initialization call
5897          */
5898         c->EnableCallbacks(TRUE);
5899 
5900         // Fix 4745222: we need to invalidate region since we validated it before initialization.
5901         ::InvalidateRgn(c->GetHWnd(), NULL, FALSE);
5902 
5903         // Fix 4530093: WM_PAINT after EnableCallbacks
5904         ::UpdateWindow(c->GetHWnd());
5905 
5906         env->DeleteLocalRef(target);
5907     }
5908 ret:
5909     env->DeleteGlobalRef(self);
5910 }
5911 
5912 void AwtComponent::_BeginValidate(void *param)
5913 {
5914     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5915     if (AwtToolkit::IsMainThread()) {
5916         jobject self = (jobject)param;
5917         if (self != NULL) {
5918             PDATA pData = JNI_GET_PDATA(self);
5919             if (pData) {
5920                 AwtComponent *c = (AwtComponent *)pData;
5921                 if (::IsWindow(c->GetHWnd())) {
5922                     c->SendMessage(WM_AWT_BEGIN_VALIDATE);
5923                 }
5924             }
5925             env->DeleteGlobalRef(self);
5926         }
5927     } else {
5928         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_BeginValidate, param);
5929     }
5930 }
5931 
5932 void AwtComponent::_EndValidate(void *param)
5933 {
5934     if (AwtToolkit::IsMainThread()) {
5935         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5936         jobject self = (jobject)param;
5937         if (self != NULL) {
5938             PDATA pData = JNI_GET_PDATA(self);
5939             if (pData) {
5940                 AwtComponent *c = (AwtComponent *)pData;
5941                 if (::IsWindow(c->GetHWnd())) {
5942                     c->SendMessage(WM_AWT_END_VALIDATE);
5943                 }
5944             }
5945             env->DeleteGlobalRef(self);
5946         }
5947     } else {
5948         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_EndValidate, param);
5949     }
5950 }
5951 
5952 void AwtComponent::_UpdateWindow(void *param)
5953 {
5954     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5955     if (AwtToolkit::IsMainThread()) {
5956         jobject self = (jobject)param;
5957         AwtComponent *c = NULL;
5958         PDATA pData;
5959         JNI_CHECK_PEER_GOTO(self, ret);
5960         c = (AwtComponent *)pData;
5961         if (::IsWindow(c->GetHWnd())) {
5962             ::UpdateWindow(c->GetHWnd());
5963         }
5964 ret:
5965         env->DeleteGlobalRef(self);
5966     } else {
5967         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_UpdateWindow, param);
5968     }
5969 }
5970 
5971 jlong AwtComponent::_AddNativeDropTarget(void *param)
5972 {
5973     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5974 
5975     jobject self = (jobject)param;
5976 
5977     jlong result = 0;
5978     AwtComponent *c = NULL;
5979 
5980     PDATA pData;
5981     JNI_CHECK_PEER_GOTO(self, ret);
5982     c = (AwtComponent *)pData;
5983     if (::IsWindow(c->GetHWnd()))
5984     {
5985         result = (jlong)(c->CreateDropTarget(env));
5986     }
5987 ret:
5988     env->DeleteGlobalRef(self);
5989 
5990     return result;
5991 }
5992 
5993 void AwtComponent::_RemoveNativeDropTarget(void *param)
5994 {
5995     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
5996 
5997     jobject self = (jobject)param;
5998 
5999     AwtComponent *c = NULL;
6000 
6001     PDATA pData;
6002     JNI_CHECK_PEER_GOTO(self, ret);
6003     c = (AwtComponent *)pData;
6004     if (::IsWindow(c->GetHWnd()))
6005     {
6006         c->DestroyDropTarget();
6007     }
6008 ret:
6009     env->DeleteGlobalRef(self);
6010 }
6011 
6012 jintArray AwtComponent::_CreatePrintedPixels(void *param)
6013 {
6014     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6015 
6016     CreatePrintedPixelsStruct *cpps = (CreatePrintedPixelsStruct *)param;
6017     jobject self = cpps->component;
6018 
6019     jintArray result = NULL;
6020     AwtComponent *c = NULL;
6021 
6022     PDATA pData;
6023     JNI_CHECK_PEER_GOTO(self, ret);
6024     c = (AwtComponent *)pData;
6025     if (::IsWindow(c->GetHWnd()))
6026     {
6027         result = (jintArray)c->SendMessage(WM_AWT_CREATE_PRINTED_PIXELS, (WPARAM)cpps, 0);
6028     }
6029 ret:
6030     env->DeleteGlobalRef(self);
6031 
6032     delete cpps;
6033     return result; // this reference is global
6034 }
6035 
6036 jboolean AwtComponent::_IsObscured(void *param)
6037 {
6038     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6039 
6040     jobject self = (jobject)param;
6041 
6042     jboolean result = JNI_FALSE;
6043     AwtComponent *c = NULL;
6044 
6045     PDATA pData;
6046     JNI_CHECK_PEER_GOTO(self, ret);
6047 
6048     c = (AwtComponent *)pData;
6049 
6050     if (::IsWindow(c->GetHWnd()))
6051     {
6052         HWND hWnd = c->GetHWnd();
6053         HDC hDC = ::GetDC(hWnd);
6054         RECT clipbox;
6055         int callresult = ::GetClipBox(hDC, &clipbox);
6056         switch(callresult) {
6057             case NULLREGION :
6058                 result = JNI_FALSE;
6059                 break;
6060             case SIMPLEREGION : {
6061                 RECT windowRect;
6062                 if (!::GetClientRect(hWnd, &windowRect)) {
6063                     result = JNI_TRUE;
6064                 } else {
6065                     result  = (jboolean)((clipbox.bottom != windowRect.bottom)
6066                         || (clipbox.left != windowRect.left)
6067                         || (clipbox.right != windowRect.right)
6068                         || (clipbox.top != windowRect.top));
6069                 }
6070                 break;
6071             }
6072             case COMPLEXREGION :
6073             default :
6074                 result = JNI_TRUE;
6075                 break;
6076         }
6077         ::ReleaseDC(hWnd, hDC);
6078     }
6079 ret:
6080     env->DeleteGlobalRef(self);
6081 
6082     return result;
6083 }
6084 
6085 jboolean AwtComponent::_NativeHandlesWheelScrolling(void *param)
6086 {
6087     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6088 
6089     jobject self = (jobject)param;
6090 
6091     jboolean result = JNI_FALSE;
6092     AwtComponent *c = NULL;
6093 
6094     PDATA pData;
6095     JNI_CHECK_PEER_GOTO(self, ret);
6096     c = (AwtComponent *)pData;
6097     if (::IsWindow(c->GetHWnd()))
6098     {
6099         result = JNI_IS_TRUE(c->InheritsNativeMouseWheelBehavior());
6100     }
6101 ret:
6102     env->DeleteGlobalRef(self);
6103 
6104     return result;
6105 }
6106 
6107 void AwtComponent::SetParent(void * param) {
6108     if (AwtToolkit::IsMainThread()) {
6109         AwtComponent** comps = (AwtComponent**)param;
6110         if ((comps[0] != NULL) && (comps[1] != NULL)) {
6111             HWND selfWnd = comps[0]->GetHWnd();
6112             HWND parentWnd = comps[1]->GetHWnd();
6113             if (::IsWindow(selfWnd) && ::IsWindow(parentWnd)) {
6114                 // Shouldn't trigger native focus change
6115                 // (only the proxy may be the native focus owner).
6116                 ::SetParent(selfWnd, parentWnd);
6117             }
6118         }
6119         delete[] comps;
6120     } else {
6121         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::SetParent, param);
6122     }
6123 }
6124 
6125 void AwtComponent::_SetRectangularShape(void *param)
6126 {
6127     if (!AwtToolkit::IsMainThread()) {
6128         AwtToolkit::GetInstance().InvokeFunction(AwtComponent::_SetRectangularShape, param);
6129     } else {
6130         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6131 
6132         SetRectangularShapeStruct *data = (SetRectangularShapeStruct *)param;
6133         jobject self = data->component;
6134         jint x1 = data->x1;
6135         jint x2 = data->x2;
6136         jint y1 = data->y1;
6137         jint y2 = data->y2;
6138         jobject region = data->region;
6139 
6140         AwtComponent *c = NULL;
6141 
6142         PDATA pData;
6143         JNI_CHECK_PEER_GOTO(self, ret);
6144 
6145         c = (AwtComponent *)pData;
6146         if (::IsWindow(c->GetHWnd())) {
6147             HRGN hRgn = NULL;
6148 
6149             // If all the params are zeros, the shape must be simply reset.
6150             // Otherwise, convert it into a region.
6151             if (region || x1 || x2 || y1 || y2) {
6152                 RECT_T rects[256];
6153                 RECT_T *pRect = rects;
6154 
6155                 const int numrects = RegionToYXBandedRectangles(env, x1, y1, x2, y2,
6156                         region, &pRect, sizeof(rects)/sizeof(rects[0]));
6157                 if (!pRect) {
6158                     // RegionToYXBandedRectangles doesn't use safe_Malloc(),
6159                     // so throw the exception explicitly
6160                     throw std::bad_alloc();
6161                 }
6162 
6163                 RGNDATA *pRgnData = (RGNDATA *) SAFE_SIZE_STRUCT_ALLOC(safe_Malloc,
6164                         sizeof(RGNDATAHEADER), sizeof(RECT_T), numrects);
6165                 memcpy((BYTE*)pRgnData + sizeof(RGNDATAHEADER), pRect, sizeof(RECT_T) * numrects);
6166                 if (pRect != rects) {
6167                     free(pRect);
6168                 }
6169                 pRect = NULL;
6170 
6171                 RGNDATAHEADER *pRgnHdr = (RGNDATAHEADER *) pRgnData;
6172                 pRgnHdr->dwSize = sizeof(RGNDATAHEADER);
6173                 pRgnHdr->iType = RDH_RECTANGLES;
6174                 pRgnHdr->nRgnSize = 0;
6175                 pRgnHdr->rcBound.top = 0;
6176                 pRgnHdr->rcBound.left = 0;
6177                 pRgnHdr->rcBound.bottom = LONG(y2 - y1);
6178                 pRgnHdr->rcBound.right = LONG(x2 - x1);
6179                 pRgnHdr->nCount = numrects;
6180 
6181                 hRgn = ::ExtCreateRegion(NULL,
6182                         sizeof(RGNDATAHEADER) + sizeof(RECT_T) * pRgnHdr->nCount, pRgnData);
6183 
6184                 free(pRgnData);
6185             }
6186 
6187             ::SetWindowRgn(c->GetHWnd(), hRgn, TRUE);
6188         }
6189 
6190 ret:
6191         env->DeleteGlobalRef(self);
6192         if (region) {
6193             env->DeleteGlobalRef(region);
6194         }
6195 
6196         delete data;
6197     }
6198 }
6199 
6200 void AwtComponent::_SetZOrder(void *param) {
6201     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6202 
6203     SetZOrderStruct *data = (SetZOrderStruct *)param;
6204     jobject self = data->component;
6205     HWND above = HWND_TOP;
6206     if (data->above != 0) {
6207         above = reinterpret_cast<HWND>(data->above);
6208     }
6209 
6210     AwtComponent *c = NULL;
6211 
6212     PDATA pData;
6213     JNI_CHECK_PEER_GOTO(self, ret);
6214 
6215     c = (AwtComponent *)pData;
6216     if (::IsWindow(c->GetHWnd())) {
6217         ::SetWindowPos(c->GetHWnd(), above, 0, 0, 0, 0,
6218                        SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE | SWP_ASYNCWINDOWPOS);
6219     }
6220 
6221 ret:
6222     env->DeleteGlobalRef(self);
6223 
6224     delete data;
6225 }
6226 
6227 void AwtComponent::PostUngrabEvent() {
6228     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6229     jobject target = GetTarget(env);
6230     jobject event = JNU_NewObjectByName(env, "sun/awt/UngrabEvent", "(Ljava/awt/Component;)V",
6231                                         target);
6232     if (safe_ExceptionOccurred(env)) {
6233         env->ExceptionDescribe();
6234         env->ExceptionClear();
6235     }
6236     env->DeleteLocalRef(target);
6237     if (event != NULL) {
6238         SendEvent(event);
6239         env->DeleteLocalRef(event);
6240     }
6241 }
6242 
6243 void AwtComponent::SetFocusedWindow(HWND window)
6244 {
6245     HWND old = sm_focusedWindow;
6246     sm_focusedWindow = window;
6247 
6248     AwtWindow::FocusedWindowChanged(old, window);
6249 }
6250 
6251 /************************************************************************
6252  * Component native methods
6253  */
6254 
6255 extern "C" {
6256 
6257 /**
6258  * This method is called from the WGL pipeline when it needs to retrieve
6259  * the HWND associated with a ComponentPeer's C++ level object.
6260  */
6261 HWND
6262 AwtComponent_GetHWnd(JNIEnv *env, jlong pData)
6263 {
6264     AwtComponent *p = (AwtComponent *)jlong_to_ptr(pData);
6265     if (p == NULL) {
6266         return (HWND)0;
6267     }
6268     return p->GetHWnd();
6269 }
6270 
6271 static void _GetInsets(void* param)
6272 {
6273     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
6274 
6275     GetInsetsStruct *gis = (GetInsetsStruct *)param;
6276     jobject self = gis->window;
6277 
6278     gis->insets->left = gis->insets->top =
6279         gis->insets->right = gis->insets->bottom = 0;
6280 
6281     PDATA pData;
6282     JNI_CHECK_PEER_GOTO(self, ret);
6283     AwtComponent *component = (AwtComponent *)pData;
6284 
6285     component->GetInsets(gis->insets);
6286 
6287   ret:
6288     env->DeleteGlobalRef(self);
6289     delete gis;
6290 }
6291 
6292 /**
6293  * This method is called from the WGL pipeline when it needs to retrieve
6294  * the insets associated with a ComponentPeer's C++ level object.
6295  */
6296 void AwtComponent_GetInsets(JNIEnv *env, jobject peer, RECT *insets)
6297 {
6298     TRY;
6299 
6300     GetInsetsStruct *gis = new GetInsetsStruct;
6301     gis->window = env->NewGlobalRef(peer);
6302     gis->insets = insets;
6303 
6304     AwtToolkit::GetInstance().InvokeFunction(_GetInsets, gis);
6305     // global refs and mds are deleted in _UpdateWindow
6306 
6307     CATCH_BAD_ALLOC;
6308 
6309 }
6310 
6311 JNIEXPORT void JNICALL
6312 Java_java_awt_Component_initIDs(JNIEnv *env, jclass cls)
6313 {
6314     TRY;
6315     jclass inputEventClazz = env->FindClass("java/awt/event/InputEvent");
6316     CHECK_NULL(inputEventClazz);
6317     jmethodID getButtonDownMasksID = env->GetStaticMethodID(inputEventClazz, "getButtonDownMasks", "()[I");
6318     CHECK_NULL(getButtonDownMasksID);
6319     jintArray obj = (jintArray)env->CallStaticObjectMethod(inputEventClazz, getButtonDownMasksID);
6320     jint * tmp = env->GetIntArrayElements(obj, JNI_FALSE);
6321     CHECK_NULL(tmp);
6322     jsize len = env->GetArrayLength(obj);
6323     AwtComponent::masks = SAFE_SIZE_NEW_ARRAY(jint, len);
6324     for (int i = 0; i < len; i++) {
6325         AwtComponent::masks[i] = tmp[i];
6326     }
6327     env->ReleaseIntArrayElements(obj, tmp, 0);
6328     env->DeleteLocalRef(obj);
6329 
6330     /* class ids */
6331     jclass peerCls = env->FindClass("sun/awt/windows/WComponentPeer");
6332 
6333     DASSERT(peerCls);
6334     CHECK_NULL(peerCls);
6335 
6336     /* field ids */
6337     AwtComponent::peerID =
6338       env->GetFieldID(cls, "peer", "Ljava/awt/peer/ComponentPeer;");
6339     DASSERT(AwtComponent::peerID);
6340     CHECK_NULL(AwtComponent::peerID);
6341 
6342     AwtComponent::xID = env->GetFieldID(cls, "x", "I");
6343     DASSERT(AwtComponent::xID);
6344     CHECK_NULL(AwtComponent::xID);
6345 
6346     AwtComponent::yID = env->GetFieldID(cls, "y", "I");
6347     DASSERT(AwtComponent::yID);
6348     CHECK_NULL(AwtComponent::yID);
6349 
6350     AwtComponent::heightID = env->GetFieldID(cls, "height", "I");
6351     DASSERT(AwtComponent::heightID);
6352     CHECK_NULL(AwtComponent::heightID);
6353 
6354     AwtComponent::widthID = env->GetFieldID(cls, "width", "I");
6355     DASSERT(AwtComponent::widthID);
6356     CHECK_NULL(AwtComponent::widthID);
6357 
6358     AwtComponent::visibleID = env->GetFieldID(cls, "visible", "Z");
6359     DASSERT(AwtComponent::visibleID);
6360     CHECK_NULL(AwtComponent::visibleID);
6361 
6362     AwtComponent::backgroundID =
6363         env->GetFieldID(cls, "background", "Ljava/awt/Color;");
6364     DASSERT(AwtComponent::backgroundID);
6365     CHECK_NULL(AwtComponent::backgroundID);
6366 
6367     AwtComponent::foregroundID =
6368         env->GetFieldID(cls, "foreground", "Ljava/awt/Color;");
6369     DASSERT(AwtComponent::foregroundID);
6370     CHECK_NULL(AwtComponent::foregroundID);
6371 
6372     AwtComponent::enabledID = env->GetFieldID(cls, "enabled", "Z");
6373     DASSERT(AwtComponent::enabledID);
6374     CHECK_NULL(AwtComponent::enabledID);
6375 
6376     AwtComponent::parentID = env->GetFieldID(cls, "parent", "Ljava/awt/Container;");
6377     DASSERT(AwtComponent::parentID);
6378     CHECK_NULL(AwtComponent::parentID);
6379 
6380     AwtComponent::graphicsConfigID =
6381      env->GetFieldID(cls, "graphicsConfig", "Ljava/awt/GraphicsConfiguration;");
6382     DASSERT(AwtComponent::graphicsConfigID);
6383     CHECK_NULL(AwtComponent::graphicsConfigID);
6384 
6385     AwtComponent::focusableID = env->GetFieldID(cls, "focusable", "Z");
6386     DASSERT(AwtComponent::focusableID);
6387     CHECK_NULL(AwtComponent::focusableID);
6388 
6389     AwtComponent::appContextID = env->GetFieldID(cls, "appContext",
6390                                                  "Lsun/awt/AppContext;");
6391     DASSERT(AwtComponent::appContextID);
6392     CHECK_NULL(AwtComponent::appContextID);
6393 
6394     AwtComponent::peerGCID = env->GetFieldID(peerCls, "winGraphicsConfig",
6395                                         "Lsun/awt/Win32GraphicsConfig;");
6396     DASSERT(AwtComponent::peerGCID);
6397     CHECK_NULL(AwtComponent::peerGCID);
6398 
6399     AwtComponent::hwndID = env->GetFieldID(peerCls, "hwnd", "J");
6400     DASSERT(AwtComponent::hwndID);
6401     CHECK_NULL(AwtComponent::hwndID);
6402 
6403     AwtComponent::cursorID = env->GetFieldID(cls, "cursor", "Ljava/awt/Cursor;");
6404     DASSERT(AwtComponent::cursorID);
6405     CHECK_NULL(AwtComponent::cursorID);
6406 
6407     /* method ids */
6408     AwtComponent::getFontMID =
6409         env->GetMethodID(cls, "getFont_NoClientCode", "()Ljava/awt/Font;");
6410     DASSERT(AwtComponent::getFontMID);
6411     CHECK_NULL(AwtComponent::getFontMID);
6412 
6413     AwtComponent::getToolkitMID =
6414         env->GetMethodID(cls, "getToolkitImpl", "()Ljava/awt/Toolkit;");
6415     DASSERT(AwtComponent::getToolkitMID);
6416     CHECK_NULL(AwtComponent::getToolkitMID);
6417 
6418     AwtComponent::isEnabledMID = env->GetMethodID(cls, "isEnabledImpl", "()Z");
6419     DASSERT(AwtComponent::isEnabledMID);
6420     CHECK_NULL(AwtComponent::isEnabledMID);
6421 
6422     AwtComponent::getLocationOnScreenMID =
6423         env->GetMethodID(cls, "getLocationOnScreen_NoTreeLock", "()Ljava/awt/Point;");
6424     DASSERT(AwtComponent::getLocationOnScreenMID);
6425     CHECK_NULL(AwtComponent::getLocationOnScreenMID);
6426 
6427     AwtComponent::replaceSurfaceDataMID =
6428         env->GetMethodID(peerCls, "replaceSurfaceData", "()V");
6429     DASSERT(AwtComponent::replaceSurfaceDataMID);
6430     CHECK_NULL(AwtComponent::replaceSurfaceDataMID);
6431 
6432     AwtComponent::replaceSurfaceDataLaterMID =
6433         env->GetMethodID(peerCls, "replaceSurfaceDataLater", "()V");
6434     DASSERT(AwtComponent::replaceSurfaceDataLaterMID);
6435     CHECK_NULL(AwtComponent::replaceSurfaceDataLaterMID);
6436 
6437     AwtComponent::disposeLaterMID = env->GetMethodID(peerCls, "disposeLater", "()V");
6438     DASSERT(AwtComponent::disposeLaterMID);
6439     CHECK_NULL(AwtComponent::disposeLaterMID);
6440 
6441     CATCH_BAD_ALLOC;
6442 }
6443 
6444 } /* extern "C" */
6445 
6446 
6447 /************************************************************************
6448  * ComponentPeer native methods
6449  */
6450 
6451 extern "C" {
6452 
6453 /*
6454  * Class:     sun_awt_windows_WComponentPeer
6455  * Method:    pShow
6456  * Signature: ()V
6457  */
6458 JNIEXPORT void JNICALL
6459 Java_sun_awt_windows_WComponentPeer_pShow(JNIEnv *env, jobject self)
6460 {
6461     TRY;
6462 
6463     jobject selfGlobalRef = env->NewGlobalRef(self);
6464 
6465     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Show, (void *)selfGlobalRef);
6466     // selfGlobalRef is deleted in _Show
6467 
6468     CATCH_BAD_ALLOC;
6469 }
6470 
6471 /*
6472  * Class:     sun_awt_windows_WComponentPeer
6473  * Method:    hide
6474  * Signature: ()V
6475  */
6476 JNIEXPORT void JNICALL
6477 Java_sun_awt_windows_WComponentPeer_hide(JNIEnv *env, jobject self)
6478 {
6479     TRY;
6480 
6481     jobject selfGlobalRef = env->NewGlobalRef(self);
6482 
6483     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Hide, (void *)selfGlobalRef);
6484     // selfGlobalRef is deleted in _Hide
6485 
6486     CATCH_BAD_ALLOC;
6487 }
6488 
6489 /*
6490  * Class:     sun_awt_windows_WComponentPeer
6491  * Method:    enable
6492  * Signature: ()V
6493  */
6494 JNIEXPORT void JNICALL
6495 Java_sun_awt_windows_WComponentPeer_enable(JNIEnv *env, jobject self)
6496 {
6497     TRY;
6498 
6499     jobject selfGlobalRef = env->NewGlobalRef(self);
6500 
6501     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Enable, (void *)selfGlobalRef);
6502     // selfGlobalRef is deleted in _Enable
6503 
6504     CATCH_BAD_ALLOC;
6505 }
6506 
6507 /*
6508  * Class:     sun_awt_windows_WComponentPeer
6509  * Method:    disable
6510  * Signature: ()V
6511  */
6512 JNIEXPORT void JNICALL
6513 Java_sun_awt_windows_WComponentPeer_disable(JNIEnv *env, jobject self)
6514 {
6515     TRY;
6516 
6517     jobject selfGlobalRef = env->NewGlobalRef(self);
6518 
6519     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Disable, (void *)selfGlobalRef);
6520     // selfGlobalRef is deleted in _Disable
6521 
6522     CATCH_BAD_ALLOC;
6523 }
6524 
6525 /*
6526  * Class:     sun_awt_windows_WComponentPeer
6527  * Method:    getLocationOnScreen
6528  * Signature: ()Ljava/awt/Point;
6529  */
6530 JNIEXPORT jobject JNICALL
6531 Java_sun_awt_windows_WComponentPeer_getLocationOnScreen(JNIEnv *env, jobject self)
6532 {
6533     TRY;
6534 
6535     jobject selfGlobalRef = env->NewGlobalRef(self);
6536 
6537     jobject resultGlobalRef = (jobject)AwtToolkit::GetInstance().SyncCall(
6538         (void*(*)(void*))AwtComponent::_GetLocationOnScreen, (void *)selfGlobalRef);
6539     // selfGlobalRef is deleted in _GetLocationOnScreen
6540     if (resultGlobalRef != NULL)
6541     {
6542         jobject resultLocalRef = env->NewLocalRef(resultGlobalRef);
6543         env->DeleteGlobalRef(resultGlobalRef);
6544         return resultLocalRef;
6545     }
6546 
6547     return NULL;
6548 
6549     CATCH_BAD_ALLOC_RET(NULL);
6550 }
6551 
6552 /*
6553  * Class:     sun_awt_windows_WComponentPeer
6554  * Method:    reshape
6555  * Signature: (IIII)V
6556  */
6557 JNIEXPORT void JNICALL
6558 Java_sun_awt_windows_WComponentPeer_reshape(JNIEnv *env, jobject self,
6559                                             jint x, jint y, jint w, jint h)
6560 {
6561     TRY;
6562 
6563     ReshapeStruct *rs = new ReshapeStruct;
6564     rs->component = env->NewGlobalRef(self);
6565     rs->x = x;
6566     rs->y = y;
6567     rs->w = w;
6568     rs->h = h;
6569 
6570     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Reshape, rs);
6571     // global ref and rs are deleted in _Reshape
6572 
6573     CATCH_BAD_ALLOC;
6574 }
6575 
6576 /*
6577  * Class:     sun_awt_windows_WComponentPeer
6578  * Method:    reshape
6579  * Signature: (IIII)V
6580  */
6581 JNIEXPORT void JNICALL
6582 Java_sun_awt_windows_WComponentPeer_reshapeNoCheck(JNIEnv *env, jobject self,
6583                                             jint x, jint y, jint w, jint h)
6584 {
6585     TRY;
6586 
6587     ReshapeStruct *rs = new ReshapeStruct;
6588     rs->component = env->NewGlobalRef(self);
6589     rs->x = x;
6590     rs->y = y;
6591     rs->w = w;
6592     rs->h = h;
6593 
6594     AwtToolkit::GetInstance().SyncCall(AwtComponent::_ReshapeNoCheck, rs);
6595     // global ref and rs are deleted in _ReshapeNoCheck
6596 
6597     CATCH_BAD_ALLOC;
6598 }
6599 
6600 
6601 /*
6602  * Class:     sun_awt_windows_WComponentPeer
6603  * Method:    nativeHandleEvent
6604  * Signature: (Ljava/awt/AWTEvent;)V
6605  */
6606 JNIEXPORT void JNICALL
6607 Java_sun_awt_windows_WComponentPeer_nativeHandleEvent(JNIEnv *env,
6608                                                       jobject self,
6609                                                       jobject event)
6610 {
6611     TRY;
6612 
6613     jobject selfGlobalRef = env->NewGlobalRef(self);
6614     jobject eventGlobalRef = env->NewGlobalRef(event);
6615 
6616     NativeHandleEventStruct *nhes = new NativeHandleEventStruct;
6617     nhes->component = selfGlobalRef;
6618     nhes->event = eventGlobalRef;
6619 
6620     AwtToolkit::GetInstance().SyncCall(AwtComponent::_NativeHandleEvent, nhes);
6621     // global refs and nhes are deleted in _NativeHandleEvent
6622 
6623     CATCH_BAD_ALLOC;
6624 }
6625 
6626 /*
6627  * Class:     sun_awt_windows_WComponentPeer
6628  * Method:    _dispose
6629  * Signature: ()V
6630  */
6631 JNIEXPORT void JNICALL
6632 Java_sun_awt_windows_WComponentPeer__1dispose(JNIEnv *env, jobject self)
6633 {
6634     TRY_NO_HANG;
6635 
6636     AwtObject::_Dispose(self);
6637 
6638     CATCH_BAD_ALLOC;
6639 }
6640 
6641 /*
6642  * Class:     sun_awt_windows_WComponentPeer
6643  * Method:    _setForeground
6644  * Signature: (I)V
6645  */
6646 JNIEXPORT void JNICALL
6647 Java_sun_awt_windows_WComponentPeer__1setForeground(JNIEnv *env, jobject self,
6648                                                     jint rgb)
6649 {
6650     TRY;
6651 
6652     jobject selfGlobalRef = env->NewGlobalRef(self);
6653 
6654     SetColorStruct *scs = new SetColorStruct;
6655     scs->component = selfGlobalRef;
6656     scs->rgb = rgb;
6657 
6658     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetForeground, scs);
6659     // selfGlobalRef and scs are deleted in _SetForeground()
6660 
6661     CATCH_BAD_ALLOC;
6662 }
6663 
6664 /*
6665  * Class:     sun_awt_windows_WComponentPeer
6666  * Method:    _setBackground
6667  * Signature: (I)V
6668  */
6669 JNIEXPORT void JNICALL
6670 Java_sun_awt_windows_WComponentPeer__1setBackground(JNIEnv *env, jobject self,
6671                                                     jint rgb)
6672 {
6673     TRY;
6674 
6675     jobject selfGlobalRef = env->NewGlobalRef(self);
6676 
6677     SetColorStruct *scs = new SetColorStruct;
6678     scs->component = selfGlobalRef;
6679     scs->rgb = rgb;
6680 
6681     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetBackground, scs);
6682     // selfGlobalRef and scs are deleted in _SetBackground()
6683 
6684     CATCH_BAD_ALLOC;
6685 }
6686 
6687 /*
6688  * Class:     sun_awt_windows_WComponentPeer
6689  * Method:    _setFont
6690  * Signature: (Ljava/awt/Font;)V
6691  */
6692 JNIEXPORT void JNICALL
6693 Java_sun_awt_windows_WComponentPeer__1setFont(JNIEnv *env, jobject self,
6694                         jobject font)
6695 {
6696     TRY;
6697 
6698     jobject selfGlobalRef = env->NewGlobalRef(self);
6699     jobject fontGlobalRef = env->NewGlobalRef(font);
6700 
6701     SetFontStruct *sfs = new SetFontStruct;
6702     sfs->component = selfGlobalRef;
6703     sfs->font = fontGlobalRef;
6704 
6705     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetFont, sfs);
6706     // global refs and sfs are deleted in _SetFont()
6707 
6708     CATCH_BAD_ALLOC;
6709 }
6710 
6711 /*
6712  * Class:     sun_awt_windows_WComponentPeer
6713  * Method:    focusGained
6714  * Signature: (Z)
6715  */
6716 JNIEXPORT void JNICALL Java_sun_awt_windows_WComponentPeer_setFocus
6717     (JNIEnv *env, jobject self, jboolean doSetFocus)
6718 {
6719     TRY;
6720 
6721     jobject selfGlobalRef = env->NewGlobalRef(self);
6722 
6723     SetFocusStruct *sfs = new SetFocusStruct;
6724     sfs->component = selfGlobalRef;
6725     sfs->doSetFocus = doSetFocus;
6726 
6727     AwtToolkit::GetInstance().SyncCall(
6728         (void*(*)(void*))AwtComponent::_SetFocus, sfs);
6729     // global refs and self are deleted in _SetFocus
6730 
6731     CATCH_BAD_ALLOC;
6732 }
6733 
6734 /*
6735  * Class:     sun_awt_windows_WComponentPeer
6736  * Method:    start
6737  * Signature: ()V
6738  */
6739 JNIEXPORT void JNICALL
6740 Java_sun_awt_windows_WComponentPeer_start(JNIEnv *env, jobject self)
6741 {
6742     TRY;
6743 
6744     jobject selfGlobalRef = env->NewGlobalRef(self);
6745 
6746     AwtToolkit::GetInstance().SyncCall(AwtComponent::_Start, (void *)selfGlobalRef);
6747     // selfGlobalRef is deleted in _Start
6748 
6749     CATCH_BAD_ALLOC;
6750 }
6751 
6752 /*
6753  * Class:     sun_awt_windows_WComponentPeer
6754  * Method:    beginValidate
6755  * Signature: ()V
6756  */
6757 JNIEXPORT void JNICALL
6758 Java_sun_awt_windows_WComponentPeer_beginValidate(JNIEnv *env, jobject self)
6759 {
6760     TRY;
6761 
6762     jobject selfGlobalRef = env->NewGlobalRef(self);
6763 
6764     AwtToolkit::GetInstance().SyncCall(AwtComponent::_BeginValidate, (void *)selfGlobalRef);
6765     // selfGlobalRef is deleted in _BeginValidate
6766 
6767     CATCH_BAD_ALLOC;
6768 }
6769 
6770 /*
6771  * Class:     sun_awt_windows_WComponentPeer
6772  * Method:    endValidate
6773  * Signature: ()V
6774  */
6775 JNIEXPORT void JNICALL
6776 Java_sun_awt_windows_WComponentPeer_endValidate(JNIEnv *env, jobject self)
6777 {
6778     TRY;
6779 
6780     jobject selfGlobalRef = env->NewGlobalRef(self);
6781 
6782     AwtToolkit::GetInstance().SyncCall(AwtComponent::_EndValidate, (void *)selfGlobalRef);
6783     // selfGlobalRef is deleted in _EndValidate
6784 
6785     CATCH_BAD_ALLOC;
6786 }
6787 
6788 JNIEXPORT void JNICALL
6789 Java_sun_awt_windows_WComponentPeer_updateWindow(JNIEnv *env, jobject self)
6790 {
6791     TRY;
6792 
6793     jobject selfGlobalRef = env->NewGlobalRef(self);
6794 
6795     AwtToolkit::GetInstance().SyncCall(AwtComponent::_UpdateWindow, (void *)selfGlobalRef);
6796     // selfGlobalRef is deleted in _UpdateWindow
6797 
6798     CATCH_BAD_ALLOC;
6799 }
6800 
6801 /*
6802  * Class:     sun_awt_windows_WComponentPeer
6803  * Method:    addNativeDropTarget
6804  * Signature: ()L
6805  */
6806 
6807 JNIEXPORT jlong JNICALL
6808 Java_sun_awt_windows_WComponentPeer_addNativeDropTarget(JNIEnv *env,
6809                                                         jobject self)
6810 {
6811     TRY;
6812 
6813     jobject selfGlobalRef = env->NewGlobalRef(self);
6814 
6815     return ptr_to_jlong(AwtToolkit::GetInstance().SyncCall(
6816         (void*(*)(void*))AwtComponent::_AddNativeDropTarget,
6817         (void *)selfGlobalRef));
6818     // selfGlobalRef is deleted in _AddNativeDropTarget
6819 
6820     CATCH_BAD_ALLOC_RET(0);
6821 }
6822 
6823 /*
6824  * Class:     sun_awt_windows_WComponentPeer
6825  * Method:    removeNativeDropTarget
6826  * Signature: ()V
6827  */
6828 
6829 JNIEXPORT void JNICALL
6830 Java_sun_awt_windows_WComponentPeer_removeNativeDropTarget(JNIEnv *env,
6831                                                            jobject self)
6832 {
6833     TRY;
6834 
6835     jobject selfGlobalRef = env->NewGlobalRef(self);
6836 
6837     AwtToolkit::GetInstance().SyncCall(
6838         AwtComponent::_RemoveNativeDropTarget, (void *)selfGlobalRef);
6839     // selfGlobalRef is deleted in _RemoveNativeDropTarget
6840 
6841     CATCH_BAD_ALLOC;
6842 }
6843 
6844 /*
6845  * Class:     sun_awt_windows_WComponentPeer
6846  * Method:    getTargetGC
6847  * Signature: ()Ljava/awt/GraphicsConfiguration;
6848  */
6849 JNIEXPORT jobject JNICALL
6850 Java_sun_awt_windows_WComponentPeer_getTargetGC(JNIEnv* env, jobject theThis)
6851 {
6852     TRY;
6853 
6854     jobject targetObj;
6855     jobject gc = 0;
6856 
6857     targetObj = env->GetObjectField(theThis, AwtObject::targetID);
6858     DASSERT(targetObj);
6859 
6860     gc = env->GetObjectField(targetObj, AwtComponent::graphicsConfigID);
6861     return gc;
6862 
6863     CATCH_BAD_ALLOC_RET(NULL);
6864 }
6865 
6866 /*
6867  * Class:     sun_awt_windows_WComponentPeer
6868  * Method:    createPrintedPixels
6869  * Signature: (IIIIII)I[
6870  */
6871 JNIEXPORT jintArray JNICALL
6872 Java_sun_awt_windows_WComponentPeer_createPrintedPixels(JNIEnv* env,
6873     jobject self, jint srcX, jint srcY, jint srcW, jint srcH, jint alpha)
6874 {
6875     TRY;
6876 
6877     jobject selfGlobalRef = env->NewGlobalRef(self);
6878 
6879     CreatePrintedPixelsStruct *cpps = new CreatePrintedPixelsStruct;
6880     cpps->component = selfGlobalRef;
6881     cpps->srcx = srcX;
6882     cpps->srcy = srcY;
6883     cpps->srcw = srcW;
6884     cpps->srch = srcH;
6885     cpps->alpha = alpha;
6886 
6887     jintArray globalRef = (jintArray)AwtToolkit::GetInstance().SyncCall(
6888         (void*(*)(void*))AwtComponent::_CreatePrintedPixels, cpps);
6889     // selfGlobalRef and cpps are deleted in _CreatePrintedPixels
6890     if (globalRef != NULL)
6891     {
6892         jintArray localRef = (jintArray)env->NewLocalRef(globalRef);
6893         env->DeleteGlobalRef(globalRef);
6894         return localRef;
6895     }
6896     else
6897     {
6898         return NULL;
6899     }
6900 
6901     CATCH_BAD_ALLOC_RET(NULL);
6902 }
6903 
6904 /*
6905  * Class:     sun_awt_windows_WComponentPeer
6906  * Method:    nativeHandlesWheelScrolling
6907  * Signature: ()Z
6908  */
6909 JNIEXPORT jboolean JNICALL
6910 Java_sun_awt_windows_WComponentPeer_nativeHandlesWheelScrolling (JNIEnv* env,
6911     jobject self)
6912 {
6913     TRY;
6914 
6915     return (jboolean)AwtToolkit::GetInstance().SyncCall(
6916         (void *(*)(void *))AwtComponent::_NativeHandlesWheelScrolling,
6917         env->NewGlobalRef(self));
6918     // global ref is deleted in _NativeHandlesWheelScrolling
6919 
6920     CATCH_BAD_ALLOC_RET(NULL);
6921 }
6922 
6923 /*
6924  * Class:     sun_awt_windows_WComponentPeer
6925  * Method:    isObscured
6926  * Signature: ()Z
6927  */
6928 JNIEXPORT jboolean JNICALL
6929 Java_sun_awt_windows_WComponentPeer_isObscured(JNIEnv* env,
6930     jobject self)
6931 {
6932     TRY;
6933 
6934     jobject selfGlobalRef = env->NewGlobalRef(self);
6935 
6936     return (jboolean)AwtToolkit::GetInstance().SyncCall(
6937         (void*(*)(void*))AwtComponent::_IsObscured,
6938         (void *)selfGlobalRef);
6939     // selfGlobalRef is deleted in _IsObscured
6940 
6941     CATCH_BAD_ALLOC_RET(NULL);
6942 }
6943 
6944 JNIEXPORT void JNICALL
6945 Java_sun_awt_windows_WComponentPeer_pSetParent(JNIEnv* env, jobject self, jobject parent) {
6946     TRY;
6947 
6948     typedef AwtComponent* PComponent;
6949     AwtComponent** comps = new PComponent[2];
6950     AwtComponent* comp = (AwtComponent*)JNI_GET_PDATA(self);
6951     AwtComponent* parentComp = (AwtComponent*)JNI_GET_PDATA(parent);
6952     comps[0] = comp;
6953     comps[1] = parentComp;
6954 
6955     AwtToolkit::GetInstance().SyncCall(AwtComponent::SetParent, comps);
6956     // comps is deleted in SetParent
6957 
6958     CATCH_BAD_ALLOC;
6959 }
6960 
6961 JNIEXPORT void JNICALL
6962 Java_sun_awt_windows_WComponentPeer_setRectangularShape(JNIEnv* env, jobject self,
6963         jint x1, jint y1, jint x2, jint y2, jobject region)
6964 {
6965     TRY;
6966 
6967     SetRectangularShapeStruct * data = new SetRectangularShapeStruct;
6968     data->component = env->NewGlobalRef(self);
6969     data->x1 = x1;
6970     data->x2 = x2;
6971     data->y1 = y1;
6972     data->y2 = y2;
6973     if (region) {
6974         data->region = env->NewGlobalRef(region);
6975     } else {
6976         data->region = NULL;
6977     }
6978 
6979     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetRectangularShape, data);
6980     // global refs and data are deleted in _SetRectangularShape
6981 
6982     CATCH_BAD_ALLOC;
6983 }
6984 
6985 JNIEXPORT void JNICALL
6986 Java_sun_awt_windows_WComponentPeer_setZOrder(JNIEnv* env, jobject self, jlong above)
6987 {
6988     TRY;
6989 
6990     SetZOrderStruct * data = new SetZOrderStruct;
6991     data->component = env->NewGlobalRef(self);
6992     data->above = above;
6993 
6994     AwtToolkit::GetInstance().SyncCall(AwtComponent::_SetZOrder, data);
6995     // global refs and data are deleted in _SetLower
6996 
6997     CATCH_BAD_ALLOC;
6998 }
6999 
7000 } /* extern "C" */
7001 
7002 
7003 /************************************************************************
7004  * Diagnostic routines
7005  */
7006 
7007 #ifdef DEBUG
7008 
7009 void AwtComponent::VerifyState()
7010 {
7011     if (AwtToolkit::GetInstance().VerifyComponents() == FALSE) {
7012         return;
7013     }
7014 
7015     if (m_callbacksEnabled == FALSE) {
7016         /* Component is not fully setup yet. */
7017         return;
7018     }
7019 
7020     /* Get target bounds. */
7021     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
7022     if (env->PushLocalFrame(10) < 0)
7023         return;
7024 
7025     jobject target = GetTarget(env);
7026 
7027     jint x = env->GetIntField(target, AwtComponent::xID);
7028     jint y = env->GetIntField(target, AwtComponent::yID);
7029     jint width = env->GetIntField(target, AwtComponent::widthID);
7030     jint height = env->GetIntField(target, AwtComponent::heightID);
7031 
7032     /* Convert target origin to absolute coordinates */
7033     while (TRUE) {
7034 
7035         jobject parent = env->GetObjectField(target, AwtComponent::parentID);
7036         if (parent == NULL) {
7037             break;
7038         }
7039         x += env->GetIntField(parent, AwtComponent::xID);
7040         y += env->GetIntField(parent, AwtComponent::yID);
7041 
7042         /* If this component has insets, factor them in, but ignore
7043          * top-level windows.
7044          */
7045         jobject parent2 = env->GetObjectField(parent, AwtComponent::parentID);
7046         if (parent2 != NULL) {
7047             jobject peer = GetPeerForTarget(env, parent);
7048             if (peer != NULL &&
7049                 JNU_IsInstanceOfByName(env, peer,
7050                                        "sun/awt/windows/WPanelPeer") > 0) {
7051                 jobject insets =
7052                     JNU_CallMethodByName(env, NULL, peer,"insets",
7053                                          "()Ljava/awt/Insets;").l;
7054                 x += (env)->GetIntField(insets, AwtInsets::leftID);
7055                 y += (env)->GetIntField(insets, AwtInsets::topID);
7056             }
7057         }
7058         env->DeleteLocalRef(target);
7059         target = parent;
7060     }
7061 





7062     // Test whether component's bounds match the native window's
7063     RECT rect;
7064     VERIFY(::GetWindowRect(GetHWnd(), &rect));
7065 #if 0
7066     DASSERT( (x == rect.left) &&
7067             (y == rect.top) &&
7068             (width == (rect.right-rect.left)) &&
7069             (height == (rect.bottom-rect.top)) );
7070 #else
7071     BOOL fSizeValid = ( (x == rect.left) &&
7072             (y == rect.top) &&
7073             (width == (rect.right-rect.left)) &&
7074             (height == (rect.bottom-rect.top)) );
7075 #endif
7076 
7077     // See if visible state matches
7078     BOOL wndVisible = ::IsWindowVisible(GetHWnd());
7079     jboolean targetVisible;
7080     // To avoid possibly running client code on the toolkit thread, don't
7081     // do the following check if we're running on the toolkit thread.
7082     if (AwtToolkit::MainThread() != ::GetCurrentThreadId()) {
7083         targetVisible = JNU_CallMethodByName(env, NULL, GetTarget(env),
7084                                                   "isShowing", "()Z").z;
7085         DASSERT(!safe_ExceptionOccurred(env));
7086     } else {
7087         targetVisible = wndVisible ? 1 : 0;
7088     }
7089 #if 0
7090     DASSERT( (targetVisible && wndVisible) ||
7091             (!targetVisible && !wndVisible) );
7092 #else
7093     BOOL fVisibleValid = ( (targetVisible && wndVisible) ||
7094             (!targetVisible && !wndVisible) );
7095 #endif
7096 
7097     // Check enabled state
7098     BOOL wndEnabled = ::IsWindowEnabled(GetHWnd());
7099     jboolean enabled = (jboolean)env->GetBooleanField(target,
7100                                                       AwtComponent::enabledID);
7101 #if 0
7102     DASSERT( (enabled && wndEnabled) ||
7103             (!enabled && !wndEnabled) );
7104 #else
7105     BOOL fEnabledValid = ((enabled && wndEnabled) ||
7106                           (!(enabled && !wndEnabled) ));
7107 
7108     if (!fSizeValid || !fVisibleValid || !fEnabledValid) {
7109         printf("AwtComponent::ValidateState() failed:\n");
7110         // To avoid possibly running client code on the toolkit thread, don't
7111         // do the following call if we're running on the toolkit thread.
7112         if (AwtToolkit::MainThread() != ::GetCurrentThreadId()) {
7113             jstring targetStr =
7114                 (jstring)JNU_CallMethodByName(env, NULL, GetTarget(env),
7115                                               "getName",
7116                                               "()Ljava/lang/String;").l;
7117             DASSERT(!safe_ExceptionOccurred(env));
7118             LPCWSTR targetStrW = JNU_GetStringPlatformChars(env, targetStr, NULL);
7119             printf("\t%S\n", targetStrW);
7120             JNU_ReleaseStringPlatformChars(env, targetStr, targetStrW);
7121         }
7122         printf("\twas:       [%d,%d,%dx%d]\n", x, y, width, height);
7123         if (!fSizeValid) {
7124             printf("\tshould be: [%d,%d,%dx%d]\n", rect.left, rect.top,
7125                    rect.right-rect.left, rect.bottom-rect.top);
7126         }
7127         if (!fVisibleValid) {
7128             printf("\tshould be: %s\n",
7129                    (targetVisible) ? "visible" : "hidden");
7130         }
7131         if (!fEnabledValid) {
7132             printf("\tshould be: %s\n",
7133                    enabled ? "enabled" : "disabled");
7134         }
7135     }
7136 #endif
7137     env->PopLocalFrame(0);
7138 }
7139 #endif //DEBUG
7140 
7141 // Methods for globally managed DC list
7142 
7143 /**
7144  * Add a new DC to the DC list for this component.
7145  */
7146 void DCList::AddDC(HDC hDC, HWND hWnd)
7147 {
7148     DCItem *newItem = new DCItem;
7149     newItem->hDC = hDC;
7150     newItem->hWnd = hWnd;
7151     AddDCItem(newItem);
7152 }
7153 
7154 void DCList::AddDCItem(DCItem *newItem)
7155 {
7156     listLock.Enter();
7157     newItem->next = head;
7158     head = newItem;
7159     listLock.Leave();
7160 }
7161 
7162 /**
7163  * Given a DC, remove it from the DC list and return
7164  * TRUE if it exists on the current list.  Otherwise
7165  * return FALSE.
7166  * A DC may not exist on the list because it has already
7167  * been released elsewhere (for example, the window
7168  * destruction process may release a DC while a rendering
7169  * thread may also want to release a DC when it notices that
7170  * its DC is obsolete for the current window).
7171  */
7172 DCItem *DCList::RemoveDC(HDC hDC)
7173 {
7174     listLock.Enter();
7175     DCItem **prevPtrPtr = &head;
7176     DCItem *listPtr = head;
7177     while (listPtr) {
7178         DCItem *nextPtr = listPtr->next;
7179         if (listPtr->hDC == hDC) {
7180             *prevPtrPtr = nextPtr;
7181             break;
7182         }
7183         prevPtrPtr = &listPtr->next;
7184         listPtr = nextPtr;
7185     }
7186     listLock.Leave();
7187     return listPtr;
7188 }
7189 
7190 /**
7191  * Remove all DCs from the DC list which are associated with
7192  * the same window as hWnd.  Return the list of those
7193  * DC's to the caller (which will then probably want to
7194  * call ReleaseDC() for the returned DCs).
7195  */
7196 DCItem *DCList::RemoveAllDCs(HWND hWnd)
7197 {
7198     listLock.Enter();
7199     DCItem **prevPtrPtr = &head;
7200     DCItem *listPtr = head;
7201     DCItem *newListPtr = NULL;
7202     BOOL ret = FALSE;
7203     while (listPtr) {
7204         DCItem *nextPtr = listPtr->next;
7205         if (listPtr->hWnd == hWnd) {
7206             *prevPtrPtr = nextPtr;
7207             listPtr->next = newListPtr;
7208             newListPtr = listPtr;
7209         } else {
7210             prevPtrPtr = &listPtr->next;
7211         }
7212         listPtr = nextPtr;
7213     }
7214     listLock.Leave();
7215     return newListPtr;
7216 }
7217 
7218 
7219 /**
7220  * Realize palettes of all existing HDC objects
7221  */
7222 void DCList::RealizePalettes(int screen)
7223 {
7224     listLock.Enter();
7225     DCItem *listPtr = head;
7226     while (listPtr) {
7227         AwtWin32GraphicsDevice::RealizePalette(listPtr->hDC, screen);
7228         listPtr = listPtr->next;
7229     }
7230     listLock.Leave();
7231 }
7232 
7233 void MoveDCToPassiveList(HDC hDC) {
7234     DCItem *removedDC;
7235     if ((removedDC = activeDCList.RemoveDC(hDC)) != NULL) {
7236         passiveDCList.AddDCItem(removedDC);
7237     }
7238 }
7239 
7240 void ReleaseDCList(HWND hwnd, DCList &list) {
7241     DCItem *removedDCs = list.RemoveAllDCs(hwnd);
7242     while (removedDCs) {
7243         DCItem *tmpDCList = removedDCs;
7244         DASSERT(::GetObjectType(tmpDCList->hDC) == OBJ_DC);
7245         int retValue = ::ReleaseDC(tmpDCList->hWnd, tmpDCList->hDC);
7246         VERIFY(retValue != 0);
7247         if (retValue != 0) {
7248             // Valid ReleaseDC call; need to decrement GDI object counter
7249             AwtGDIObject::Decrement();
7250         }
7251         removedDCs = removedDCs->next;
7252         delete tmpDCList;
7253     }
7254 }
7255 
--- EOF ---