src/msw/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/windows.cpp
   3 // Purpose:     wxWindow
   4 // Author:      Julian Smart
   5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "window.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/msw/wrapwin.h"
  33     #include "wx/window.h"
  34     #include "wx/accel.h"
  35     #include "wx/setup.h"
  36     #include "wx/menu.h"
  37     #include "wx/dc.h"
  38     #include "wx/dcclient.h"
  39     #include "wx/dcmemory.h"
  40     #include "wx/utils.h"
  41     #include "wx/app.h"
  42     #include "wx/layout.h"
  43     #include "wx/dialog.h"
  44     #include "wx/frame.h"
  45     #include "wx/listbox.h"
  46     #include "wx/button.h"
  47     #include "wx/msgdlg.h"
  48     #include "wx/settings.h"
  49     #include "wx/statbox.h"
  50 #endif
  51
  52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
  53     #include "wx/ownerdrw.h"
  54 #endif
  55
  56 #include "wx/module.h"
  57
  58 #if wxUSE_DRAG_AND_DROP
  59     #include "wx/dnd.h"
  60 #endif
  61
  62 #if wxUSE_ACCESSIBILITY
  63     #include "wx/access.h"
  64     #include <ole2.h>
  65     #include <oleacc.h>
  66     #ifndef WM_GETOBJECT
  67         #define WM_GETOBJECT 0x003D
  68     #endif
  69     #ifndef OBJID_CLIENT
  70         #define OBJID_CLIENT 0xFFFFFFFC
  71     #endif
  72 #endif
  73
  74 #include "wx/menuitem.h"
  75 #include "wx/log.h"
  76
  77 #include "wx/msw/private.h"
  78
  79 #if wxUSE_TOOLTIPS
  80     #include "wx/tooltip.h"
  81 #endif
  82
  83 #if wxUSE_CARET
  84     #include "wx/caret.h"
  85 #endif // wxUSE_CARET
  86
  87 #if wxUSE_SPINCTRL
  88     #include "wx/spinctrl.h"
  89 #endif // wxUSE_SPINCTRL
  90
  91 #include "wx/intl.h"
  92 #include "wx/log.h"
  93
  94 #include "wx/textctrl.h"
  95 #include "wx/notebook.h"
  96 #include "wx/listctrl.h"
  97
  98 #include <string.h>
  99
 100 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
 101     #include <shellapi.h>
 102     #include <mmsystem.h>
 103 #endif
 104
 105 #ifdef __WIN32__
 106     #include <windowsx.h>
 107 #endif
 108
 109 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
 110     #ifdef __WIN95__
 111         #include <commctrl.h>
 112     #endif
 113 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
 114     #include "wx/msw/gnuwin32/extra.h"
 115 #endif
 116
 117 #if defined(__GNUG__)
 118 #include "wx/msw/missing.h"
 119 #endif
 120
 121 #if defined(__WXWINCE__)
 122 #include "wx/msw/wince/missing.h"
 123 #endif
 124
 125 // ----------------------------------------------------------------------------
 126 // standard constants not available with all compilers/headers
 127 // ----------------------------------------------------------------------------
 128
 129 // This didn't appear in mingw until 2.95.2
 130 #ifndef SIF_TRACKPOS
 131 #define SIF_TRACKPOS 16
 132 #endif
 133
 134 #if wxUSE_MOUSEWHEEL
 135     #ifndef WM_MOUSEWHEEL
 136         #define WM_MOUSEWHEEL           0x020A
 137     #endif
 138     #ifndef WHEEL_DELTA
 139         #define WHEEL_DELTA             120
 140     #endif
 141     #ifndef SPI_GETWHEELSCROLLLINES
 142         #define SPI_GETWHEELSCROLLLINES 104
 143     #endif
 144 #endif // wxUSE_MOUSEWHEEL
 145
 146 #ifndef VK_OEM_1
 147     #define VK_OEM_1        0xBA
 148     #define VK_OEM_2        0xBF
 149     #define VK_OEM_3        0xC0
 150     #define VK_OEM_4        0xDB
 151     #define VK_OEM_5        0xDC
 152     #define VK_OEM_6        0xDD
 153     #define VK_OEM_7        0xDE
 154 #endif
 155
 156 #ifndef VK_OEM_COMMA
 157     #define VK_OEM_PLUS     0xBB
 158     #define VK_OEM_COMMA    0xBC
 159     #define VK_OEM_MINUS    0xBD
 160     #define VK_OEM_PERIOD   0xBE
 161 #endif
 162
 163 // ---------------------------------------------------------------------------
 164 // global variables
 165 // ---------------------------------------------------------------------------
 166
 167 #if wxUSE_MENUS_NATIVE
 168 wxMenu *wxCurrentPopupMenu = NULL;
 169 #endif // wxUSE_MENUS_NATIVE
 170
 171 extern const wxChar *wxCanvasClassName;
 172
 173 // true if we had already created the std colour map, used by
 174 // wxGetStdColourMap() and wxWindow::OnSysColourChanged()           (FIXME-MT)
 175 static bool gs_hasStdCmap = FALSE;
 176
 177 // ---------------------------------------------------------------------------
 178 // private functions
 179 // ---------------------------------------------------------------------------
 180
 181 // the window proc for all our windows
 182 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
 183                                    WPARAM wParam, LPARAM lParam);
 184
 185
 186 #ifdef  __WXDEBUG__
 187     const char *wxGetMessageName(int message);
 188 #endif  //__WXDEBUG__
 189
 190 void wxRemoveHandleAssociation(wxWindowMSW *win);
 191 extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
 192 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
 193
 194 // this magical function is used to translate VK_APPS key presses to right
 195 // mouse clicks
 196 static void TranslateKbdEventToMouse(wxWindowMSW *win,
 197                                      int *x, int *y, WPARAM *flags);
 198
 199 // get the text metrics for the current font
 200 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
 201
 202 // find the window for the mouse event at the specified position
 203 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y); //TW:REQ:Univ
 204
 205 // wrapper around BringWindowToTop() API
 206 static inline void wxBringWindowToTop(HWND hwnd)
 207 {
 208 #ifdef __WXMICROWIN__
 209     // It seems that MicroWindows brings the _parent_ of the window to the top,
 210     // which can be the wrong one.
 211
 212     // activate (set focus to) specified window
 213     ::SetFocus(hwnd);
 214 #endif
 215
 216     // raise top level parent to top of z order
 217     if (!::SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE))
 218     {
 219         wxLogLastError(_T("SetWindowPos"));
 220     }
 221 }
 222
 223 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
 224 static void EnsureParentHasControlParentStyle(wxWindow *parent)
 225 {
 226     /*
 227        If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
 228        parent as well as otherwise several Win32 functions using
 229        GetNextDlgTabItem() to iterate over all controls such as
 230        IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
 231        all of them iterate over all the controls starting from the currently
 232        focused one and stop iterating when they get back to the focus but
 233        unless all parents have WS_EX_CONTROLPARENT bit set, they would never
 234        get back to the initial (focused) window: as we do have this style,
 235        GetNextDlgTabItem() will leave this window and continue in its parent,
 236        but if the parent doesn't have it, it wouldn't recurse inside it later
 237        on and so wouldn't have a chance of getting back to this window neither.
 238      */
 239 #ifndef __WXWINCE__
 240     while ( parent && !parent->IsTopLevel() )
 241     {
 242         LONG exStyle = ::GetWindowLong(GetHwndOf(parent), GWL_EXSTYLE);
 243         if ( !(exStyle & WS_EX_CONTROLPARENT) )
 244         {
 245             // force the parent to have this style
 246             ::SetWindowLong(GetHwndOf(parent), GWL_EXSTYLE,
 247                             exStyle | WS_EX_CONTROLPARENT);
 248         }
 249
 250         parent = parent->GetParent();
 251     }
 252 #endif // !__WXWINCE__
 253 }
 254
 255 // ---------------------------------------------------------------------------
 256 // event tables
 257 // ---------------------------------------------------------------------------
 258
 259 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
 260 // method
 261 #ifdef __WXUNIVERSAL__
 262     IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW, wxWindowBase)
 263 #else // __WXMSW__
 264 #if wxUSE_EXTENDED_RTTI
 265
 266 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
 267 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
 268 // windows with negative ids never can be recreated anyway
 269
 270 bool wxWindowStreamingCallback( const wxObject *object, wxWriter * , wxPersister * , wxxVariantArray & )
 271 {
 272     const wxWindow * win = dynamic_cast<const wxWindow*>(object) ;
 273     if ( win && win->GetId() < 0 )
 274         return false ;
 275     return true ;
 276 }
 277
 278 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow, wxWindowBase,"wx/window.h", wxWindowStreamingCallback)
 279
 280 // make wxWindowList known before the property is used
 281
 282 wxCOLLECTION_TYPE_INFO( wxWindow* , wxWindowList ) ;
 283
 284 template<> void wxCollectionToVariantArray( wxWindowList const &theList, wxxVariantArray &value)
 285 {
 286     wxListCollectionToVariantArray<wxWindowList::compatibility_iterator>( theList , value ) ;
 287 }
 288
 289 WX_DEFINE_FLAGS( wxWindowStyle )
 290
 291 wxBEGIN_FLAGS( wxWindowStyle )
 292     // new style border flags, we put them first to
 293     // use them for streaming out
 294
 295     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
 296     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
 297     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
 298     wxFLAGS_MEMBER(wxBORDER_RAISED)
 299     wxFLAGS_MEMBER(wxBORDER_STATIC)
 300     wxFLAGS_MEMBER(wxBORDER_NONE)
 301
 302     // old style border flags
 303     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
 304     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
 305     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
 306     wxFLAGS_MEMBER(wxRAISED_BORDER)
 307     wxFLAGS_MEMBER(wxSTATIC_BORDER)
 308     wxFLAGS_MEMBER(wxBORDER)
 309
 310     // standard window styles
 311     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
 312     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
 313     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
 314     wxFLAGS_MEMBER(wxWANTS_CHARS)
 315     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
 316     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
 317     wxFLAGS_MEMBER(wxVSCROLL)
 318     wxFLAGS_MEMBER(wxHSCROLL)
 319
 320 wxEND_FLAGS( wxWindowStyle )
 321
 322 wxBEGIN_PROPERTIES_TABLE(wxWindow)
 323         wxEVENT_PROPERTY( Close , wxEVT_CLOSE_WINDOW , wxCloseEvent)
 324         wxEVENT_PROPERTY( Create , wxEVT_CREATE , wxWindowCreateEvent )
 325         wxEVENT_PROPERTY( Destroy , wxEVT_DESTROY , wxWindowDestroyEvent )
 326     // Always constructor Properties first
 327
 328     wxREADONLY_PROPERTY( Parent,wxWindow*, GetParent,  , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 329         wxPROPERTY( Id,wxWindowID, SetId, GetId, -1, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 330         wxPROPERTY( Position,wxPoint, SetPosition , GetPosition, wxPoint(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
 331         wxPROPERTY( Size,wxSize, SetSize, GetSize, wxSize(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
 332     wxPROPERTY( WindowStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 333
 334     // Then all relations of the object graph
 335
 336     wxREADONLY_PROPERTY_COLLECTION( Children , wxWindowList , wxWindowBase* , GetWindowChildren , wxPROP_OBJECT_GRAPH /*flags*/ , wxT("Helpstring") , wxT("group"))
 337
 338    // and finally all other properties
 339
 340         wxPROPERTY( ExtraStyle , long , SetExtraStyle , GetExtraStyle , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
 341         wxPROPERTY( BackgroundColour , wxColour , SetBackgroundColour , GetBackgroundColour , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
 342         wxPROPERTY( ForegroundColour , wxColour , SetForegroundColour , GetForegroundColour , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
 343         wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 344         wxPROPERTY( Shown , bool , Show , IsShown , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 345 #if 0
 346     // possible property candidates (not in xrc) or not valid in all subclasses
 347         wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxT("") )
 348         wxPROPERTY( Font , wxFont , SetFont , GetWindowFont  , )
 349         wxPROPERTY( Label,wxString, SetLabel, GetLabel, wxT("") )
 350         // MaxHeight, Width , MinHeight , Width
 351         // TODO switch label to control and title to toplevels
 352
 353         wxPROPERTY( ThemeEnabled , bool , SetThemeEnabled , GetThemeEnabled , )
 354         //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
 355         // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
 356         wxPROPERTY( AutoLayout , bool , SetAutoLayout , GetAutoLayout , )
 357
 358
 359
 360 #endif
 361 wxEND_PROPERTIES_TABLE()
 362
 363 wxBEGIN_HANDLERS_TABLE(wxWindow)
 364 wxEND_HANDLERS_TABLE()
 365
 366 wxCONSTRUCTOR_DUMMY(wxWindow)
 367
 368 #else
 369     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 370 #endif
 371 #endif // __WXUNIVERSAL__/__WXMSW__
 372
 373 BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
 374     EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
 375     EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
 376     EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
 377 END_EVENT_TABLE()
 378
 379 // ===========================================================================
 380 // implementation
 381 // ===========================================================================
 382
 383 // ---------------------------------------------------------------------------
 384 // wxWindow utility functions
 385 // ---------------------------------------------------------------------------
 386
 387 // Find an item given the MS Windows id
 388 wxWindow *wxWindowMSW::FindItem(long id) const
 389 {
 390 #if wxUSE_CONTROLS
 391     wxControl *item = wxDynamicCastThis(wxControl);
 392     if ( item )
 393     {
 394         // is it we or one of our "internal" children?
 395         if ( item->GetId() == id
 396 #ifndef __WXUNIVERSAL__
 397                 || (item->GetSubcontrols().Index(id) != wxNOT_FOUND)
 398 #endif // __WXUNIVERSAL__
 399            )
 400         {
 401             return item;
 402         }
 403     }
 404 #endif // wxUSE_CONTROLS
 405
 406     wxWindowList::compatibility_iterator current = GetChildren().GetFirst();
 407     while (current)
 408     {
 409         wxWindow *childWin = current->GetData();
 410
 411         wxWindow *wnd = childWin->FindItem(id);
 412         if ( wnd )
 413             return wnd;
 414
 415         current = current->GetNext();
 416     }
 417
 418     return NULL;
 419 }
 420
 421 // Find an item given the MS Windows handle
 422 wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
 423 {
 424     wxWindowList::compatibility_iterator current = GetChildren().GetFirst();
 425     while (current)
 426     {
 427         wxWindow *parent = current->GetData();
 428
 429         // Do a recursive search.
 430         wxWindow *wnd = parent->FindItemByHWND(hWnd);
 431         if ( wnd )
 432             return wnd;
 433
 434         if ( !controlOnly
 435 #if wxUSE_CONTROLS
 436                 || parent->IsKindOf(CLASSINFO(wxControl))
 437 #endif // wxUSE_CONTROLS
 438            )
 439         {
 440             wxWindow *item = current->GetData();
 441             if ( item->GetHWND() == hWnd )
 442                 return item;
 443             else
 444             {
 445                 if ( item->ContainsHWND(hWnd) )
 446                     return item;
 447             }
 448         }
 449
 450         current = current->GetNext();
 451     }
 452     return NULL;
 453 }
 454
 455 // Default command handler
 456 bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
 457 {
 458     return FALSE;
 459 }
 460
 461 // ----------------------------------------------------------------------------
 462 // constructors and such
 463 // ----------------------------------------------------------------------------
 464
 465 void wxWindowMSW::Init()
 466 {
 467     // MSW specific
 468     m_isBeingDeleted = FALSE;
 469     m_oldWndProc = NULL;
 470     m_mouseInWindow = FALSE;
 471     m_lastKeydownProcessed = FALSE;
 472
 473     m_childrenDisabled = NULL;
 474
 475     // wxWnd
 476     m_hMenu = 0;
 477
 478     m_hWnd = 0;
 479
 480     m_xThumbSize = 0;
 481     m_yThumbSize = 0;
 482
 483     // as all windows are created with WS_VISIBLE style...
 484     m_isShown = TRUE;
 485
 486 #if wxUSE_MOUSEEVENT_HACK
 487     m_lastMouseX =
 488     m_lastMouseY = -1;
 489     m_lastMouseEvent = -1;
 490 #endif // wxUSE_MOUSEEVENT_HACK
 491 }
 492
 493 // Destructor
 494 wxWindowMSW::~wxWindowMSW()
 495 {
 496     m_isBeingDeleted = TRUE;
 497
 498 #ifndef __WXUNIVERSAL__
 499     // VS: make sure there's no wxFrame with last focus set to us:
 500     for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
 501     {
 502         wxTopLevelWindow *frame = wxDynamicCast(win, wxTopLevelWindow);
 503         if ( frame )
 504         {
 505             if ( frame->GetLastFocus() == this )
 506             {
 507                 frame->SetLastFocus(NULL);
 508             }
 509             break;
 510         }
 511     }
 512 #endif // __WXUNIVERSAL__
 513
 514     // VS: destroy children first and _then_ detach *this from its parent.
 515     //     If we'd do it the other way around, children wouldn't be able
 516     //     find their parent frame (see above).
 517     DestroyChildren();
 518
 519     if ( m_hWnd )
 520     {
 521         // VZ: test temp removed to understand what really happens here
 522         //if (::IsWindow(GetHwnd()))
 523         {
 524             if ( !::DestroyWindow(GetHwnd()) )
 525                 wxLogLastError(wxT("DestroyWindow"));
 526         }
 527
 528         // remove hWnd <-> wxWindow association
 529         wxRemoveHandleAssociation(this);
 530     }
 531
 532     delete m_childrenDisabled;
 533 }
 534
 535 // real construction (Init() must have been called before!)
 536 bool wxWindowMSW::Create(wxWindow *parent,
 537                          wxWindowID id,
 538                          const wxPoint& pos,
 539                          const wxSize& size,
 540                          long style,
 541                          const wxString& name)
 542 {
 543     wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
 544
 545     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 546         return FALSE;
 547
 548     parent->AddChild(this);
 549
 550     WXDWORD exstyle;
 551     DWORD msflags = MSWGetCreateWindowFlags(&exstyle);
 552
 553 #ifdef __WXUNIVERSAL__
 554     // no borders, we draw them ourselves
 555     exstyle &= ~(WS_EX_DLGMODALFRAME |
 556                  WS_EX_STATICEDGE |
 557                  WS_EX_CLIENTEDGE |
 558                  WS_EX_WINDOWEDGE);
 559     msflags &= ~WS_BORDER;
 560 #endif // wxUniversal
 561
 562     // all windows are created visible by default except popup ones (which are
 563     // like the wxTopLevelWindows in this aspect)
 564     if ( style & wxPOPUP_WINDOW )
 565     {
 566         msflags &= ~WS_VISIBLE;
 567         m_isShown = FALSE;
 568     }
 569     else
 570     {
 571         msflags |= WS_VISIBLE;
 572     }
 573
 574     return MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exstyle);
 575 }
 576
 577 // ---------------------------------------------------------------------------
 578 // basic operations
 579 // ---------------------------------------------------------------------------
 580
 581 void wxWindowMSW::SetFocus()
 582 {
 583     HWND hWnd = GetHwnd();
 584     wxCHECK_RET( hWnd, _T("can't set focus to invalid window") );
 585
 586 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 587     ::SetLastError(0);
 588 #endif
 589
 590     if ( !::SetFocus(hWnd) )
 591     {
 592 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
 593         // was there really an error?
 594         DWORD dwRes = ::GetLastError();
 595         if ( dwRes )
 596         {
 597             HWND hwndFocus = ::GetFocus();
 598             if ( hwndFocus != hWnd )
 599             {
 600                 wxLogApiError(_T("SetFocus"), dwRes);
 601             }
 602         }
 603 #endif // Debug
 604     }
 605 }
 606
 607 void wxWindowMSW::SetFocusFromKbd()
 608 {
 609     // when the focus is given to the control with DLGC_HASSETSEL style from
 610     // keyboard its contents should be entirely selected: this is what
 611     // ::IsDialogMessage() does and so we should do it as well to provide the
 612     // same LNF as the native programs
 613     if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE, 0, 0) & DLGC_HASSETSEL )
 614     {
 615         ::SendMessage(GetHwnd(), EM_SETSEL, 0, -1);
 616     }
 617
 618     // do this after (maybe) setting the selection as like this when
 619     // wxEVT_SET_FOCUS handler is called, the selection would have been already
 620     // set correctly -- this may be important
 621     wxWindowBase::SetFocusFromKbd();
 622 }
 623
 624 // Get the window with the focus
 625 wxWindow *wxWindowBase::FindFocus()
 626 {
 627     HWND hWnd = ::GetFocus();
 628     if ( hWnd )
 629     {
 630         return wxGetWindowFromHWND((WXHWND)hWnd);
 631     }
 632
 633     return NULL;
 634 }
 635
 636 bool wxWindowMSW::Enable(bool enable)
 637 {
 638     if ( !wxWindowBase::Enable(enable) )
 639         return FALSE;
 640
 641     HWND hWnd = GetHwnd();
 642     if ( hWnd )
 643         ::EnableWindow(hWnd, (BOOL)enable);
 644
 645     // the logic below doesn't apply to the top level windows -- otherwise
 646     // showing a modal dialog would result in total greying out (and ungreying
 647     // out later) of everything which would be really ugly
 648     if ( IsTopLevel() )
 649         return TRUE;
 650
 651     // when the parent is disabled, all of its children should be disabled as
 652     // well but when it is enabled back, only those of the children which
 653     // hadn't been already disabled in the beginning should be enabled again,
 654     // so we have to keep the list of those children
 655     for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 656           node;
 657           node = node->GetNext() )
 658     {
 659         wxWindow *child = node->GetData();
 660         if ( child->IsTopLevel() )
 661         {
 662             // the logic below doesn't apply to top level children
 663             continue;
 664         }
 665
 666         if ( enable )
 667         {
 668             // enable the child back unless it had been disabled before us
 669             if ( !m_childrenDisabled || !m_childrenDisabled->Find(child) )
 670                 child->Enable();
 671         }
 672         else // we're being disabled
 673         {
 674             if ( child->IsEnabled() )
 675             {
 676                 // disable it as children shouldn't stay enabled while the
 677                 // parent is not
 678                 child->Disable();
 679             }
 680             else // child already disabled, remember it
 681             {
 682                 // have we created the list of disabled children already?
 683                 if ( !m_childrenDisabled )
 684                     m_childrenDisabled = new wxWindowList;
 685
 686                 m_childrenDisabled->Append(child);
 687             }
 688         }
 689     }
 690
 691     if ( enable && m_childrenDisabled )
 692     {
 693         // we don't need this list any more, don't keep unused memory
 694         delete m_childrenDisabled;
 695         m_childrenDisabled = NULL;
 696     }
 697
 698     return TRUE;
 699 }
 700
 701 bool wxWindowMSW::Show(bool show)
 702 {
 703     if ( !wxWindowBase::Show(show) )
 704         return FALSE;
 705
 706     HWND hWnd = GetHwnd();
 707     int cshow = show ? SW_SHOW : SW_HIDE;
 708     ::ShowWindow(hWnd, cshow);
 709
 710     if ( show && IsTopLevel() )
 711     {
 712         wxBringWindowToTop(hWnd);
 713     }
 714
 715     return TRUE;
 716 }
 717
 718 // Raise the window to the top of the Z order
 719 void wxWindowMSW::Raise()
 720 {
 721     wxBringWindowToTop(GetHwnd());
 722 }
 723
 724 // Lower the window to the bottom of the Z order
 725 void wxWindowMSW::Lower()
 726 {
 727     ::SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0,
 728                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 729 }
 730
 731 void wxWindowMSW::SetTitle( const wxString& title)
 732 {
 733     SetWindowText(GetHwnd(), title.c_str());
 734 }
 735
 736 wxString wxWindowMSW::GetTitle() const
 737 {
 738     return wxGetWindowText(GetHWND());
 739 }
 740
 741 void wxWindowMSW::DoCaptureMouse()
 742 {
 743     HWND hWnd = GetHwnd();
 744     if ( hWnd )
 745     {
 746         ::SetCapture(hWnd);
 747     }
 748 }
 749
 750 void wxWindowMSW::DoReleaseMouse()
 751 {
 752     if ( !::ReleaseCapture() )
 753     {
 754         wxLogLastError(_T("ReleaseCapture"));
 755     }
 756 }
 757
 758 /* static */ wxWindow *wxWindowBase::GetCapture()
 759 {
 760     HWND hwnd = ::GetCapture();
 761     return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL;
 762 }
 763
 764 bool wxWindowMSW::SetFont(const wxFont& font)
 765 {
 766     if ( !wxWindowBase::SetFont(font) )
 767     {
 768         // nothing to do
 769         return FALSE;
 770     }
 771
 772     HWND hWnd = GetHwnd();
 773     if ( hWnd != 0 )
 774     {
 775         WXHANDLE hFont = m_font.GetResourceHandle();
 776
 777         wxASSERT_MSG( hFont, wxT("should have valid font") );
 778
 779         ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
 780     }
 781
 782     return TRUE;
 783 }
 784 bool wxWindowMSW::SetCursor(const wxCursor& cursor)
 785 {
 786     if ( !wxWindowBase::SetCursor(cursor) )
 787     {
 788         // no change
 789         return FALSE;
 790     }
 791
 792     if ( m_cursor.Ok() )
 793     {
 794         HWND hWnd = GetHwnd();
 795
 796         // Change the cursor NOW if we're within the correct window
 797         POINT point;
 798         ::GetCursorPos(&point);
 799
 800         RECT rect = wxGetWindowRect(hWnd);
 801
 802         if ( ::PtInRect(&rect, point) && !wxIsBusy() )
 803             ::SetCursor(GetHcursorOf(m_cursor));
 804     }
 805
 806     return TRUE;
 807 }
 808
 809 void wxWindowMSW::WarpPointer (int x, int y)
 810 {
 811     ClientToScreen(&x, &y);
 812
 813     if ( !::SetCursorPos(x, y) )
 814     {
 815         wxLogLastError(_T("SetCursorPos"));
 816     }
 817 }
 818
 819 // ---------------------------------------------------------------------------
 820 // scrolling stuff
 821 // ---------------------------------------------------------------------------
 822
 823 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
 824 static inline int wxDirToWinStyle(int orient)
 825 {
 826     return orient == wxHORIZONTAL ? SB_HORZ : SB_VERT;
 827 }
 828
 829 inline int GetScrollPosition(HWND hWnd, int wOrient)
 830 {
 831 #ifdef __WXMICROWIN__
 832     return ::GetScrollPosWX(hWnd, wOrient);
 833 #else
 834     WinStruct<SCROLLINFO> scrollInfo;
 835     scrollInfo.cbSize = sizeof(SCROLLINFO);
 836     scrollInfo.fMask = SIF_POS;
 837     if ( !::GetScrollInfo(hWnd,
 838                           wOrient,
 839                           &scrollInfo) )
 840     {
 841         // Not neccessarily an error, if there are no scrollbars yet.
 842         // wxLogLastError(_T("GetScrollInfo"));
 843     }
 844     return scrollInfo.nPos;
 845 //    return ::GetScrollPos(hWnd, wOrient);
 846 #endif
 847 }
 848
 849 int wxWindowMSW::GetScrollPos(int orient) const
 850 {
 851     HWND hWnd = GetHwnd();
 852     wxCHECK_MSG( hWnd, 0, _T("no HWND in GetScrollPos") );
 853
 854     return GetScrollPosition(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT);
 855 }
 856
 857 // This now returns the whole range, not just the number
 858 // of positions that we can scroll.
 859 int wxWindowMSW::GetScrollRange(int orient) const
 860 {
 861     int maxPos;
 862     HWND hWnd = GetHwnd();
 863     if ( !hWnd )
 864         return 0;
 865 #if 0
 866     ::GetScrollRange(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
 867                      &minPos, &maxPos);
 868 #endif
 869     WinStruct<SCROLLINFO> scrollInfo;
 870     scrollInfo.fMask = SIF_RANGE;
 871     if ( !::GetScrollInfo(hWnd,
 872                           orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
 873                           &scrollInfo) )
 874     {
 875         // Most of the time this is not really an error, since the return
 876         // value can also be zero when there is no scrollbar yet.
 877         // wxLogLastError(_T("GetScrollInfo"));
 878     }
 879     maxPos = scrollInfo.nMax;
 880
 881     // undo "range - 1" done in SetScrollbar()
 882     return maxPos + 1;
 883 }
 884
 885 int wxWindowMSW::GetScrollThumb(int orient) const
 886 {
 887     return orient == wxHORIZONTAL ? m_xThumbSize : m_yThumbSize;
 888 }
 889
 890 void wxWindowMSW::SetScrollPos(int orient, int pos, bool refresh)
 891 {
 892     HWND hWnd = GetHwnd();
 893     wxCHECK_RET( hWnd, _T("SetScrollPos: no HWND") );
 894
 895     WinStruct<SCROLLINFO> info;
 896     info.nPage = 0;
 897     info.nMin = 0;
 898     info.nPos = pos;
 899     info.fMask = SIF_POS;
 900     if ( HasFlag(wxALWAYS_SHOW_SB) )
 901     {
 902         // disable scrollbar instead of removing it then
 903         info.fMask |= SIF_DISABLENOSCROLL;
 904     }
 905
 906     ::SetScrollInfo(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
 907                     &info, refresh);
 908 }
 909
 910 // New function that will replace some of the above.
 911 void wxWindowMSW::SetScrollbar(int orient,
 912                                int pos,
 913                                int pageSize,
 914                                int range,
 915                                bool refresh)
 916 {
 917     WinStruct<SCROLLINFO> info;
 918     info.nPage = pageSize;
 919     info.nMin = 0;              // range is nMax - nMin + 1
 920     info.nMax = range - 1;      //  as both nMax and nMax are inclusive
 921     info.nPos = pos;
 922     info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
 923     if ( HasFlag(wxALWAYS_SHOW_SB) )
 924     {
 925         // disable scrollbar instead of removing it then
 926         info.fMask |= SIF_DISABLENOSCROLL;
 927     }
 928
 929     HWND hWnd = GetHwnd();
 930     if ( hWnd )
 931     {
 932         ::SetScrollInfo(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
 933                         &info, refresh);
 934     }
 935
 936     *(orient == wxHORIZONTAL ? &m_xThumbSize : &m_yThumbSize) = pageSize;
 937 }
 938
 939 void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
 940 {
 941     RECT rect;
 942     RECT *pr;
 943     if ( prect )
 944     {
 945         rect.left = prect->x;
 946         rect.top = prect->y;
 947         rect.right = prect->x + prect->width;
 948         rect.bottom = prect->y + prect->height;
 949         pr = &rect;
 950     }
 951     else
 952     {
 953         pr = NULL;
 954     }
 955
 956 #ifdef __WXWINCE__
 957     // FIXME: is this the exact equivalent of the line below?
 958     ::ScrollWindowEx(GetHwnd(), dx, dy, pr, pr, 0, 0, SW_ERASE|SW_INVALIDATE);
 959 #else
 960     ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
 961 #endif
 962 }
 963
 964 static bool ScrollVertically(HWND hwnd, int kind, int count)
 965 {
 966     int posStart = GetScrollPosition(hwnd, SB_VERT);
 967
 968     int pos = posStart;
 969     for ( int n = 0; n < count; n++ )
 970     {
 971         ::SendMessage(hwnd, WM_VSCROLL, kind, 0);
 972
 973         int posNew = GetScrollPosition(hwnd, SB_VERT);
 974         if ( posNew == pos )
 975         {
 976             // don't bother to continue, we're already at top/bottom
 977             break;
 978         }
 979
 980         pos = posNew;
 981     }
 982
 983     return pos != posStart;
 984 }
 985
 986 bool wxWindowMSW::ScrollLines(int lines)
 987 {
 988     bool down = lines > 0;
 989
 990     return ScrollVertically(GetHwnd(),
 991                             down ? SB_LINEDOWN : SB_LINEUP,
 992                             down ? lines : -lines);
 993 }
 994
 995 bool wxWindowMSW::ScrollPages(int pages)
 996 {
 997     bool down = pages > 0;
 998
 999     return ScrollVertically(GetHwnd(),
1000                             down ? SB_PAGEDOWN : SB_PAGEUP,
1001                             down ? pages : -pages);
1002 }
1003
1004 // ---------------------------------------------------------------------------
1005 // subclassing
1006 // ---------------------------------------------------------------------------
1007
1008 void wxWindowMSW::SubclassWin(WXHWND hWnd)
1009 {
1010     wxASSERT_MSG( !m_oldWndProc, wxT("subclassing window twice?") );
1011
1012     HWND hwnd = (HWND)hWnd;
1013     wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in SubclassWin") );
1014
1015     wxAssociateWinWithHandle(hwnd, this);
1016
1017     m_oldWndProc = (WXFARPROC)::GetWindowLong((HWND)hWnd, GWL_WNDPROC);
1018
1019     // we don't need to subclass the window of our own class (in the Windows
1020     // sense of the word)
1021         if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )
1022     {
1023         ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
1024     }
1025     else
1026     {
1027         // don't bother restoring it neither: this also makes it easy to
1028         // implement IsOfStandardClass() method which returns TRUE for the
1029         // standard controls and FALSE for the wxWindows own windows as it can
1030         // simply check m_oldWndProc
1031         m_oldWndProc = NULL;
1032     }
1033 }
1034
1035 void wxWindowMSW::UnsubclassWin()
1036 {
1037     wxRemoveHandleAssociation(this);
1038
1039     // Restore old Window proc
1040     HWND hwnd = GetHwnd();
1041     if ( hwnd )
1042     {
1043         m_hWnd = 0;
1044
1045         wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
1046
1047         if ( m_oldWndProc )
1048         {
1049             if ( !wxCheckWindowWndProc((WXHWND)hwnd, m_oldWndProc) )
1050             {
1051                 ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) m_oldWndProc);
1052             }
1053
1054             m_oldWndProc = NULL;
1055         }
1056     }
1057 }
1058
1059 bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
1060 {
1061     // Unicows note: the code below works, but only because WNDCLASS contains
1062     // original window handler rather that the unicows fake one. This may not
1063     // be on purpose, though; if it stops working with future versions of
1064     // unicows.dll, we can override unicows hooks by setting
1065     // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1066     // versions that keep track of fake<->real wnd proc mapping.
1067
1068         // On WinCE (at least), the wndproc comparison doesn't work,
1069         // so have to use something like this.
1070 #ifdef __WXWINCE__
1071         extern const wxChar *wxCanvasClassName;
1072         extern const wxChar *wxCanvasClassNameNR;
1073         extern const wxChar *wxMDIFrameClassName;
1074         extern const wxChar *wxMDIFrameClassNameNoRedraw;
1075         extern const wxChar *wxMDIChildFrameClassName;
1076         extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
1077         wxString str(wxGetWindowClass(hWnd));
1078         if (str == wxCanvasClassName ||
1079                 str == wxCanvasClassNameNR ||
1080                 str == wxMDIFrameClassName ||
1081                 str == wxMDIFrameClassNameNoRedraw ||
1082                 str == wxMDIChildFrameClassName ||
1083                 str == wxMDIChildFrameClassNameNoRedraw ||
1084                 str == _T("wxTLWHiddenParent"))
1085                 return TRUE; // Effectively means don't subclass
1086         else
1087                 return FALSE;
1088 #else
1089     WNDCLASS cls;
1090     if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd), &cls) )
1091     {
1092         wxLogLastError(_T("GetClassInfo"));
1093
1094         return FALSE;
1095     }
1096
1097     return wndProc == (WXFARPROC)cls.lpfnWndProc;
1098 #endif
1099 }
1100
1101 // ----------------------------------------------------------------------------
1102 // Style handling
1103 // ----------------------------------------------------------------------------
1104
1105 void wxWindowMSW::SetWindowStyleFlag(long flags)
1106 {
1107     long flagsOld = GetWindowStyleFlag();
1108     if ( flags == flagsOld )
1109         return;
1110
1111     // update the internal variable
1112     wxWindowBase::SetWindowStyleFlag(flags);
1113
1114     // now update the Windows style as well if needed - and if the window had
1115     // been already created
1116     if ( !GetHwnd() )
1117         return;
1118
1119     WXDWORD exstyle, exstyleOld;
1120     long style = MSWGetStyle(flags, &exstyle),
1121          styleOld = MSWGetStyle(flagsOld, &exstyleOld);
1122
1123     if ( style != styleOld )
1124     {
1125         // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1126         // this function so instead of simply setting the style to the new
1127         // value we clear the bits which were set in styleOld but are set in
1128         // the new one and set the ones which were not set before
1129         long styleReal = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1130         styleReal &= ~styleOld;
1131         styleReal |= style;
1132
1133         ::SetWindowLong(GetHwnd(), GWL_STYLE, styleReal);
1134     }
1135
1136     // and the extended style
1137     if ( exstyle != exstyleOld )
1138     {
1139         long exstyleReal = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1140         exstyleReal &= ~exstyleOld;
1141         exstyleReal |= exstyle;
1142
1143         ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyleReal);
1144
1145         // we must call SetWindowPos() to flash the cached extended style and
1146         // also to make the change to wxSTAY_ON_TOP style take effect: just
1147         // setting the style simply doesn't work
1148         if ( !::SetWindowPos(GetHwnd(),
1149                              exstyleReal & WS_EX_TOPMOST ? HWND_TOPMOST
1150                                                          : HWND_NOTOPMOST,
1151                              0, 0, 0, 0,
1152                              SWP_NOMOVE | SWP_NOSIZE) )
1153         {
1154             wxLogLastError(_T("SetWindowPos"));
1155         }
1156     }
1157 }
1158
1159 WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
1160 {
1161     // translate the style
1162     WXDWORD style = WS_CHILD | WS_VISIBLE;
1163
1164     if ( flags & wxCLIP_CHILDREN )
1165         style |= WS_CLIPCHILDREN;
1166
1167     if ( flags & wxCLIP_SIBLINGS )
1168         style |= WS_CLIPSIBLINGS;
1169
1170     if ( flags & wxVSCROLL )
1171         style |= WS_VSCROLL;
1172
1173     if ( flags & wxHSCROLL )
1174         style |= WS_HSCROLL;
1175
1176     const wxBorder border = GetBorder(flags);
1177
1178     // WS_BORDER is only required for wxBORDER_SIMPLE
1179     if ( border == wxBORDER_SIMPLE )
1180         style |= WS_BORDER;
1181
1182     // now deal with ext style if the caller wants it
1183     if ( exstyle )
1184     {
1185         *exstyle = 0;
1186
1187 #ifndef __WXWINCE__
1188         if ( flags & wxTRANSPARENT_WINDOW )
1189             *exstyle |= WS_EX_TRANSPARENT;
1190 #endif
1191
1192         switch ( border )
1193         {
1194             default:
1195             case wxBORDER_DEFAULT:
1196                 wxFAIL_MSG( _T("unknown border style") );
1197                 // fall through
1198
1199             case wxBORDER_NONE:
1200             case wxBORDER_SIMPLE:
1201                 break;
1202
1203             case wxBORDER_STATIC:
1204                 *exstyle |= WS_EX_STATICEDGE;
1205                 break;
1206
1207             case wxBORDER_RAISED:
1208                 *exstyle |= WS_EX_DLGMODALFRAME;
1209                 break;
1210
1211             case wxBORDER_SUNKEN:
1212                 *exstyle |= WS_EX_CLIENTEDGE;
1213                 style &= ~WS_BORDER;
1214                 break;
1215
1216             case wxBORDER_DOUBLE:
1217                 *exstyle |= WS_EX_DLGMODALFRAME;
1218                 break;
1219         }
1220
1221         // wxUniv doesn't use Windows dialog navigation functions at all
1222 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1223         // to make the dialog navigation work with the nested panels we must
1224         // use this style (top level windows such as dialogs don't need it)
1225         if ( (flags & wxTAB_TRAVERSAL) && !IsTopLevel() )
1226         {
1227             *exstyle |= WS_EX_CONTROLPARENT;
1228         }
1229 #endif // __WXUNIVERSAL__
1230     }
1231
1232     return style;
1233 }
1234
1235 // Setup background and foreground colours correctly
1236 void wxWindowMSW::SetupColours()
1237 {
1238     if ( GetParent() )
1239         SetBackgroundColour(GetParent()->GetBackgroundColour());
1240 }
1241
1242 bool wxWindowMSW::IsMouseInWindow() const
1243 {
1244     // get the mouse position
1245     POINT pt;
1246     ::GetCursorPos(&pt);
1247
1248     // find the window which currently has the cursor and go up the window
1249     // chain until we find this window - or exhaust it
1250     HWND hwnd = ::WindowFromPoint(pt);
1251     while ( hwnd && (hwnd != GetHwnd()) )
1252         hwnd = ::GetParent(hwnd);
1253
1254     return hwnd != NULL;
1255 }
1256
1257 void wxWindowMSW::OnInternalIdle()
1258 {
1259     // Check if we need to send a LEAVE event
1260     if ( m_mouseInWindow )
1261     {
1262         // note that we should generate the leave event whether the window has
1263         // or doesn't have mouse capture
1264         if ( !IsMouseInWindow() )
1265         {
1266             // Generate a LEAVE event
1267             m_mouseInWindow = FALSE;
1268
1269             // Unfortunately the mouse button and keyboard state may have
1270             // changed by the time the OnInternalIdle function is called, so 'state'
1271             // may be meaningless.
1272             int state = 0;
1273             if ( wxIsShiftDown() )
1274                 state |= MK_SHIFT;
1275             if ( wxIsCtrlDown() )
1276                 state |= MK_CONTROL;
1277             if ( GetKeyState( VK_LBUTTON ) )
1278                 state |= MK_LBUTTON;
1279             if ( GetKeyState( VK_MBUTTON ) )
1280                 state |= MK_MBUTTON;
1281             if ( GetKeyState( VK_RBUTTON ) )
1282                 state |= MK_RBUTTON;
1283
1284             POINT pt;
1285             if ( !::GetCursorPos(&pt) )
1286             {
1287                 wxLogLastError(_T("GetCursorPos"));
1288             }
1289
1290             // we need to have client coordinates here for symmetry with
1291             // wxEVT_ENTER_WINDOW
1292             RECT rect = wxGetWindowRect(GetHwnd());
1293             pt.x -= rect.left;
1294             pt.y -= rect.top;
1295
1296             wxMouseEvent event2(wxEVT_LEAVE_WINDOW);
1297             InitMouseEvent(event2, pt.x, pt.y, state);
1298
1299             (void)GetEventHandler()->ProcessEvent(event2);
1300         }
1301     }
1302
1303     if (wxUpdateUIEvent::CanUpdate(this))
1304         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1305 }
1306
1307 // Set this window to be the child of 'parent'.
1308 bool wxWindowMSW::Reparent(wxWindowBase *parent)
1309 {
1310     if ( !wxWindowBase::Reparent(parent) )
1311         return FALSE;
1312
1313     HWND hWndChild = GetHwnd();
1314     HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
1315
1316     ::SetParent(hWndChild, hWndParent);
1317
1318 #ifndef __WXWINCE__
1319     if ( ::GetWindowLong(hWndChild, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
1320     {
1321         EnsureParentHasControlParentStyle(GetParent());
1322     }
1323 #endif // !__WXWINCE__
1324
1325     return TRUE;
1326 }
1327
1328 static inline void SendSetRedraw(HWND hwnd, bool on)
1329 {
1330 #ifndef __WXMICROWIN__
1331     ::SendMessage(hwnd, WM_SETREDRAW, (WPARAM)on, 0);
1332 #endif
1333 }
1334
1335 void wxWindowMSW::Freeze()
1336 {
1337     SendSetRedraw(GetHwnd(), FALSE);
1338 }
1339
1340 void wxWindowMSW::Thaw()
1341 {
1342     SendSetRedraw(GetHwnd(), TRUE);
1343
1344     // we need to refresh everything or otherwise he invalidated area is not
1345     // repainted
1346     Refresh();
1347 }
1348
1349 void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
1350 {
1351     HWND hWnd = GetHwnd();
1352     if ( hWnd )
1353     {
1354         if ( rect )
1355         {
1356             RECT mswRect;
1357             mswRect.left = rect->x;
1358             mswRect.top = rect->y;
1359             mswRect.right = rect->x + rect->width;
1360             mswRect.bottom = rect->y + rect->height;
1361
1362             ::InvalidateRect(hWnd, &mswRect, eraseBack);
1363         }
1364         else
1365             ::InvalidateRect(hWnd, NULL, eraseBack);
1366     }
1367 }
1368
1369 void wxWindowMSW::Update()
1370 {
1371     if ( !::UpdateWindow(GetHwnd()) )
1372     {
1373         wxLogLastError(_T("UpdateWindow"));
1374     }
1375
1376 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1377     // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1378     // handler needs to be really drawn right now
1379     (void)::GdiFlush();
1380 #endif // __WIN32__
1381 }
1382
1383 // ---------------------------------------------------------------------------
1384 // drag and drop
1385 // ---------------------------------------------------------------------------
1386
1387
1388 #if wxUSE_DRAG_AND_DROP
1389 void wxWindowMSW::SetDropTarget(wxDropTarget *pDropTarget)
1390 {
1391     if ( m_dropTarget != 0 ) {
1392         m_dropTarget->Revoke(m_hWnd);
1393         delete m_dropTarget;
1394     }
1395
1396     m_dropTarget = pDropTarget;
1397     if ( m_dropTarget != 0 )
1398         m_dropTarget->Register(m_hWnd);
1399 }
1400 #endif // wxUSE_DRAG_AND_DROP
1401
1402 // old style file-manager drag&drop support: we retain the old-style
1403 // DragAcceptFiles in parallel with SetDropTarget.
1404 void wxWindowMSW::DragAcceptFiles(bool accept)
1405 {
1406 #if !defined(__WXWINCE__)
1407     HWND hWnd = GetHwnd();
1408     if ( hWnd )
1409         ::DragAcceptFiles(hWnd, (BOOL)accept);
1410 #endif
1411 }
1412
1413 // ----------------------------------------------------------------------------
1414 // tooltips
1415 // ----------------------------------------------------------------------------
1416
1417 #if wxUSE_TOOLTIPS
1418
1419 void wxWindowMSW::DoSetToolTip(wxToolTip *tooltip)
1420 {
1421     wxWindowBase::DoSetToolTip(tooltip);
1422
1423     if ( m_tooltip )
1424         m_tooltip->SetWindow((wxWindow *)this);
1425 }
1426
1427 #endif // wxUSE_TOOLTIPS
1428
1429 // ---------------------------------------------------------------------------
1430 // moving and resizing
1431 // ---------------------------------------------------------------------------
1432
1433 // Get total size
1434 void wxWindowMSW::DoGetSize(int *x, int *y) const
1435 {
1436     RECT rect = wxGetWindowRect(GetHwnd());
1437
1438     if ( x )
1439         *x = rect.right - rect.left;
1440     if ( y )
1441         *y = rect.bottom - rect.top;
1442 }
1443
1444 // Get size *available for subwindows* i.e. excluding menu bar etc.
1445 void wxWindowMSW::DoGetClientSize(int *x, int *y) const
1446 {
1447     RECT rect = wxGetClientRect(GetHwnd());
1448
1449     if ( x )
1450         *x = rect.right;
1451     if ( y )
1452         *y = rect.bottom;
1453 }
1454
1455 void wxWindowMSW::DoGetPosition(int *x, int *y) const
1456 {
1457     RECT rect = wxGetWindowRect(GetHwnd());
1458
1459     POINT point;
1460     point.x = rect.left;
1461     point.y = rect.top;
1462
1463     // we do the adjustments with respect to the parent only for the "real"
1464     // children, not for the dialogs/frames
1465     if ( !IsTopLevel() )
1466     {
1467         HWND hParentWnd = 0;
1468         wxWindow *parent = GetParent();
1469         if ( parent )
1470             hParentWnd = GetWinHwnd(parent);
1471
1472         // Since we now have the absolute screen coords, if there's a parent we
1473         // must subtract its top left corner
1474         if ( hParentWnd )
1475         {
1476             ::ScreenToClient(hParentWnd, &point);
1477         }
1478
1479         if ( parent )
1480         {
1481             // We may be faking the client origin. So a window that's really at (0,
1482             // 30) may appear (to wxWin apps) to be at (0, 0).
1483             wxPoint pt(parent->GetClientAreaOrigin());
1484             point.x -= pt.x;
1485             point.y -= pt.y;
1486         }
1487     }
1488
1489     if ( x )
1490         *x = point.x;
1491     if ( y )
1492         *y = point.y;
1493 }
1494
1495 void wxWindowMSW::DoScreenToClient(int *x, int *y) const
1496 {
1497     POINT pt;
1498     if ( x )
1499         pt.x = *x;
1500     if ( y )
1501         pt.y = *y;
1502
1503     ::ScreenToClient(GetHwnd(), &pt);
1504
1505     if ( x )
1506         *x = pt.x;
1507     if ( y )
1508         *y = pt.y;
1509 }
1510
1511 void wxWindowMSW::DoClientToScreen(int *x, int *y) const
1512 {
1513     POINT pt;
1514     if ( x )
1515         pt.x = *x;
1516     if ( y )
1517         pt.y = *y;
1518
1519     ::ClientToScreen(GetHwnd(), &pt);
1520
1521     if ( x )
1522         *x = pt.x;
1523     if ( y )
1524         *y = pt.y;
1525 }
1526
1527 void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
1528 {
1529     // TODO: is this consistent with other platforms?
1530     // Still, negative width or height shouldn't be allowed
1531     if (width < 0)
1532         width = 0;
1533     if (height < 0)
1534         height = 0;
1535     if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
1536     {
1537         wxLogLastError(wxT("MoveWindow"));
1538     }
1539 }
1540
1541 // set the size of the window: if the dimensions are positive, just use them,
1542 // but if any of them is equal to -1, it means that we must find the value for
1543 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1544 // which case -1 is a valid value for x and y)
1545 //
1546 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1547 // the width/height to best suit our contents, otherwise we reuse the current
1548 // width/height
1549 void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1550 {
1551     // get the current size and position...
1552     int currentX, currentY;
1553     GetPosition(&currentX, &currentY);
1554     int currentW,currentH;
1555     GetSize(&currentW, &currentH);
1556
1557     // ... and don't do anything (avoiding flicker) if it's already ok
1558     if ( x == currentX && y == currentY &&
1559          width == currentW && height == currentH )
1560     {
1561         return;
1562     }
1563
1564     if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1565         x = currentX;
1566     if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1567         y = currentY;
1568
1569     AdjustForParentClientOrigin(x, y, sizeFlags);
1570
1571     wxSize size(-1, -1);
1572     if ( width == -1 )
1573     {
1574         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
1575         {
1576             size = DoGetBestSize();
1577             width = size.x;
1578         }
1579         else
1580         {
1581             // just take the current one
1582             width = currentW;
1583         }
1584     }
1585
1586     if ( height == -1 )
1587     {
1588         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
1589         {
1590             if ( size.x == -1 )
1591             {
1592                 size = DoGetBestSize();
1593             }
1594             //else: already called DoGetBestSize() above
1595
1596             height = size.y;
1597         }
1598         else
1599         {
1600             // just take the current one
1601             height = currentH;
1602         }
1603     }
1604
1605     DoMoveWindow(x, y, width, height);
1606 }
1607
1608 void wxWindowMSW::DoSetClientSize(int width, int height)
1609 {
1610     // setting the client size is less obvious than it it could have been
1611     // because in the result of changing the total size the window scrollbar
1612     // may [dis]appear and/or its menubar may [un]wrap and so the client size
1613     // will not be correct as the difference between the total and client size
1614     // changes - so we keep changing it until we get it right
1615     //
1616     // normally this loop shouldn't take more than 3 iterations (usually 1 but
1617     // if scrollbars [dis]appear as the result of the first call, then 2 and it
1618     // may become 3 if the window had 0 size originally and so we didn't
1619     // calculate the scrollbar correction correctly during the first iteration)
1620     // but just to be on the safe side we check for it instead of making it an
1621     // "infinite" loop (i.e. leaving break inside as the only way to get out)
1622     for ( int i = 0; i < 4; i++ )
1623     {
1624         RECT rectClient;
1625         ::GetClientRect(GetHwnd(), &rectClient);
1626
1627         // if the size is already ok, stop here (rectClient.left = top = 0)
1628         if ( (rectClient.right == width || width == -1) &&
1629              (rectClient.bottom == height || height == -1) )
1630         {
1631             break;
1632         }
1633
1634         int widthClient = width,
1635             heightClient = height;
1636
1637         // Find the difference between the entire window (title bar and all)
1638         // and the client area; add this to the new client size to move the
1639         // window
1640         RECT rectWin;
1641         ::GetWindowRect(GetHwnd(), &rectWin);
1642
1643         widthClient += rectWin.right - rectWin.left - rectClient.right;
1644         heightClient += rectWin.bottom - rectWin.top - rectClient.bottom;
1645
1646         POINT point;
1647         point.x = rectWin.left;
1648         point.y = rectWin.top;
1649
1650         // MoveWindow positions the child windows relative to the parent, so
1651         // adjust if necessary
1652         if ( !IsTopLevel() )
1653         {
1654             wxWindow *parent = GetParent();
1655             if ( parent )
1656             {
1657                 ::ScreenToClient(GetHwndOf(parent), &point);
1658             }
1659         }
1660
1661         DoMoveWindow(point.x, point.y, widthClient, heightClient);
1662     }
1663 }
1664
1665 // For implementation purposes - sometimes decorations make the client area
1666 // smaller
1667 wxPoint wxWindowMSW::GetClientAreaOrigin() const
1668 {
1669     return wxPoint(0, 0);
1670 }
1671
1672 // ---------------------------------------------------------------------------
1673 // text metrics
1674 // ---------------------------------------------------------------------------
1675
1676 int wxWindowMSW::GetCharHeight() const
1677 {
1678     return wxGetTextMetrics(this).tmHeight;
1679 }
1680
1681 int wxWindowMSW::GetCharWidth() const
1682 {
1683     // +1 is needed because Windows apparently adds it when calculating the
1684     // dialog units size in pixels
1685 #if wxDIALOG_UNIT_COMPATIBILITY
1686     return wxGetTextMetrics(this).tmAveCharWidth;
1687 #else
1688     return wxGetTextMetrics(this).tmAveCharWidth + 1;
1689 #endif
1690 }
1691
1692 void wxWindowMSW::GetTextExtent(const wxString& string,
1693                              int *x, int *y,
1694                              int *descent, int *externalLeading,
1695                              const wxFont *theFont) const
1696 {
1697     const wxFont *fontToUse = theFont;
1698     if ( !fontToUse )
1699         fontToUse = &m_font;
1700
1701     HWND hWnd = GetHwnd();
1702     HDC dc = ::GetDC(hWnd);
1703
1704     HFONT fnt = 0;
1705     HFONT hfontOld = 0;
1706     if ( fontToUse && fontToUse->Ok() )
1707     {
1708         fnt = (HFONT)((wxFont *)fontToUse)->GetResourceHandle(); // const_cast
1709         if ( fnt )
1710             hfontOld = (HFONT)SelectObject(dc,fnt);
1711     }
1712
1713     SIZE sizeRect;
1714     TEXTMETRIC tm;
1715     GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
1716     GetTextMetrics(dc, &tm);
1717
1718     if ( fontToUse && fnt && hfontOld )
1719         SelectObject(dc, hfontOld);
1720
1721     ReleaseDC(hWnd, dc);
1722
1723     if ( x )
1724         *x = sizeRect.cx;
1725     if ( y )
1726         *y = sizeRect.cy;
1727     if ( descent )
1728         *descent = tm.tmDescent;
1729     if ( externalLeading )
1730         *externalLeading = tm.tmExternalLeading;
1731 }
1732
1733 // ---------------------------------------------------------------------------
1734 // popup menu
1735 // ---------------------------------------------------------------------------
1736
1737 #if wxUSE_MENUS_NATIVE
1738
1739 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1740 // immediately, without waiting for the next event loop iteration
1741 //
1742 // NB: this function should probably be made public later as it can almost
1743 //     surely replace wxYield() elsewhere as well
1744 static void wxYieldForCommandsOnly()
1745 {
1746     // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1747     // want to process it here)
1748     MSG msg;
1749     while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE) )
1750     {
1751         if ( msg.message == WM_QUIT )
1752         {
1753             // if we retrieved a WM_QUIT, insert back into the message queue.
1754             ::PostQuitMessage(0);
1755             break;
1756         }
1757
1758         // luckily (as we don't have access to wxEventLoopImpl method from here
1759         // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1760         // immediately
1761         ::TranslateMessage(&msg);
1762         ::DispatchMessage(&msg);
1763     }
1764 }
1765
1766 bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
1767 {
1768     menu->SetInvokingWindow(this);
1769     menu->UpdateUI();
1770
1771     HWND hWnd = GetHwnd();
1772     HMENU hMenu = GetHmenuOf(menu);
1773     POINT point;
1774     point.x = x;
1775     point.y = y;
1776     ::ClientToScreen(hWnd, &point);
1777     wxCurrentPopupMenu = menu;
1778     UINT flags = 0;
1779 #if !defined(__WXWINCE__)
1780     flags = TPM_RIGHTBUTTON;
1781 #endif
1782     ::TrackPopupMenu(hMenu, flags, point.x, point.y, 0, hWnd, NULL);
1783
1784     // we need to do it righ now as otherwise the events are never going to be
1785     // sent to wxCurrentPopupMenu from HandleCommand()
1786     //
1787     // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1788     // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1789     // destroyed as soon as we return (it can be a local variable in the caller
1790     // for example) and so we do need to process the event immediately
1791     wxYieldForCommandsOnly();
1792
1793     wxCurrentPopupMenu = NULL;
1794
1795     menu->SetInvokingWindow(NULL);
1796
1797     return TRUE;
1798 }
1799
1800 #endif // wxUSE_MENUS_NATIVE
1801
1802 // ===========================================================================
1803 // pre/post message processing
1804 // ===========================================================================
1805
1806 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1807 {
1808     if ( m_oldWndProc )
1809         return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
1810     else
1811         return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
1812 }
1813
1814 bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
1815 {
1816     // wxUniversal implements tab traversal itself
1817 #ifndef __WXUNIVERSAL__
1818     if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
1819     {
1820         // intercept dialog navigation keys
1821         MSG *msg = (MSG *)pMsg;
1822
1823         // here we try to do all the job which ::IsDialogMessage() usually does
1824         // internally
1825 #if 1
1826         if ( msg->message == WM_KEYDOWN )
1827         {
1828             bool bCtrlDown = wxIsCtrlDown();
1829             bool bShiftDown = wxIsShiftDown();
1830
1831             // WM_GETDLGCODE: ask the control if it wants the key for itself,
1832             // don't process it if it's the case (except for Ctrl-Tab/Enter
1833             // combinations which are always processed)
1834             LONG lDlgCode = 0;
1835             if ( !bCtrlDown )
1836             {
1837                 lDlgCode = ::SendMessage(msg->hwnd, WM_GETDLGCODE, 0, 0);
1838
1839                 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1840                 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1841                 // it, of course, implies them
1842                 if ( lDlgCode & DLGC_WANTALLKEYS )
1843                 {
1844                     lDlgCode |= DLGC_WANTTAB | DLGC_WANTARROWS;
1845                 }
1846             }
1847
1848             bool bForward = TRUE,
1849                  bWindowChange = FALSE;
1850
1851             // should we process this message specially?
1852             bool bProcess = TRUE;
1853             switch ( msg->wParam )
1854             {
1855                 case VK_TAB:
1856                     // assume that nobody wants Shift-TAB for himself - if we
1857                     // don't do it there is no easy way for a control to grab
1858                     // TABs but still let Shift-TAB work as navugation key
1859                     if ( (lDlgCode & DLGC_WANTTAB) && !bShiftDown ) {
1860                         bProcess = FALSE;
1861                     }
1862                     else {
1863                         // Ctrl-Tab cycles thru notebook pages
1864                         bWindowChange = bCtrlDown;
1865                         bForward = !bShiftDown;
1866                     }
1867                     break;
1868
1869                 case VK_UP:
1870                 case VK_LEFT:
1871                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1872                         bProcess = FALSE;
1873                     else
1874                         bForward = FALSE;
1875                     break;
1876
1877                 case VK_DOWN:
1878                 case VK_RIGHT:
1879                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1880                         bProcess = FALSE;
1881                     break;
1882
1883                 case VK_RETURN:
1884                     {
1885                         if ( (lDlgCode & DLGC_WANTMESSAGE) && !bCtrlDown )
1886                         {
1887                             // control wants to process Enter itself, don't
1888                             // call IsDialogMessage() which would interpret
1889                             // it
1890                             return FALSE;
1891                         }
1892                         else if ( lDlgCode & DLGC_BUTTON )
1893                         {
1894                             // let IsDialogMessage() handle this for all
1895                             // buttons except the owner-drawn ones which it
1896                             // just seems to ignore
1897                             long style = ::GetWindowLong(msg->hwnd, GWL_STYLE);
1898                             if ( (style & BS_OWNERDRAW) == BS_OWNERDRAW )
1899                             {
1900                                 // emulate the button click
1901                                 wxWindow *btn = wxFindWinFromHandle((WXHWND)msg->hwnd);
1902                                 if ( btn )
1903                                     btn->MSWCommand(BN_CLICKED, 0 /* unused */);
1904                             }
1905
1906                             bProcess = FALSE;
1907                         }
1908                         // FIXME: this should be handled by
1909                         //        wxNavigationKeyEvent handler and not here!!
1910                         else
1911                         {
1912 #if wxUSE_BUTTON
1913                             wxButton *btn = wxDynamicCast(GetDefaultItem(),
1914                                                           wxButton);
1915                             if ( btn && btn->IsEnabled() )
1916                             {
1917                                 // if we do have a default button, do press it
1918                                 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
1919
1920                                 return TRUE;
1921                             }
1922                             else // no default button
1923                             {
1924 #endif // wxUSE_BUTTON
1925                                 // this is a quick and dirty test for a text
1926                                 // control
1927                                 if ( !(lDlgCode & DLGC_HASSETSEL) )
1928                                 {
1929                                     // don't process Enter, the control might
1930                                     // need it for itself and don't let
1931                                     // ::IsDialogMessage() have it as it can
1932                                     // eat the Enter events sometimes
1933                                     return FALSE;
1934                                 }
1935                                 else if (!IsTopLevel())
1936                                 {
1937                                     // if not a top level window, let parent
1938                                     // handle it
1939                                     return FALSE;
1940                                 }
1941                                 //else: treat Enter as TAB: pass to the next
1942                                 //      control as this is the best thing to do
1943                                 //      if the text doesn't handle Enter itself
1944                             }
1945                         }
1946                     }
1947                     break;
1948
1949                 default:
1950                     bProcess = FALSE;
1951             }
1952
1953             if ( bProcess )
1954             {
1955                 wxNavigationKeyEvent event;
1956                 event.SetDirection(bForward);
1957                 event.SetWindowChange(bWindowChange);
1958                 event.SetEventObject(this);
1959
1960                 if ( GetEventHandler()->ProcessEvent(event) )
1961                 {
1962                     return TRUE;
1963                 }
1964             }
1965         }
1966 #else // 0
1967         // let ::IsDialogMessage() do almost everything and handle just the
1968         // things it doesn't here: Ctrl-TAB for switching notebook pages
1969         if ( msg->message == WM_KEYDOWN )
1970         {
1971             // don't process system keys here
1972             if ( !(HIWORD(msg->lParam) & KF_ALTDOWN) )
1973             {
1974                 if ( (msg->wParam == VK_TAB) && wxIsCtrlDown() )
1975                 {
1976                     // find the first notebook parent and change its page
1977                     wxWindow *win = this;
1978                     wxNotebook *nbook = NULL;
1979                     while ( win && !nbook )
1980                     {
1981                         nbook = wxDynamicCast(win, wxNotebook);
1982                         win = win->GetParent();
1983                     }
1984
1985                     if ( nbook )
1986                     {
1987                         bool forward = !wxIsShiftDown();
1988
1989                         nbook->AdvanceSelection(forward);
1990                     }
1991                 }
1992             }
1993         }
1994 #endif // 1/0
1995
1996         // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1997         // shouldn't let IsDialogMessage() get it as it _always_ eats the
1998         // message even when there is no cancel button and when the message is
1999         // needed by the control itself: in particular, it prevents the tree in
2000         // place edit control from being closed with Escape in a dialog
2001         if ( msg->message != WM_KEYDOWN || msg->wParam != VK_ESCAPE )
2002         {
2003             // ::IsDialogMessage() is broken and may sometimes hang the
2004             // application by going into an infinite loop, so we try to detect
2005             // [some of] the situatations when this may happen and not call it
2006             // then
2007
2008             // assume we can call it by default
2009             bool canSafelyCallIsDlgMsg = TRUE;
2010
2011             HWND hwndFocus = ::GetFocus();
2012
2013             // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2014             // an infinite loop, because it will recursively check the child
2015             // windows but not the window itself and so if none of the children
2016             // accepts focus it loops forever (as it only stops when it gets
2017             // back to the window it started from)
2018             //
2019             // while it is very unusual that a window with WS_EX_CONTROLPARENT
2020             // style has the focus, it can happen. One such possibility is if
2021             // all windows are either toplevel, wxDialog, wxPanel or static
2022             // controls and no window can actually accept keyboard input.
2023 #if !defined(__WXWINCE__)
2024             if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
2025             {
2026                 // passimistic by default
2027                 canSafelyCallIsDlgMsg = FALSE;
2028                 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2029                       node;
2030                       node = node->GetNext() )
2031                 {
2032                     wxWindow * const win = node->GetData();
2033                     if ( win->AcceptsFocus() &&
2034                             !(::GetWindowLong(GetHwndOf(win), GWL_EXSTYLE) &
2035                                 WS_EX_CONTROLPARENT) )
2036                     {
2037                         // it shouldn't hang...
2038                         canSafelyCallIsDlgMsg = TRUE;
2039
2040                         break;
2041                     }
2042                 }
2043             }
2044 #endif // !__WXWINCE__
2045
2046             if ( canSafelyCallIsDlgMsg )
2047             {
2048                 // ::IsDialogMessage() can enter in an infinite loop when the
2049                 // currently focused window is disabled or hidden and its
2050                 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2051                 // this case
2052                 while ( hwndFocus )
2053                 {
2054                     if ( !::IsWindowEnabled(hwndFocus) ||
2055                             !::IsWindowVisible(hwndFocus) )
2056                     {
2057                         // it would enter an infinite loop if we do this!
2058                         canSafelyCallIsDlgMsg = FALSE;
2059
2060                         break;
2061                     }
2062
2063                     if ( !(::GetWindowLong(hwndFocus, GWL_STYLE) & WS_CHILD) )
2064                     {
2065                         // it's a top level window, don't go further -- e.g. even
2066                         // if the parent of a dialog is disabled, this doesn't
2067                         // break navigation inside the dialog
2068                         break;
2069                     }
2070
2071                     hwndFocus = ::GetParent(hwndFocus);
2072                 }
2073             }
2074
2075             // let IsDialogMessage() have the message if it's safe to call it
2076             if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
2077             {
2078                 // IsDialogMessage() did something...
2079                 return TRUE;
2080             }
2081         }
2082     }
2083 #endif // __WXUNIVERSAL__
2084
2085 #if wxUSE_TOOLTIPS
2086     if ( m_tooltip )
2087     {
2088         // relay mouse move events to the tooltip control
2089         MSG *msg = (MSG *)pMsg;
2090         if ( msg->message == WM_MOUSEMOVE )
2091             m_tooltip->RelayEvent(pMsg);
2092     }
2093 #endif // wxUSE_TOOLTIPS
2094
2095     return FALSE;
2096 }
2097
2098 bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
2099 {
2100 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2101     return m_acceleratorTable.Translate(this, pMsg);
2102 #else
2103     (void) pMsg;
2104     return FALSE;
2105 #endif // wxUSE_ACCEL
2106 }
2107
2108 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
2109 {
2110     // preprocess all messages by default
2111     return TRUE;
2112 }
2113
2114 // ---------------------------------------------------------------------------
2115 // message params unpackers
2116 // ---------------------------------------------------------------------------
2117
2118 void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
2119                              WORD *id, WXHWND *hwnd, WORD *cmd)
2120 {
2121     *id = LOWORD(wParam);
2122     *hwnd = (WXHWND)lParam;
2123     *cmd = HIWORD(wParam);
2124 }
2125
2126 void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
2127                               WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
2128 {
2129     *state = LOWORD(wParam);
2130     *minimized = HIWORD(wParam);
2131     *hwnd = (WXHWND)lParam;
2132 }
2133
2134 void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
2135                             WXWORD *code, WXWORD *pos, WXHWND *hwnd)
2136 {
2137     *code = LOWORD(wParam);
2138     *pos = HIWORD(wParam);
2139     *hwnd = (WXHWND)lParam;
2140 }
2141
2142 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
2143                               WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
2144 {
2145 #ifndef __WXMICROWIN__
2146     *nCtlColor = CTLCOLOR_BTN;
2147     *hwnd = (WXHWND)lParam;
2148     *hdc = (WXHDC)wParam;
2149 #endif
2150 }
2151
2152 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
2153                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
2154 {
2155     *item = (WXWORD)wParam;
2156     *flags = HIWORD(wParam);
2157     *hmenu = (WXHMENU)lParam;
2158 }
2159
2160 // ---------------------------------------------------------------------------
2161 // Main wxWindows window proc and the window proc for wxWindow
2162 // ---------------------------------------------------------------------------
2163
2164 // Hook for new window just as it's being created, when the window isn't yet
2165 // associated with the handle
2166 static wxWindowMSW *gs_winBeingCreated = NULL;
2167
2168 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2169 // window being created and insures that it's always unset back later
2170 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW *winBeingCreated)
2171 {
2172     gs_winBeingCreated = winBeingCreated;
2173 }
2174
2175 wxWindowCreationHook::~wxWindowCreationHook()
2176 {
2177     gs_winBeingCreated = NULL;
2178 }
2179
2180 // Main window proc
2181 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2182 {
2183     // trace all messages - useful for the debugging
2184 #ifdef __WXDEBUG__
2185     wxLogTrace(wxTraceMessages,
2186                wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2187                wxGetMessageName(message), (long)hWnd, (long)wParam, lParam);
2188 #endif // __WXDEBUG__
2189
2190     wxWindowMSW *wnd = wxFindWinFromHandle((WXHWND) hWnd);
2191
2192     // when we get the first message for the HWND we just created, we associate
2193     // it with wxWindow stored in gs_winBeingCreated
2194     if ( !wnd && gs_winBeingCreated )
2195     {
2196         wxAssociateWinWithHandle(hWnd, gs_winBeingCreated);
2197         wnd = gs_winBeingCreated;
2198         gs_winBeingCreated = NULL;
2199         wnd->SetHWND((WXHWND)hWnd);
2200     }
2201
2202     LRESULT rc;
2203
2204     if ( wnd )
2205         rc = wnd->MSWWindowProc(message, wParam, lParam);
2206     else
2207         rc = ::DefWindowProc(hWnd, message, wParam, lParam);
2208
2209     return rc;
2210 }
2211
2212 long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
2213 {
2214     // did we process the message?
2215     bool processed = FALSE;
2216
2217     // the return value
2218     union
2219     {
2220         bool        allow;
2221         long        result;
2222         WXHICON     hIcon;
2223         WXHBRUSH    hBrush;
2224     } rc;
2225
2226     // for most messages we should return 0 when we do process the message
2227     rc.result = 0;
2228
2229     switch ( message )
2230     {
2231         case WM_CREATE:
2232             {
2233                 bool mayCreate;
2234                 processed = HandleCreate((WXLPCREATESTRUCT)lParam, &mayCreate);
2235                 if ( processed )
2236                 {
2237                     // return 0 to allow window creation
2238                     rc.result = mayCreate ? 0 : -1;
2239                 }
2240             }
2241             break;
2242
2243         case WM_DESTROY:
2244             // never set processed to TRUE and *always* pass WM_DESTROY to
2245             // DefWindowProc() as Windows may do some internal cleanup when
2246             // processing it and failing to pass the message along may cause
2247             // memory and resource leaks!
2248             (void)HandleDestroy();
2249             break;
2250
2251         case WM_MOVE:
2252             processed = HandleMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2253             break;
2254
2255 #if !defined(__WXWINCE__)
2256         case WM_MOVING:
2257             {
2258                 LPRECT pRect = (LPRECT)lParam;
2259                 wxRect rc;
2260                 rc.SetLeft(pRect->left);
2261                 rc.SetTop(pRect->top);
2262                 rc.SetRight(pRect->right);
2263                 rc.SetBottom(pRect->bottom);
2264                 processed = HandleMoving(rc);
2265                 if (processed) {
2266                     pRect->left = rc.GetLeft();
2267                     pRect->top = rc.GetTop();
2268                     pRect->right = rc.GetRight();
2269                     pRect->bottom = rc.GetBottom();
2270                 }
2271             }
2272             break;
2273 #endif
2274
2275         case WM_SIZE:
2276             switch ( wParam )
2277             {
2278                 case SIZE_MAXHIDE:
2279                 case SIZE_MAXSHOW:
2280                     // we're not interested in these messages at all
2281                     break;
2282
2283                 case SIZE_MINIMIZED:
2284                     // we shouldn't send sizev events for these messages as the
2285                     // client size may be negative which breaks existing code
2286                     //
2287                     // OTOH we might send another (wxMinimizedEvent?) one or
2288                     // add an additional parameter to wxSizeEvent if this is
2289                     // useful to anybody
2290                     break;
2291
2292                 default:
2293                     wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2294                     // fall through nevertheless
2295
2296                 case SIZE_MAXIMIZED:
2297                 case SIZE_RESTORED:
2298                     processed = HandleSize(LOWORD(lParam), HIWORD(lParam),
2299                                            wParam);
2300             }
2301             break;
2302
2303 #if !defined(__WXWINCE__)
2304         case WM_SIZING:
2305             {
2306                 LPRECT pRect = (LPRECT)lParam;
2307                 wxRect rc;
2308                 rc.SetLeft(pRect->left);
2309                 rc.SetTop(pRect->top);
2310                 rc.SetRight(pRect->right);
2311                 rc.SetBottom(pRect->bottom);
2312                 processed = HandleSizing(rc);
2313                 if (processed) {
2314                     pRect->left = rc.GetLeft();
2315                     pRect->top = rc.GetTop();
2316                     pRect->right = rc.GetRight();
2317                     pRect->bottom = rc.GetBottom();
2318                 }
2319             }
2320             break;
2321 #endif
2322
2323 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2324         case WM_ACTIVATEAPP:
2325             wxTheApp->SetActive(wParam != 0, FindFocus());
2326             break;
2327 #endif
2328
2329         case WM_ACTIVATE:
2330             {
2331                 WXWORD state, minimized;
2332                 WXHWND hwnd;
2333                 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
2334
2335                 processed = HandleActivate(state, minimized != 0, (WXHWND)hwnd);
2336             }
2337             break;
2338
2339         case WM_SETFOCUS:
2340             processed = HandleSetFocus((WXHWND)(HWND)wParam);
2341             break;
2342
2343         case WM_KILLFOCUS:
2344             processed = HandleKillFocus((WXHWND)(HWND)wParam);
2345             break;
2346
2347         case WM_PAINT:
2348             {
2349                 if ( wParam )
2350                 {
2351                     // cast to wxWindow is needed for wxUniv
2352                     wxPaintDCEx dc((wxWindow *)this, (WXHDC)wParam);
2353                     processed = HandlePaint();
2354                 }
2355                 else
2356                 {
2357                     processed = HandlePaint();
2358                 }
2359                 break;
2360             }
2361
2362 #ifndef __WXWINCE__
2363         case WM_PRINT:
2364             {
2365                 // Don't call the wx handlers in this case
2366                 if ( wxIsKindOf(this, wxListCtrl) )
2367                     break;
2368
2369                 if ( lParam & PRF_ERASEBKGND )
2370                     HandleEraseBkgnd((WXHDC)(HDC)wParam);
2371
2372                 wxPaintDCEx dc((wxWindow *)this, (WXHDC)wParam);
2373                 processed = HandlePaint();
2374             }
2375             break;
2376 #endif
2377
2378         case WM_CLOSE:
2379 #ifdef __WXUNIVERSAL__
2380             // Universal uses its own wxFrame/wxDialog, so we don't receive
2381             // close events unless we have this.
2382             Close();
2383             processed = TRUE;
2384             rc.result = TRUE;
2385 #else
2386             // don't let the DefWindowProc() destroy our window - we'll do it
2387             // ourselves in ~wxWindow
2388             processed = TRUE;
2389             rc.result = TRUE;
2390 #endif
2391             break;
2392
2393         case WM_SHOWWINDOW:
2394             processed = HandleShow(wParam != 0, (int)lParam);
2395             break;
2396
2397         case WM_MOUSEMOVE:
2398             processed = HandleMouseMove(GET_X_LPARAM(lParam),
2399                                         GET_Y_LPARAM(lParam),
2400                                         wParam);
2401             break;
2402
2403 #if wxUSE_MOUSEWHEEL
2404         case WM_MOUSEWHEEL:
2405             processed = HandleMouseWheel(wParam, lParam);
2406             break;
2407 #endif
2408
2409         case WM_LBUTTONDOWN:
2410         case WM_LBUTTONUP:
2411         case WM_LBUTTONDBLCLK:
2412         case WM_RBUTTONDOWN:
2413         case WM_RBUTTONUP:
2414         case WM_RBUTTONDBLCLK:
2415         case WM_MBUTTONDOWN:
2416         case WM_MBUTTONUP:
2417         case WM_MBUTTONDBLCLK:
2418             {
2419 #ifdef __WXMICROWIN__
2420                 // MicroWindows seems to ignore the fact that a window is
2421                 // disabled. So catch mouse events and throw them away if
2422                 // necessary.
2423                 wxWindowMSW* win = this;
2424                 for ( ;; )
2425                 {
2426                     if (!win->IsEnabled())
2427                     {
2428                         processed = TRUE;
2429                         break;
2430                     }
2431
2432                     win = win->GetParent();
2433                     if ( !win || win->IsTopLevel() )
2434                         break;
2435                 }
2436
2437                 if ( processed )
2438                     break;
2439
2440 #endif // __WXMICROWIN__
2441                 int x = GET_X_LPARAM(lParam),
2442                     y = GET_Y_LPARAM(lParam);
2443
2444                 // redirect the event to a static control if necessary by
2445                 // finding one under mouse
2446                 wxWindowMSW *win;
2447                 if ( GetCapture() == this )
2448                 {
2449                     // but don't do it if the mouse is captured by this window
2450                     // because then it should really get this event itself
2451                     win = this;
2452                 }
2453                 else
2454                 {
2455                     win = FindWindowForMouseEvent(this, &x, &y);
2456
2457                     // this should never happen
2458                     wxCHECK_MSG( win, 0,
2459                                  _T("FindWindowForMouseEvent() returned NULL") );
2460
2461                     // for the standard classes their WndProc sets the focus to
2462                     // them anyhow and doing it from here results in some weird
2463                     // problems, but for our windows we want them to acquire
2464                     // focus when clicked
2465                     if ( !win->IsOfStandardClass() )
2466                     {
2467                         if ( message == WM_LBUTTONDOWN && win->AcceptsFocus() )
2468                             win->SetFocus();
2469                     }
2470                 }
2471
2472                 processed = win->HandleMouseEvent(message, x, y, wParam);
2473             }
2474             break;
2475
2476 #ifdef MM_JOY1MOVE
2477         case MM_JOY1MOVE:
2478         case MM_JOY2MOVE:
2479         case MM_JOY1ZMOVE:
2480         case MM_JOY2ZMOVE:
2481         case MM_JOY1BUTTONDOWN:
2482         case MM_JOY2BUTTONDOWN:
2483         case MM_JOY1BUTTONUP:
2484         case MM_JOY2BUTTONUP:
2485             processed = HandleJoystickEvent(message,
2486                                             GET_X_LPARAM(lParam),
2487                                             GET_Y_LPARAM(lParam),
2488                                             wParam);
2489             break;
2490 #endif // __WXMICROWIN__
2491
2492         case WM_SYSCOMMAND:
2493             processed = HandleSysCommand(wParam, lParam);
2494             break;
2495
2496         case WM_COMMAND:
2497             {
2498                 WORD id, cmd;
2499                 WXHWND hwnd;
2500                 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
2501
2502                 processed = HandleCommand(id, cmd, hwnd);
2503             }
2504             break;
2505
2506         case WM_NOTIFY:
2507             processed = HandleNotify((int)wParam, lParam, &rc.result);
2508             break;
2509
2510             // for these messages we must return TRUE if process the message
2511 #ifdef WM_DRAWITEM
2512         case WM_DRAWITEM:
2513         case WM_MEASUREITEM:
2514             {
2515                 int idCtrl = (UINT)wParam;
2516                 if ( message == WM_DRAWITEM )
2517                 {
2518                     processed = MSWOnDrawItem(idCtrl,
2519                                               (WXDRAWITEMSTRUCT *)lParam);
2520                 }
2521                 else
2522                 {
2523                     processed = MSWOnMeasureItem(idCtrl,
2524                                                  (WXMEASUREITEMSTRUCT *)lParam);
2525                 }
2526
2527                 if ( processed )
2528                     rc.result = TRUE;
2529             }
2530             break;
2531 #endif // defined(WM_DRAWITEM)
2532
2533         case WM_GETDLGCODE:
2534             if ( !IsOfStandardClass() )
2535             {
2536                 // we always want to get the char events
2537                 rc.result = DLGC_WANTCHARS;
2538
2539                 if ( GetWindowStyleFlag() & wxWANTS_CHARS )
2540                 {
2541                     // in fact, we want everything
2542                     rc.result |= DLGC_WANTARROWS |
2543                                  DLGC_WANTTAB |
2544                                  DLGC_WANTALLKEYS;
2545                 }
2546
2547                 processed = TRUE;
2548             }
2549             //else: get the dlg code from the DefWindowProc()
2550             break;
2551
2552         case WM_SYSKEYDOWN:
2553         case WM_KEYDOWN:
2554             // If this has been processed by an event handler, return 0 now
2555             // (we've handled it).
2556             m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
2557             if ( m_lastKeydownProcessed )
2558             {
2559                 processed = TRUE;
2560             }
2561
2562             if ( !processed )
2563             {
2564                 switch ( wParam )
2565                 {
2566                     // we consider these message "not interesting" to OnChar, so
2567                     // just don't do anything more with them
2568                     case VK_SHIFT:
2569                     case VK_CONTROL:
2570                     case VK_MENU:
2571                     case VK_CAPITAL:
2572                     case VK_NUMLOCK:
2573                     case VK_SCROLL:
2574                         processed = TRUE;
2575                         break;
2576
2577                     // avoid duplicate messages to OnChar for these ASCII keys:
2578                     // they will be translated by TranslateMessage() and received
2579                     // in WM_CHAR
2580                     case VK_ESCAPE:
2581                     case VK_SPACE:
2582                     case VK_RETURN:
2583                     case VK_BACK:
2584                     case VK_TAB:
2585                     case VK_ADD:
2586                     case VK_SUBTRACT:
2587                     case VK_MULTIPLY:
2588                     case VK_DIVIDE:
2589                     case VK_OEM_1:
2590                     case VK_OEM_2:
2591                     case VK_OEM_3:
2592                     case VK_OEM_4:
2593                     case VK_OEM_5:
2594                     case VK_OEM_6:
2595                     case VK_OEM_7:
2596                     case VK_OEM_PLUS:
2597                     case VK_OEM_COMMA:
2598                     case VK_OEM_MINUS:
2599                     case VK_OEM_PERIOD:
2600                         // but set processed to FALSE, not TRUE to still pass them
2601                         // to the control's default window proc - otherwise
2602                         // built-in keyboard handling won't work
2603                         processed = FALSE;
2604                         break;
2605
2606 #ifdef VK_APPS
2607                     // special case of VK_APPS: treat it the same as right mouse
2608                     // click because both usually pop up a context menu
2609                     case VK_APPS:
2610                         {
2611                             WPARAM flags;
2612                             int x, y;
2613
2614                             TranslateKbdEventToMouse(this, &x, &y, &flags);
2615                             processed = HandleMouseEvent(WM_RBUTTONDOWN, x, y, flags);
2616                         }
2617                         break;
2618 #endif // VK_APPS
2619
2620                     default:
2621                         // do generate a CHAR event
2622                         processed = HandleChar((WORD)wParam, lParam);
2623                 }
2624             }
2625             if (message == WM_SYSKEYDOWN)  // Let Windows still handle the SYSKEYs
2626                 processed = FALSE;
2627             break;
2628
2629         case WM_SYSKEYUP:
2630         case WM_KEYUP:
2631 #ifdef VK_APPS
2632             // special case of VK_APPS: treat it the same as right mouse button
2633             if ( wParam == VK_APPS )
2634             {
2635                 WPARAM flags;
2636                 int x, y;
2637
2638                 TranslateKbdEventToMouse(this, &x, &y, &flags);
2639                 processed = HandleMouseEvent(WM_RBUTTONUP, x, y, flags);
2640             }
2641             else
2642 #endif // VK_APPS
2643             {
2644                 processed = HandleKeyUp((WORD) wParam, lParam);
2645             }
2646             break;
2647
2648         case WM_SYSCHAR:
2649         case WM_CHAR: // Always an ASCII character
2650             if ( m_lastKeydownProcessed )
2651             {
2652                 // The key was handled in the EVT_KEY_DOWN and handling
2653                 // a key in an EVT_KEY_DOWN handler is meant, by
2654                 // design, to prevent EVT_CHARs from happening
2655                 m_lastKeydownProcessed = FALSE;
2656                 processed = TRUE;
2657             }
2658             else
2659             {
2660                 processed = HandleChar((WORD)wParam, lParam, TRUE);
2661             }
2662             break;
2663
2664 #if wxUSE_HOTKEY
2665         case WM_HOTKEY:
2666             processed = HandleHotKey((WORD)wParam, lParam);
2667             break;
2668 #endif // wxUSE_HOTKEY
2669
2670         case WM_HSCROLL:
2671         case WM_VSCROLL:
2672             {
2673                 WXWORD code, pos;
2674                 WXHWND hwnd;
2675                 UnpackScroll(wParam, lParam, &code, &pos, &hwnd);
2676
2677                 processed = MSWOnScroll(message == WM_HSCROLL ? wxHORIZONTAL
2678                                                               : wxVERTICAL,
2679                                         code, pos, hwnd);
2680             }
2681             break;
2682
2683         // CTLCOLOR messages are sent by children to query the parent for their
2684         // colors#ifndef __WXMICROWIN__
2685 #ifndef __WXMICROWIN__
2686         case WM_CTLCOLORMSGBOX:
2687         case WM_CTLCOLOREDIT:
2688         case WM_CTLCOLORLISTBOX:
2689         case WM_CTLCOLORBTN:
2690         case WM_CTLCOLORDLG:
2691         case WM_CTLCOLORSCROLLBAR:
2692         case WM_CTLCOLORSTATIC:
2693             {
2694                 WXWORD nCtlColor;
2695                 WXHDC hdc;
2696                 WXHWND hwnd;
2697                 UnpackCtlColor(wParam, lParam, &nCtlColor, &hdc, &hwnd);
2698
2699                 processed = HandleCtlColor(&rc.hBrush,
2700                                            (WXHDC)hdc,
2701                                            (WXHWND)hwnd,
2702                                            nCtlColor,
2703                                            message,
2704                                            wParam,
2705                                            lParam);
2706             }
2707             break;
2708 #endif // !__WXMICROWIN__
2709
2710         case WM_SYSCOLORCHANGE:
2711             // the return value for this message is ignored
2712             processed = HandleSysColorChange();
2713             break;
2714
2715 #if !defined(__WXWINCE__)
2716         case WM_DISPLAYCHANGE:
2717             processed = HandleDisplayChange();
2718             break;
2719 #endif
2720
2721         case WM_PALETTECHANGED:
2722             processed = HandlePaletteChanged((WXHWND) (HWND) wParam);
2723             break;
2724
2725         case WM_CAPTURECHANGED:
2726             processed = HandleCaptureChanged((WXHWND) (HWND) lParam);
2727             break;
2728
2729         case WM_QUERYNEWPALETTE:
2730             processed = HandleQueryNewPalette();
2731             break;
2732
2733         case WM_ERASEBKGND:
2734             processed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
2735             if ( processed )
2736             {
2737                 // we processed the message, i.e. erased the background
2738                 rc.result = TRUE;
2739             }
2740             break;
2741
2742 #if !defined(__WXWINCE__)
2743         case WM_DROPFILES:
2744             processed = HandleDropFiles(wParam);
2745             break;
2746 #endif
2747
2748         case WM_INITDIALOG:
2749             processed = HandleInitDialog((WXHWND)(HWND)wParam);
2750
2751             if ( processed )
2752             {
2753                 // we never set focus from here
2754                 rc.result = FALSE;
2755             }
2756             break;
2757
2758 #if !defined(__WXWINCE__)
2759         case WM_QUERYENDSESSION:
2760             processed = HandleQueryEndSession(lParam, &rc.allow);
2761             break;
2762
2763         case WM_ENDSESSION:
2764             processed = HandleEndSession(wParam != 0, lParam);
2765             break;
2766
2767         case WM_GETMINMAXINFO:
2768             processed = HandleGetMinMaxInfo((MINMAXINFO*)lParam);
2769             break;
2770 #endif
2771
2772         case WM_SETCURSOR:
2773             processed = HandleSetCursor((WXHWND)(HWND)wParam,
2774                                         LOWORD(lParam),     // hit test
2775                                         HIWORD(lParam));    // mouse msg
2776
2777             if ( processed )
2778             {
2779                 // returning TRUE stops the DefWindowProc() from further
2780                 // processing this message - exactly what we need because we've
2781                 // just set the cursor.
2782                 rc.result = TRUE;
2783             }
2784             break;
2785
2786 #if wxUSE_ACCESSIBILITY
2787         case WM_GETOBJECT:
2788             {
2789                 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2790                 LPARAM dwObjId = (LPARAM) (DWORD) lParam;
2791
2792                 if (dwObjId == (LPARAM)OBJID_CLIENT && GetOrCreateAccessible())
2793                 {
2794                     return LresultFromObject(IID_IAccessible, wParam, (IUnknown*) GetAccessible()->GetIAccessible());
2795                 }
2796                 break;
2797             }
2798 #endif
2799
2800 #if defined(WM_HELP)
2801         case WM_HELP:
2802             {
2803                 // HELPINFO doesn't seem to be supported on WinCE.
2804 #ifndef __WXWINCE__
2805                 HELPINFO* info = (HELPINFO*) lParam;
2806                 // Don't yet process menu help events, just windows
2807                 if (info->iContextType == HELPINFO_WINDOW)
2808                 {
2809 #endif
2810                     wxWindowMSW* subjectOfHelp = this;
2811                     bool eventProcessed = FALSE;
2812                     while (subjectOfHelp && !eventProcessed)
2813                     {
2814                         wxHelpEvent helpEvent(wxEVT_HELP,
2815                                               subjectOfHelp->GetId(),
2816 #ifdef __WXWINCE__
2817                                               wxPoint(0, 0)
2818 #else
2819                                               wxPoint(info->MousePos.x, info->MousePos.y)
2820 #endif
2821                                               );
2822
2823                         helpEvent.SetEventObject(this);
2824                         eventProcessed =
2825                             GetEventHandler()->ProcessEvent(helpEvent);
2826
2827                         // Go up the window hierarchy until the event is
2828                         // handled (or not)
2829                         subjectOfHelp = subjectOfHelp->GetParent();
2830                     }
2831
2832                     processed = eventProcessed;
2833 #ifndef __WXWINCE__
2834                 }
2835                 else if (info->iContextType == HELPINFO_MENUITEM)
2836                 {
2837                     wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId);
2838                     helpEvent.SetEventObject(this);
2839                     processed = GetEventHandler()->ProcessEvent(helpEvent);
2840
2841                 }
2842                 //else: processed is already FALSE
2843 #endif
2844             }
2845             break;
2846 #endif
2847
2848 #if !defined(__WXWINCE__)
2849         case WM_CONTEXTMENU:
2850             {
2851                 // we don't convert from screen to client coordinates as
2852                 // the event may be handled by a parent window
2853                 wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2854
2855                 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
2856                 evtCtx.SetEventObject(this);
2857                 processed = GetEventHandler()->ProcessEvent(evtCtx);
2858             }
2859             break;
2860 #endif
2861
2862         case WM_MENUCHAR:
2863             // we're only interested in our own menus, not MF_SYSMENU
2864             if ( HIWORD(wParam) == MF_POPUP )
2865             {
2866                 // handle menu chars for ownerdrawn menu items
2867                 int i = HandleMenuChar(toupper(LOWORD(wParam)), lParam);
2868                 if ( i != wxNOT_FOUND )
2869                 {
2870                     rc.result = MAKELRESULT(i, MNC_EXECUTE);
2871                     processed = TRUE;
2872                 }
2873             }
2874             break;
2875     }
2876
2877     if ( !processed )
2878     {
2879 #ifdef __WXDEBUG__
2880         wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
2881                    wxGetMessageName(message));
2882 #endif // __WXDEBUG__
2883         rc.result = MSWDefWindowProc(message, wParam, lParam);
2884     }
2885
2886     return rc.result;
2887 }
2888
2889 // ----------------------------------------------------------------------------
2890 // wxWindow <-> HWND map
2891 // ----------------------------------------------------------------------------
2892
2893 wxWinHashTable *wxWinHandleHash = NULL;
2894
2895 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
2896 {
2897     return wxWinHandleHash->Get((long)hWnd);
2898 }
2899
2900 void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
2901 {
2902     // adding NULL hWnd is (first) surely a result of an error and
2903     // (secondly) breaks menu command processing
2904     wxCHECK_RET( hWnd != (HWND)NULL,
2905                  wxT("attempt to add a NULL hWnd to window list ignored") );
2906
2907     wxWindow *oldWin = wxFindWinFromHandle((WXHWND) hWnd);
2908 #ifdef __WXDEBUG__
2909     if ( oldWin && (oldWin != win) )
2910     {
2911         wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2912                    (int) hWnd, win->GetClassInfo()->GetClassName());
2913     }
2914     else
2915 #endif // __WXDEBUG__
2916     if (!oldWin)
2917     {
2918         wxWinHandleHash->Put((long)hWnd, (wxWindow *)win);
2919     }
2920 }
2921
2922 void wxRemoveHandleAssociation(wxWindowMSW *win)
2923 {
2924     wxWinHandleHash->Delete((long)win->GetHWND());
2925 }
2926
2927 // ----------------------------------------------------------------------------
2928 // various MSW speciic class dependent functions
2929 // ----------------------------------------------------------------------------
2930
2931 // Default destroyer - override if you destroy it in some other way
2932 // (e.g. with MDI child windows)
2933 void wxWindowMSW::MSWDestroyWindow()
2934 {
2935 }
2936
2937 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
2938                                            const wxSize& size,
2939                                            int& x, int& y,
2940                                            int& w, int& h) const
2941 {
2942     static const int DEFAULT_Y = 200;
2943     static const int DEFAULT_H = 250;
2944
2945     bool nonDefault = FALSE;
2946
2947     if ( pos.x == -1 )
2948     {
2949         // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2950         // just as well set it to CW_USEDEFAULT as well
2951         x =
2952         y = CW_USEDEFAULT;
2953     }
2954     else
2955     {
2956         // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2957         // neither because it is not handled as a special value by Windows then
2958         // and so we have to choose some default value for it
2959         x = pos.x;
2960         y = pos.y == -1 ? DEFAULT_Y : pos.y;
2961
2962         nonDefault = TRUE;
2963     }
2964
2965     /*
2966       NB: there used to be some code here which set the initial size of the
2967           window to the client size of the parent if no explicit size was
2968           specified. This was wrong because wxWindows programs often assume
2969           that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2970           it. To see why, you should understand that Windows sends WM_SIZE from
2971           inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2972           from some base class ctor and so this WM_SIZE is not processed in the
2973           real class' OnSize() (because it's not fully constructed yet and the
2974           event goes to some base class OnSize() instead). So the WM_SIZE we
2975           rely on is the one sent when the parent frame resizes its children
2976           but here is the problem: if the child already has just the right
2977           size, nothing will happen as both wxWindows and Windows check for
2978           this and ignore any attempts to change the window size to the size it
2979           already has - so no WM_SIZE would be sent.
2980      */
2981     if ( size.x == -1 )
2982     {
2983         // as above, h is not used at all in this case anyhow
2984         w =
2985         h = CW_USEDEFAULT;
2986     }
2987     else
2988     {
2989         // and, again as above, we can't set the height to CW_USEDEFAULT here
2990         w = size.x;
2991         h = size.y == -1 ? DEFAULT_H  : size.y;
2992
2993         nonDefault = TRUE;
2994     }
2995
2996     AdjustForParentClientOrigin(x, y);
2997
2998     return nonDefault;
2999 }
3000
3001 WXHWND wxWindowMSW::MSWGetParent() const
3002 {
3003     return m_parent ? m_parent->GetHWND() : WXHWND(NULL);
3004 }
3005
3006 bool wxWindowMSW::MSWCreate(const wxChar *wclass,
3007                             const wxChar *title,
3008                             const wxPoint& pos,
3009                             const wxSize& size,
3010                             WXDWORD style,
3011                             WXDWORD extendedStyle)
3012 {
3013     // choose the position/size for the new window
3014     int x, y, w, h;
3015     (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
3016
3017     // controlId is menu handle for the top level windows, so set it to 0
3018     // unless we're creating a child window
3019     int controlId = style & WS_CHILD ? GetId() : 0;
3020
3021     // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3022     // which is the same but without CS_[HV]REDRAW class styles so using it
3023     // ensures that the window is not fully repainted on each resize
3024     wxString className(wclass);
3025     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
3026     {
3027         className += wxT("NR");
3028     }
3029
3030     // do create the window
3031     wxWindowCreationHook hook(this);
3032
3033 #ifdef __WXWINCE__
3034     if (extendedStyle == 0)
3035     {
3036         m_hWnd = (WXHWND)::CreateWindow
3037             (
3038             className,
3039             title ? title : wxEmptyString,
3040             style,
3041             x, y, w, h,
3042             (HWND)MSWGetParent(),
3043             (HMENU)controlId,
3044             wxGetInstance(),
3045             NULL                        // no extra data
3046             );
3047     }
3048     else
3049 #endif
3050     {
3051         m_hWnd = (WXHWND)::CreateWindowEx
3052             (
3053             extendedStyle,
3054             className,
3055             title ? title : wxEmptyString,
3056             style,
3057             x, y, w, h,
3058             (HWND)MSWGetParent(),
3059             (HMENU)controlId,
3060             wxGetInstance(),
3061             NULL                        // no extra data
3062             );
3063     }
3064
3065     if ( !m_hWnd )
3066     {
3067         wxLogSysError(_("Can't create window of class %s"), wclass);
3068
3069         return FALSE;
3070     }
3071
3072     SubclassWin(m_hWnd);
3073
3074     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
3075
3076     return TRUE;
3077 }
3078
3079 // ===========================================================================
3080 // MSW message handlers
3081 // ===========================================================================
3082
3083 // ---------------------------------------------------------------------------
3084 // WM_NOTIFY
3085 // ---------------------------------------------------------------------------
3086
3087 #ifdef __WIN95__
3088
3089 bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
3090 {
3091 #ifndef __WXMICROWIN__
3092     LPNMHDR hdr = (LPNMHDR)lParam;
3093     HWND hWnd = hdr->hwndFrom;
3094     wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
3095
3096     // if the control is one of our windows, let it handle the message itself
3097     if ( win )
3098     {
3099         return win->MSWOnNotify(idCtrl, lParam, result);
3100     }
3101
3102     // VZ: why did we do it? normally this is unnecessary and, besides, it
3103     //     breaks the message processing for the toolbars because the tooltip
3104     //     notifications were being forwarded to the toolbar child controls
3105     //     (if it had any) before being passed to the toolbar itself, so in my
3106     //     example the tooltip for the combobox was always shown instead of the
3107     //     correct button tooltips
3108 #if 0
3109     // try all our children
3110     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3111     while ( node )
3112     {
3113         wxWindow *child = node->GetData();
3114         if ( child->MSWOnNotify(idCtrl, lParam, result) )
3115         {
3116             return TRUE;
3117         }
3118
3119         node = node->GetNext();
3120     }
3121 #endif // 0
3122
3123     // by default, handle it ourselves
3124     return MSWOnNotify(idCtrl, lParam, result);
3125 #else // __WXMICROWIN__
3126     return FALSE;
3127 #endif
3128 }
3129
3130 #if wxUSE_TOOLTIPS
3131
3132 bool wxWindowMSW::HandleTooltipNotify(WXUINT code,
3133                                       WXLPARAM lParam,
3134                                       const wxString& ttip)
3135 {
3136     // I don't know why it happens, but the versions of comctl32.dll starting
3137     // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3138     // this message is supposed to be sent to Unicode programs only) -- hence
3139     // we need to handle it as well, otherwise no tooltips will be shown in
3140     // this case
3141 #ifndef __WXWINCE__
3142     if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW) || ttip.empty() )
3143     {
3144         // not a tooltip message or no tooltip to show anyhow
3145         return FALSE;
3146     }
3147 #endif
3148
3149     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
3150
3151 #if !wxUSE_UNICODE
3152     if ( code == (WXUINT) TTN_NEEDTEXTA )
3153     {
3154         // we pass just the pointer as we store the string internally anyhow
3155         ttText->lpszText = (char *)ttip.c_str();
3156     }
3157     else // TTN_NEEDTEXTW
3158 #endif // !Unicode
3159     {
3160 #if wxUSE_UNICODE
3161         // in Unicode mode this is just what we need
3162         ttText->lpszText = (wxChar *)ttip.c_str();
3163 #else // !Unicode
3164 /*
3165         MultiByteToWideChar(CP_ACP, 0, ttip, ttip.length()+1,
3166                             (wchar_t *)ttText->szText,
3167                             sizeof(ttText->szText) / sizeof(wchar_t));
3168 */
3169         // Fix by dimitrishortcut: see patch 771772
3170
3171         // FIXME: szText has a max of 80 bytes, so limit the tooltip string
3172         // length accordingly. Ideally lpszText should be used, but who
3173         // would be responsible for freeing the buffer?
3174
3175         // Maximum length of a tip is 39 characters. 39 is 80/2 minus 1 byte
3176         // needed for NULL character.
3177         size_t tipLength = wxMin(ttip.Len(), 39);
3178
3179         // Convert to WideChar without adding the NULL character. The NULL
3180         // character is added afterwards (Could have used ttip.Left(tipLength)
3181         // and a cchMultiByte parameter of tipLength+1, but this is more
3182         //efficient.
3183         ::MultiByteToWideChar(CP_ACP, 0, ttip, tipLength,
3184                              (wchar_t *)ttText->szText,
3185                              sizeof(ttText->szText) / sizeof(wchar_t));
3186
3187         // Add the NULL character.
3188         ttText->szText[tipLength*2+0] = '\0';
3189         ttText->szText[tipLength*2+1] = '\0';
3190
3191 #endif // Unicode/!Unicode
3192     }
3193
3194     return TRUE;
3195 }
3196
3197 #endif // wxUSE_TOOLTIPS
3198
3199 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
3200                               WXLPARAM lParam,
3201                               WXLPARAM* WXUNUSED(result))
3202 {
3203 #if wxUSE_TOOLTIPS
3204     if ( m_tooltip )
3205     {
3206         NMHDR* hdr = (NMHDR *)lParam;
3207         if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
3208         {
3209             // processed
3210             return TRUE;
3211         }
3212     }
3213 #endif // wxUSE_TOOLTIPS
3214
3215     return FALSE;
3216 }
3217
3218 #endif // __WIN95__
3219
3220 // ---------------------------------------------------------------------------
3221 // end session messages
3222 // ---------------------------------------------------------------------------
3223
3224 bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
3225 {
3226 #ifndef __WXWINCE__
3227     wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
3228     event.SetEventObject(wxTheApp);
3229     event.SetCanVeto(TRUE);
3230     event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
3231
3232     bool rc = wxTheApp->ProcessEvent(event);
3233
3234     if ( rc )
3235     {
3236         // we may end only if the app didn't veto session closing (double
3237         // negation...)
3238         *mayEnd = !event.GetVeto();
3239     }
3240
3241     return rc;
3242 #else
3243     return FALSE;
3244 #endif
3245 }
3246
3247 bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
3248 {
3249 #ifndef __WXWINCE__
3250     // do nothing if the session isn't ending
3251     if ( !endSession )
3252         return FALSE;
3253
3254     // only send once
3255     if ( (this != wxTheApp->GetTopWindow()) )
3256         return FALSE;
3257
3258     wxCloseEvent event(wxEVT_END_SESSION, -1);
3259     event.SetEventObject(wxTheApp);
3260     event.SetCanVeto(FALSE);
3261     event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
3262
3263     return wxTheApp->ProcessEvent(event);
3264 #else
3265     return FALSE;
3266 #endif
3267 }
3268
3269 // ---------------------------------------------------------------------------
3270 // window creation/destruction
3271 // ---------------------------------------------------------------------------
3272
3273 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate)
3274 {
3275     // VZ: why is this commented out for WinCE? If it doesn't support
3276     //     WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3277     //     not with multiple #ifdef's!
3278 #ifndef __WXWINCE__
3279     if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
3280         EnsureParentHasControlParentStyle(GetParent());
3281 #endif // !__WXWINCE__
3282
3283     // TODO: should generate this event from WM_NCCREATE
3284     wxWindowCreateEvent event((wxWindow *)this);
3285     (void)GetEventHandler()->ProcessEvent(event);
3286
3287     *mayCreate = TRUE;
3288
3289     return TRUE;
3290 }
3291
3292 bool wxWindowMSW::HandleDestroy()
3293 {
3294     SendDestroyEvent();
3295
3296     // delete our drop target if we've got one
3297 #if wxUSE_DRAG_AND_DROP
3298     if ( m_dropTarget != NULL )
3299     {
3300         m_dropTarget->Revoke(m_hWnd);
3301
3302         delete m_dropTarget;
3303         m_dropTarget = NULL;
3304     }
3305 #endif // wxUSE_DRAG_AND_DROP
3306
3307     // WM_DESTROY handled
3308     return TRUE;
3309 }
3310
3311 // ---------------------------------------------------------------------------
3312 // activation/focus
3313 // ---------------------------------------------------------------------------
3314
3315 bool wxWindowMSW::HandleActivate(int state,
3316                               bool WXUNUSED(minimized),
3317                               WXHWND WXUNUSED(activate))
3318 {
3319     wxActivateEvent event(wxEVT_ACTIVATE,
3320                           (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
3321                           m_windowId);
3322     event.SetEventObject(this);
3323
3324     return GetEventHandler()->ProcessEvent(event);
3325 }
3326
3327 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
3328 {
3329     // notify the parent keeping track of focus for the kbd navigation
3330     // purposes that we got it
3331     wxChildFocusEvent eventFocus((wxWindow *)this);
3332     (void)GetEventHandler()->ProcessEvent(eventFocus);
3333
3334 #if wxUSE_CARET
3335     // Deal with caret
3336     if ( m_caret )
3337     {
3338         m_caret->OnSetFocus();
3339     }
3340 #endif // wxUSE_CARET
3341
3342 #if wxUSE_TEXTCTRL
3343     // If it's a wxTextCtrl don't send the event as it will be done
3344     // after the control gets to process it from EN_FOCUS handler
3345     if ( wxDynamicCastThis(wxTextCtrl) )
3346     {
3347         return FALSE;
3348     }
3349 #endif // wxUSE_TEXTCTRL
3350
3351     wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
3352     event.SetEventObject(this);
3353
3354     // wxFindWinFromHandle() may return NULL, it is ok
3355     event.SetWindow(wxFindWinFromHandle(hwnd));
3356
3357     return GetEventHandler()->ProcessEvent(event);
3358 }
3359
3360 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
3361 {
3362 #if wxUSE_CARET
3363     // Deal with caret
3364     if ( m_caret )
3365     {
3366         m_caret->OnKillFocus();
3367     }
3368 #endif // wxUSE_CARET
3369
3370 #if wxUSE_TEXTCTRL
3371     // If it's a wxTextCtrl don't send the event as it will be done
3372     // after the control gets to process it.
3373     wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
3374     if ( ctrl )
3375     {
3376         return FALSE;
3377     }
3378 #endif
3379
3380     // Don't send the event when in the process of being deleted.  This can
3381     // only cause problems if the event handler tries to access the object.
3382     if ( m_isBeingDeleted )
3383     {
3384         return FALSE;
3385     }
3386
3387     wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
3388     event.SetEventObject(this);
3389
3390     // wxFindWinFromHandle() may return NULL, it is ok
3391     event.SetWindow(wxFindWinFromHandle(hwnd));
3392
3393     return GetEventHandler()->ProcessEvent(event);
3394 }
3395
3396 // ---------------------------------------------------------------------------
3397 // miscellaneous
3398 // ---------------------------------------------------------------------------
3399
3400 bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
3401 {
3402     wxShowEvent event(GetId(), show);
3403     event.m_eventObject = this;
3404
3405     return GetEventHandler()->ProcessEvent(event);
3406 }
3407
3408 bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
3409 {
3410     wxInitDialogEvent event(GetId());
3411     event.m_eventObject = this;
3412
3413     return GetEventHandler()->ProcessEvent(event);
3414 }
3415
3416 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
3417 {
3418 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3419     return FALSE;
3420 #else // __WXMICROWIN__
3421     HDROP hFilesInfo = (HDROP) wParam;
3422
3423     // Get the total number of files dropped
3424     UINT gwFilesDropped = ::DragQueryFile
3425                             (
3426                                 (HDROP)hFilesInfo,
3427                                 (UINT)-1,
3428                                 (LPTSTR)0,
3429                                 (UINT)0
3430                             );
3431
3432     wxString *files = new wxString[gwFilesDropped];
3433     for ( UINT wIndex = 0; wIndex < gwFilesDropped; wIndex++ )
3434     {
3435         // first get the needed buffer length (+1 for terminating NUL)
3436         size_t len = ::DragQueryFile(hFilesInfo, wIndex, NULL, 0) + 1;
3437
3438         // and now get the file name
3439         ::DragQueryFile(hFilesInfo, wIndex,
3440                         wxStringBuffer(files[wIndex], len), len);
3441     }
3442     DragFinish (hFilesInfo);
3443
3444     wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
3445     event.m_eventObject = this;
3446
3447     POINT dropPoint;
3448     DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
3449     event.m_pos.x = dropPoint.x;
3450     event.m_pos.y = dropPoint.y;
3451
3452     return GetEventHandler()->ProcessEvent(event);
3453 #endif
3454 }
3455
3456
3457 bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
3458                                   short nHitTest,
3459                                   int WXUNUSED(mouseMsg))
3460 {
3461 #ifndef __WXMICROWIN__
3462     // the logic is as follows:
3463     // -1. don't set cursor for non client area, including but not limited to
3464     //     the title bar, scrollbars, &c
3465     //  0. allow the user to override default behaviour by using EVT_SET_CURSOR
3466     //  1. if we have the cursor set it unless wxIsBusy()
3467     //  2. if we're a top level window, set some cursor anyhow
3468     //  3. if wxIsBusy(), set the busy cursor, otherwise the global one
3469
3470     if ( nHitTest != HTCLIENT )
3471     {
3472         return FALSE;
3473     }
3474
3475     HCURSOR hcursor = 0;
3476
3477     // first ask the user code - it may wish to set the cursor in some very
3478     // specific way (for example, depending on the current position)
3479     POINT pt;
3480     if ( !::GetCursorPos(&pt) )
3481     {
3482         wxLogLastError(wxT("GetCursorPos"));
3483     }
3484
3485     int x = pt.x,
3486         y = pt.y;
3487     ScreenToClient(&x, &y);
3488     wxSetCursorEvent event(x, y);
3489
3490     bool processedEvtSetCursor = GetEventHandler()->ProcessEvent(event);
3491     if ( processedEvtSetCursor && event.HasCursor() )
3492     {
3493         hcursor = GetHcursorOf(event.GetCursor());
3494     }
3495
3496     if ( !hcursor )
3497     {
3498         bool isBusy = wxIsBusy();
3499
3500         // the test for processedEvtSetCursor is here to prevent using m_cursor
3501         // if the user code caught EVT_SET_CURSOR() and returned nothing from
3502         // it - this is a way to say that our cursor shouldn't be used for this
3503         // point
3504         if ( !processedEvtSetCursor && m_cursor.Ok() )
3505         {
3506             hcursor = GetHcursorOf(m_cursor);
3507         }
3508
3509         if ( !GetParent() )
3510         {
3511             if ( isBusy )
3512             {
3513                 hcursor = wxGetCurrentBusyCursor();
3514             }
3515             else if ( !hcursor )
3516             {
3517                 const wxCursor *cursor = wxGetGlobalCursor();
3518                 if ( cursor && cursor->Ok() )
3519                 {
3520                     hcursor = GetHcursorOf(*cursor);
3521                 }
3522             }
3523         }
3524     }
3525
3526     if ( hcursor )
3527     {
3528 //        wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3529
3530         ::SetCursor(hcursor);
3531
3532         // cursor set, stop here
3533         return TRUE;
3534     }
3535 #endif // __WXMICROWIN__
3536
3537     // pass up the window chain
3538     return FALSE;
3539 }
3540
3541 // ---------------------------------------------------------------------------
3542 // owner drawn stuff
3543 // ---------------------------------------------------------------------------
3544
3545 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3546         (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3547     #define WXUNUSED_UNLESS_ODRAWN(param) param
3548 #else
3549     #define WXUNUSED_UNLESS_ODRAWN(param)
3550 #endif
3551
3552 bool
3553 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
3554                            WXDRAWITEMSTRUCT * WXUNUSED_UNLESS_ODRAWN(itemStruct))
3555 {
3556 #if wxUSE_OWNER_DRAWN
3557
3558 #if wxUSE_MENUS_NATIVE
3559     // is it a menu item?
3560     DRAWITEMSTRUCT *pDrawStruct = (DRAWITEMSTRUCT *)itemStruct;
3561     if ( id == 0 && pDrawStruct->CtlType == ODT_MENU )
3562     {
3563         wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
3564
3565         wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3566
3567         // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3568         // the DC from being released
3569         wxDCTemp dc((WXHDC)pDrawStruct->hDC);
3570         wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
3571                     pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
3572                     pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
3573
3574         return pMenuItem->OnDrawItem
3575                (
3576                 dc,
3577                 rect,
3578                 (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
3579                 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
3580                );
3581     }
3582 #endif // wxUSE_MENUS_NATIVE
3583
3584 #endif // USE_OWNER_DRAWN
3585
3586 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3587
3588 #if wxUSE_OWNER_DRAWN
3589     wxControl *item = wxDynamicCast(FindItem(id), wxControl);
3590 #else // !wxUSE_OWNER_DRAWN
3591     // we may still have owner-drawn buttons internally because we have to make
3592     // them owner-drawn to support colour change
3593     wxControl *item = wxDynamicCast(FindItem(id), wxButton);
3594 #endif // USE_OWNER_DRAWN
3595
3596     if ( item )
3597     {
3598         return item->MSWOnDraw(itemStruct);
3599     }
3600
3601 #endif // wxUSE_CONTROLS
3602
3603     return FALSE;
3604 }
3605
3606 bool
3607 wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id),
3608                               WXMEASUREITEMSTRUCT *
3609                                   WXUNUSED_UNLESS_ODRAWN(itemStruct))
3610 {
3611 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3612     // is it a menu item?
3613     MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
3614     if ( id == 0 && pMeasureStruct->CtlType == ODT_MENU )
3615     {
3616         wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
3617
3618         wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3619
3620         return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
3621                                         &pMeasureStruct->itemHeight);
3622     }
3623
3624     wxControl *item = wxDynamicCast(FindItem(id), wxControl);
3625     if ( item )
3626     {
3627         return item->MSWOnMeasure(itemStruct);
3628     }
3629 #endif // wxUSE_OWNER_DRAWN
3630
3631     return FALSE;
3632 }
3633
3634 // ---------------------------------------------------------------------------
3635 // colours and palettes
3636 // ---------------------------------------------------------------------------
3637
3638 bool wxWindowMSW::HandleSysColorChange()
3639 {
3640     wxSysColourChangedEvent event;
3641     event.SetEventObject(this);
3642
3643     (void)GetEventHandler()->ProcessEvent(event);
3644
3645     // always let the system carry on the default processing to allow the
3646     // native controls to react to the colours update
3647     return FALSE;
3648 }
3649
3650 bool wxWindowMSW::HandleDisplayChange()
3651 {
3652     wxDisplayChangedEvent event;
3653     event.SetEventObject(this);
3654
3655     return GetEventHandler()->ProcessEvent(event);
3656 }
3657
3658 bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
3659                               WXHDC pDC,
3660                               WXHWND pWnd,
3661                               WXUINT nCtlColor,
3662                               WXUINT message,
3663                               WXWPARAM wParam,
3664                               WXLPARAM lParam)
3665 {
3666 #ifndef __WXMICROWIN__
3667     WXHBRUSH hBrush = 0;
3668
3669 #ifdef __WXWINCE__
3670     if (FALSE)
3671 #else
3672     if ( nCtlColor == CTLCOLOR_DLG )
3673 #endif
3674     {
3675         hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3676     }
3677 #if wxUSE_CONTROLS
3678     else
3679     {
3680         wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
3681         if ( item )
3682             hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3683     }
3684 #endif // wxUSE_CONTROLS
3685
3686     if ( hBrush )
3687         *brush = hBrush;
3688
3689     return hBrush != 0;
3690 #else // __WXMICROWIN__
3691     return FALSE;
3692 #endif
3693 }
3694
3695 // Define for each class of dialog and control
3696 WXHBRUSH wxWindowMSW::OnCtlColor(WXHDC WXUNUSED(hDC),
3697                                  WXHWND WXUNUSED(hWnd),
3698                                  WXUINT WXUNUSED(nCtlColor),
3699                                  WXUINT WXUNUSED(message),
3700                                  WXWPARAM WXUNUSED(wParam),
3701                                  WXLPARAM WXUNUSED(lParam))
3702 {
3703     return (WXHBRUSH)0;
3704 }
3705
3706 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
3707 {
3708 #if wxUSE_PALETTE
3709     // same as below except we don't respond to our own messages
3710     if ( hWndPalChange != GetHWND() )
3711     {
3712         // check to see if we our our parents have a custom palette
3713         wxWindowMSW *win = this;
3714         while ( win && !win->HasCustomPalette() )
3715         {
3716             win = win->GetParent();
3717         }
3718
3719         if ( win && win->HasCustomPalette() )
3720         {
3721             // realize the palette to see whether redrawing is needed
3722             HDC hdc = ::GetDC((HWND) hWndPalChange);
3723             win->m_palette.SetHPALETTE((WXHPALETTE)
3724                     ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3725
3726             int result = ::RealizePalette(hdc);
3727
3728             // restore the palette (before releasing the DC)
3729             win->m_palette.SetHPALETTE((WXHPALETTE)
3730                     ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3731             ::RealizePalette(hdc);
3732             ::ReleaseDC((HWND) hWndPalChange, hdc);
3733
3734             // now check for the need to redraw
3735             if (result > 0)
3736                 InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
3737         }
3738
3739     }
3740 #endif // wxUSE_PALETTE
3741
3742     wxPaletteChangedEvent event(GetId());
3743     event.SetEventObject(this);
3744     event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
3745
3746     return GetEventHandler()->ProcessEvent(event);
3747 }
3748
3749 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture)
3750 {
3751     wxMouseCaptureChangedEvent event(GetId(), wxFindWinFromHandle(hWndGainedCapture));
3752     event.SetEventObject(this);
3753
3754     return GetEventHandler()->ProcessEvent(event);
3755 }
3756
3757 bool wxWindowMSW::HandleQueryNewPalette()
3758 {
3759
3760 #if wxUSE_PALETTE
3761     // check to see if we our our parents have a custom palette
3762     wxWindowMSW *win = this;
3763     while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
3764     if (win->HasCustomPalette()) {
3765         /* realize the palette to see whether redrawing is needed */
3766         HDC hdc = GetDC((HWND) GetHWND());
3767         win->m_palette.SetHPALETTE( (WXHPALETTE)
3768              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
3769
3770         int result = ::RealizePalette(hdc);
3771         /* restore the palette (before releasing the DC) */
3772         win->m_palette.SetHPALETTE( (WXHPALETTE)
3773              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), TRUE) );
3774         ::RealizePalette(hdc);
3775         ::ReleaseDC((HWND) GetHWND(), hdc);
3776         /* now check for the need to redraw */
3777         if (result > 0)
3778             ::InvalidateRect((HWND) GetHWND(), NULL, TRUE);
3779         }
3780 #endif // wxUSE_PALETTE
3781
3782     wxQueryNewPaletteEvent event(GetId());
3783     event.SetEventObject(this);
3784
3785     return GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
3786 }
3787
3788 // Responds to colour changes: passes event on to children.
3789 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
3790 {
3791     // the top level window also reset the standard colour map as it might have
3792     // changed (there is no need to do it for the non top level windows as we
3793     // only have to do it once)
3794     if ( IsTopLevel() )
3795     {
3796         // FIXME-MT
3797         gs_hasStdCmap = FALSE;
3798     }
3799     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3800     while ( node )
3801     {
3802         // Only propagate to non-top-level windows because Windows already
3803         // sends this event to all top-level ones
3804         wxWindow *win = node->GetData();
3805         if ( !win->IsTopLevel() )
3806         {
3807             // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3808             // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3809             // the standard controls
3810             ::SendMessage(GetHwndOf(win), WM_SYSCOLORCHANGE, 0, 0);
3811         }
3812
3813         node = node->GetNext();
3814     }
3815
3816     // update the colours we use if they were not set explicitly by the user:
3817     // this must be done or OnCtlColor() would continue to use the old colours
3818     if ( !m_hasFgCol )
3819     {
3820         m_foregroundColour = wxSystemSettings::
3821                                 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
3822     }
3823
3824     if ( !m_hasBgCol )
3825     {
3826         m_backgroundColour = wxSystemSettings::
3827                                 GetSystemColour(wxSYS_COLOUR_BTNFACE);
3828     }
3829 }
3830
3831 extern wxCOLORMAP *wxGetStdColourMap()
3832 {
3833     static COLORREF s_stdColours[wxSTD_COL_MAX];
3834     static wxCOLORMAP s_cmap[wxSTD_COL_MAX];
3835
3836     if ( !gs_hasStdCmap )
3837     {
3838         static bool s_coloursInit = FALSE;
3839
3840         if ( !s_coloursInit )
3841         {
3842             // When a bitmap is loaded, the RGB values can change (apparently
3843             // because Windows adjusts them to care for the old programs always
3844             // using 0xc0c0c0 while the transparent colour for the new Windows
3845             // versions is different). But we do this adjustment ourselves so
3846             // we want to avoid Windows' "help" and for this we need to have a
3847             // reference bitmap which can tell us what the RGB values change
3848             // to.
3849             wxBitmap stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3850             if ( stdColourBitmap.Ok() )
3851             {
3852                 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3853                 wxASSERT_MSG( stdColourBitmap.GetWidth() == wxSTD_COL_MAX,
3854                               _T("forgot to update wxBITMAP_STD_COLOURS!") );
3855
3856                 wxMemoryDC memDC;
3857                 memDC.SelectObject(stdColourBitmap);
3858
3859                 wxColour colour;
3860                 for ( size_t i = 0; i < WXSIZEOF(s_stdColours); i++ )
3861                 {
3862                     memDC.GetPixel(i, 0, &colour);
3863                     s_stdColours[i] = wxColourToRGB(colour);
3864                 }
3865             }
3866             else // wxBITMAP_STD_COLOURS couldn't be loaded
3867             {
3868                 s_stdColours[0] = RGB(000,000,000);     // black
3869                 s_stdColours[1] = RGB(128,128,128);     // dark grey
3870                 s_stdColours[2] = RGB(192,192,192);     // light grey
3871                 s_stdColours[3] = RGB(255,255,255);     // white
3872                 //s_stdColours[4] = RGB(000,000,255);     // blue
3873                 //s_stdColours[5] = RGB(255,000,255);     // magenta
3874             }
3875
3876             s_coloursInit = TRUE;
3877         }
3878
3879         gs_hasStdCmap = TRUE;
3880
3881         // create the colour map
3882 #define INIT_CMAP_ENTRY(col) \
3883             s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3884             s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3885
3886         INIT_CMAP_ENTRY(BTNTEXT);
3887         INIT_CMAP_ENTRY(BTNSHADOW);
3888         INIT_CMAP_ENTRY(BTNFACE);
3889         INIT_CMAP_ENTRY(BTNHIGHLIGHT);
3890
3891 #undef INIT_CMAP_ENTRY
3892     }
3893
3894     return s_cmap;
3895 }
3896
3897 // ---------------------------------------------------------------------------
3898 // painting
3899 // ---------------------------------------------------------------------------
3900
3901 bool wxWindowMSW::HandlePaint()
3902 {
3903 //    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3904 //        return FALSE;
3905
3906     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3907     if ( !hRegion )
3908         wxLogLastError(wxT("CreateRectRgn"));
3909     if ( ::GetUpdateRgn(GetHwnd(), hRegion, FALSE) == ERROR )
3910         wxLogLastError(wxT("GetUpdateRgn"));
3911
3912     m_updateRegion = wxRegion((WXHRGN) hRegion);
3913
3914     wxPaintEvent event(m_windowId);
3915     event.SetEventObject(this);
3916
3917     bool processed = GetEventHandler()->ProcessEvent(event);
3918
3919     // note that we must generate NC event after the normal one as otherwise
3920     // BeginPaint() will happily overwrite our decorations with the background
3921     // colour
3922     wxNcPaintEvent eventNc(m_windowId);
3923     eventNc.SetEventObject(this);
3924     GetEventHandler()->ProcessEvent(eventNc);
3925
3926     return processed;
3927 }
3928
3929 // Can be called from an application's OnPaint handler
3930 void wxWindowMSW::OnPaint(wxPaintEvent& event)
3931 {
3932 #ifdef __WXUNIVERSAL__
3933     event.Skip();
3934 #else
3935     HDC hDC = (HDC) wxPaintDC::FindDCInCache((wxWindow*) event.GetEventObject());
3936     if (hDC != 0)
3937     {
3938         MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
3939     }
3940 #endif
3941 }
3942
3943 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
3944 {
3945     // Prevents flicker when dragging
3946     if ( ::IsIconic(GetHwnd()) )
3947         return TRUE;
3948
3949 #if 0
3950     if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3951     {
3952         return FALSE;
3953     }
3954
3955     if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3956     {
3957         if (wxUxThemeEngine::Get())
3958         {
3959             WXHTHEME hTheme = wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L"TAB");
3960             if (hTheme)
3961             {
3962                 WXURECT rect;
3963                 ::GetClientRect((HWND) GetHWND(), (RECT*) & rect);
3964                 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme, hdc, 10 /* TABP_BODY */, 0, &rect, &rect);
3965                 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme);
3966                 return TRUE;
3967             }
3968         }
3969     }
3970 #endif
3971
3972     wxDCTemp dc(hdc);
3973
3974     dc.SetHDC(hdc);
3975     dc.SetWindow((wxWindow *)this);
3976     dc.BeginDrawing();
3977
3978     wxEraseEvent event(m_windowId, &dc);
3979     event.SetEventObject(this);
3980     bool rc = GetEventHandler()->ProcessEvent(event);
3981
3982     dc.EndDrawing();
3983
3984     // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3985     dc.SelectOldObjects(hdc);
3986
3987     return rc;
3988 }
3989
3990 void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
3991 {
3992     RECT rect;
3993     ::GetClientRect(GetHwnd(), &rect);
3994
3995     COLORREF ref = PALETTERGB(m_backgroundColour.Red(),
3996                               m_backgroundColour.Green(),
3997                               m_backgroundColour.Blue());
3998     HBRUSH hBrush = ::CreateSolidBrush(ref);
3999     if ( !hBrush )
4000         wxLogLastError(wxT("CreateSolidBrush"));
4001
4002     HDC hdc = (HDC)event.GetDC()->GetHDC();
4003
4004 #ifndef __WXWINCE__
4005     int mode = ::SetMapMode(hdc, MM_TEXT);
4006 #endif
4007
4008     ::FillRect(hdc, &rect, hBrush);
4009     ::DeleteObject(hBrush);
4010
4011 #ifndef __WXWINCE__
4012     ::SetMapMode(hdc, mode);
4013 #endif
4014 }
4015
4016 // ---------------------------------------------------------------------------
4017 // moving and resizing
4018 // ---------------------------------------------------------------------------
4019
4020 bool wxWindowMSW::HandleMinimize()
4021 {
4022     wxIconizeEvent event(m_windowId);
4023     event.SetEventObject(this);
4024
4025     return GetEventHandler()->ProcessEvent(event);
4026 }
4027
4028 bool wxWindowMSW::HandleMaximize()
4029 {
4030     wxMaximizeEvent event(m_windowId);
4031     event.SetEventObject(this);
4032
4033     return GetEventHandler()->ProcessEvent(event);
4034 }
4035
4036 bool wxWindowMSW::HandleMove(int x, int y)
4037 {
4038     wxMoveEvent event(wxPoint(x, y), m_windowId);
4039     event.SetEventObject(this);
4040
4041     return GetEventHandler()->ProcessEvent(event);
4042 }
4043
4044 bool wxWindowMSW::HandleMoving(wxRect& rect)
4045 {
4046     wxMoveEvent event(rect, m_windowId);
4047     event.SetEventObject(this);
4048
4049     bool rc = GetEventHandler()->ProcessEvent(event);
4050     if (rc)
4051         rect = event.GetRect();
4052     return rc;
4053 }
4054
4055 bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
4056                              WXUINT WXUNUSED(flag))
4057 {
4058     // don't use w and h parameters as they specify the client size while
4059     // according to the docs EVT_SIZE handler is supposed to receive the total
4060     // size
4061     wxSizeEvent event(GetSize(), m_windowId);
4062     event.SetEventObject(this);
4063
4064     return GetEventHandler()->ProcessEvent(event);
4065 }
4066
4067 bool wxWindowMSW::HandleSizing(wxRect& rect)
4068 {
4069     wxSizeEvent event(rect, m_windowId);
4070     event.SetEventObject(this);
4071
4072     bool rc = GetEventHandler()->ProcessEvent(event);
4073     if (rc)
4074         rect = event.GetRect();
4075     return rc;
4076 }
4077
4078 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
4079 {
4080 #ifdef __WXWINCE__
4081     return FALSE;
4082 #else
4083     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
4084
4085     bool rc = FALSE;
4086
4087     int minWidth = GetMinWidth(),
4088         minHeight = GetMinHeight(),
4089         maxWidth = GetMaxWidth(),
4090         maxHeight = GetMaxHeight();
4091
4092     if ( minWidth != -1 )
4093     {
4094         info->ptMinTrackSize.x = minWidth;
4095         rc = TRUE;
4096     }
4097
4098     if ( minHeight != -1 )
4099     {
4100         info->ptMinTrackSize.y = minHeight;
4101         rc = TRUE;
4102     }
4103
4104     if ( maxWidth != -1 )
4105     {
4106         info->ptMaxTrackSize.x = maxWidth;
4107         rc = TRUE;
4108     }
4109
4110     if ( maxHeight != -1 )
4111     {
4112         info->ptMaxTrackSize.y = maxHeight;
4113         rc = TRUE;
4114     }
4115
4116     return rc;
4117 #endif
4118 }
4119
4120 // ---------------------------------------------------------------------------
4121 // command messages
4122 // ---------------------------------------------------------------------------
4123
4124 bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
4125 {
4126 #if wxUSE_MENUS_NATIVE
4127     if ( !cmd && wxCurrentPopupMenu )
4128     {
4129         wxMenu *popupMenu = wxCurrentPopupMenu;
4130         wxCurrentPopupMenu = NULL;
4131
4132         return popupMenu->MSWCommand(cmd, id);
4133     }
4134 #endif // wxUSE_MENUS_NATIVE
4135
4136     wxWindow *win = NULL;
4137
4138     // first try to find it from HWND - this works even with the broken
4139     // programs using the same ids for different controls
4140     if ( control )
4141     {
4142         win = wxFindWinFromHandle(control);
4143     }
4144
4145     // try the id
4146     if ( !win )
4147     {
4148         // must cast to a signed type before comparing with other ids!
4149         win = FindItem((signed short)id);
4150     }
4151
4152     if ( win )
4153     {
4154         return win->MSWCommand(cmd, id);
4155     }
4156
4157     // the messages sent from the in-place edit control used by the treectrl
4158     // for label editing have id == 0, but they should _not_ be treated as menu
4159     // messages (they are EN_XXX ones, in fact) so don't translate anything
4160     // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4161     if ( !control )
4162     {
4163         // If no child window, it may be an accelerator, e.g. for a popup menu
4164         // command
4165
4166         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
4167         event.SetEventObject(this);
4168         event.SetId(id);
4169         event.SetInt(id);
4170
4171         return GetEventHandler()->ProcessEvent(event);
4172     }
4173 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4174     else
4175     {
4176         // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4177         // notifications to its parent which we want to reflect back to
4178         // wxSpinCtrl
4179         wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
4180         if ( spin && spin->ProcessTextCommand(cmd, id) )
4181             return TRUE;
4182     }
4183 #endif // wxUSE_SPINCTRL
4184
4185     return FALSE;
4186 }
4187
4188 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
4189 {
4190 #ifndef __WXWINCE__
4191     // 4 bits are reserved
4192     switch ( wParam & 0xFFFFFFF0 )
4193     {
4194         case SC_MAXIMIZE:
4195             return HandleMaximize();
4196
4197         case SC_MINIMIZE:
4198             return HandleMinimize();
4199     }
4200 #endif
4201
4202     return FALSE;
4203 }
4204
4205 // ---------------------------------------------------------------------------
4206 // mouse events
4207 // ---------------------------------------------------------------------------
4208
4209 void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
4210                                  int x, int y,
4211                                  WXUINT flags)
4212 {
4213     // our client coords are not quite the same as Windows ones
4214     wxPoint pt = GetClientAreaOrigin();
4215     event.m_x = x - pt.x;
4216     event.m_y = y - pt.y;
4217
4218     event.m_shiftDown = (flags & MK_SHIFT) != 0;
4219     event.m_controlDown = (flags & MK_CONTROL) != 0;
4220     event.m_leftDown = (flags & MK_LBUTTON) != 0;
4221     event.m_middleDown = (flags & MK_MBUTTON) != 0;
4222     event.m_rightDown = (flags & MK_RBUTTON) != 0;
4223  //   event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4224     // Returns different negative values on WinME and WinNT,
4225     // so simply test for negative value.
4226     event.m_altDown = ::GetKeyState(VK_MENU) < 0;
4227
4228 #ifndef __WXWINCE__
4229     event.SetTimestamp(::GetMessageTime());
4230 #endif
4231
4232     event.m_eventObject = this;
4233     event.SetId(GetId());
4234
4235 #if wxUSE_MOUSEEVENT_HACK
4236     m_lastMouseX = x;
4237     m_lastMouseY = y;
4238     m_lastMouseEvent = event.GetEventType();
4239 #endif // wxUSE_MOUSEEVENT_HACK
4240 }
4241
4242 // Windows doesn't send the mouse events to the static controls (which are
4243 // transparent in the sense that their WM_NCHITTEST handler returns
4244 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4245 // and so we manually check if we don't have a child window under mouse and if
4246 // we do, send the event to it instead of the window Windows had sent WM_XXX
4247 // to.
4248 //
4249 // Notice that this is not done for the mouse move events because this could
4250 // (would?) be too slow, but only for clicks which means that the static texts
4251 // still don't get move, enter nor leave events.
4252 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //TW:REQ:Univ
4253 {
4254     wxCHECK_MSG( x && y, win, _T("NULL pointer in FindWindowForMouseEvent") );
4255
4256     // first try to find a non transparent child: this allows us to send events
4257     // to a static text which is inside a static box, for example
4258     POINT pt = { *x, *y };
4259     HWND hwnd = GetHwndOf(win),
4260          hwndUnderMouse;
4261
4262 #ifdef __WXWINCE__
4263     hwndUnderMouse = ::ChildWindowFromPoint
4264                        (
4265                         hwnd,
4266                         pt
4267                        );
4268 #else
4269     hwndUnderMouse = ::ChildWindowFromPointEx
4270                        (
4271                         hwnd,
4272                         pt,
4273                         CWP_SKIPINVISIBLE   |
4274                         CWP_SKIPDISABLED    |
4275                         CWP_SKIPTRANSPARENT
4276                        );
4277 #endif
4278
4279     if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
4280     {
4281         // now try any child window at all
4282         hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
4283     }
4284
4285     // check that we have a child window which is susceptible to receive mouse
4286     // events: for this it must be shown and enabled
4287     if ( hwndUnderMouse &&
4288             hwndUnderMouse != hwnd &&
4289                 ::IsWindowVisible(hwndUnderMouse) &&
4290                     ::IsWindowEnabled(hwndUnderMouse) )
4291     {
4292         wxWindow *winUnderMouse = wxFindWinFromHandle((WXHWND)hwndUnderMouse);
4293         if ( winUnderMouse )
4294         {
4295             // translate the mouse coords to the other window coords
4296             win->ClientToScreen(x, y);
4297             winUnderMouse->ScreenToClient(x, y);
4298
4299             win = winUnderMouse;
4300         }
4301     }
4302
4303     return win;
4304 }
4305
4306 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
4307 {
4308     // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4309     // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4310     // from the message id and take the value in the table to get wxWin event
4311     // id
4312     static const wxEventType eventsMouse[] =
4313     {
4314         wxEVT_MOTION,
4315         wxEVT_LEFT_DOWN,
4316         wxEVT_LEFT_UP,
4317         wxEVT_LEFT_DCLICK,
4318         wxEVT_RIGHT_DOWN,
4319         wxEVT_RIGHT_UP,
4320         wxEVT_RIGHT_DCLICK,
4321         wxEVT_MIDDLE_DOWN,
4322         wxEVT_MIDDLE_UP,
4323         wxEVT_MIDDLE_DCLICK
4324     };
4325
4326     wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
4327     InitMouseEvent(event, x, y, flags);
4328
4329     return GetEventHandler()->ProcessEvent(event);
4330 }
4331
4332 bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
4333 {
4334     if ( !m_mouseInWindow )
4335     {
4336         // it would be wrong to assume that just because we get a mouse move
4337         // event that the mouse is inside the window: although this is usually
4338         // true, it is not if we had captured the mouse, so we need to check
4339         // the mouse coordinates here
4340         if ( !HasCapture() || IsMouseInWindow() )
4341         {
4342             // Generate an ENTER event
4343             m_mouseInWindow = TRUE;
4344
4345             wxMouseEvent event(wxEVT_ENTER_WINDOW);
4346             InitMouseEvent(event, x, y, flags);
4347
4348             (void)GetEventHandler()->ProcessEvent(event);
4349         }
4350     }
4351
4352 #if wxUSE_MOUSEEVENT_HACK
4353     // Window gets a click down message followed by a mouse move message even
4354     // if position isn't changed!  We want to discard the trailing move event
4355     // if x and y are the same.
4356     if ( (m_lastMouseEvent == wxEVT_RIGHT_DOWN ||
4357           m_lastMouseEvent == wxEVT_LEFT_DOWN ||
4358           m_lastMouseEvent == wxEVT_MIDDLE_DOWN) &&
4359          (m_lastMouseX == x && m_lastMouseY == y) )
4360     {
4361         m_lastMouseEvent = wxEVT_MOTION;
4362
4363         return FALSE;
4364     }
4365 #endif // wxUSE_MOUSEEVENT_HACK
4366
4367     return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
4368 }
4369
4370
4371 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
4372 {
4373 #if wxUSE_MOUSEWHEEL
4374     wxMouseEvent event(wxEVT_MOUSEWHEEL);
4375     InitMouseEvent(event,
4376                    GET_X_LPARAM(lParam),
4377                    GET_Y_LPARAM(lParam),
4378                    LOWORD(wParam));
4379     event.m_wheelRotation = (short)HIWORD(wParam);
4380     event.m_wheelDelta = WHEEL_DELTA;
4381
4382     static int s_linesPerRotation = -1;
4383     if ( s_linesPerRotation == -1 )
4384     {
4385         if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
4386                                      &s_linesPerRotation, 0))
4387         {
4388             // this is not supposed to happen
4389             wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4390
4391             // the default is 3, so use it if SystemParametersInfo() failed
4392             s_linesPerRotation = 3;
4393         }
4394     }
4395
4396     event.m_linesPerAction = s_linesPerRotation;
4397     return GetEventHandler()->ProcessEvent(event);
4398
4399 #else
4400     (void) wParam;
4401     (void) lParam;
4402
4403     return FALSE;
4404 #endif
4405 }
4406
4407
4408 // ---------------------------------------------------------------------------
4409 // keyboard handling
4410 // ---------------------------------------------------------------------------
4411
4412 // create the key event of the given type for the given key - used by
4413 // HandleChar and HandleKeyDown/Up
4414 wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
4415                                        int id,
4416                                        WXLPARAM lParam,
4417                                        WXWPARAM wParam) const
4418 {
4419     wxKeyEvent event(evType);
4420     event.SetId(GetId());
4421     event.m_shiftDown = wxIsShiftDown();
4422     event.m_controlDown = wxIsCtrlDown();
4423     event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
4424
4425     event.m_eventObject = (wxWindow *)this; // const_cast
4426     event.m_keyCode = id;
4427     event.m_rawCode = (wxUint32) wParam;
4428     event.m_rawFlags = (wxUint32) lParam;
4429 #ifndef __WXWINCE__
4430     event.SetTimestamp(::GetMessageTime());
4431 #endif
4432
4433     // translate the position to client coords
4434     POINT pt;
4435     GetCursorPos(&pt);
4436     RECT rect;
4437     GetWindowRect(GetHwnd(),&rect);
4438     pt.x -= rect.left;
4439     pt.y -= rect.top;
4440
4441     event.m_x = pt.x;
4442     event.m_y = pt.y;
4443
4444     return event;
4445 }
4446
4447 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4448 // WM_KEYDOWN one
4449 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
4450 {
4451     int id;
4452     if ( isASCII )
4453     {
4454         // If 1 -> 26, translate to either special keycode or just set
4455         // ctrlDown.  IOW, Ctrl-C should result in keycode == 3 and
4456         // ControlDown() == TRUE.
4457         id = wParam;
4458         if ( (id > 0) && (id < 27) )
4459         {
4460             switch (id)
4461             {
4462                 case 13:
4463                     id = WXK_RETURN;
4464                     break;
4465
4466                 case 8:
4467                     id = WXK_BACK;
4468                     break;
4469
4470                 case 9:
4471                     id = WXK_TAB;
4472                     break;
4473
4474                 default:
4475                     //ctrlDown = TRUE;
4476                     break;
4477             }
4478         }
4479     }
4480     else // we're called from WM_KEYDOWN
4481     {
4482         id = wxCharCodeMSWToWX(wParam);
4483         if ( id == 0 )
4484         {
4485             // it's ASCII and will be processed here only when called from
4486             // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4487             return FALSE;
4488         }
4489     }
4490
4491     wxKeyEvent event(CreateKeyEvent(wxEVT_CHAR, id, lParam, wParam));
4492
4493     // the alphanumeric keys produced by pressing AltGr+something on European
4494     // keyboards have both Ctrl and Alt modifiers which may confuse the user
4495     // code as, normally, keys with Ctrl and/or Alt don't result in anything
4496     // alphanumeric, so pretend that there are no modifiers at all (the
4497     // KEY_DOWN event would still have the correct modifiers if they're really
4498     // needed)
4499     if ( event.m_controlDown && event.m_altDown &&
4500             (id >= 32 && id < 256) )
4501     {
4502         event.m_controlDown =
4503         event.m_altDown = FALSE;
4504     }
4505
4506     return GetEventHandler()->ProcessEvent(event);
4507 }
4508
4509 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
4510 {
4511     int id = wxCharCodeMSWToWX(wParam);
4512
4513     if ( !id )
4514     {
4515         // normal ASCII char
4516         id = wParam;
4517     }
4518
4519     if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4520     {
4521         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
4522         if ( GetEventHandler()->ProcessEvent(event) )
4523         {
4524             return TRUE;
4525         }
4526     }
4527
4528     return FALSE;
4529 }
4530
4531 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
4532 {
4533     int id = wxCharCodeMSWToWX(wParam);
4534
4535     if ( !id )
4536     {
4537         // normal ASCII char
4538         id = wParam;
4539     }
4540
4541     if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4542     {
4543         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
4544         if ( GetEventHandler()->ProcessEvent(event) )
4545             return TRUE;
4546     }
4547
4548     return FALSE;
4549 }
4550
4551 int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
4552 {
4553     // FIXME: implement GetMenuItemCount for WinCE, possibly
4554     // in terms of GetMenuItemInfo
4555 #ifndef __WXWINCE__
4556     const HMENU hmenu = (HMENU)lParam;
4557
4558     MENUITEMINFO mii;
4559     wxZeroMemory(mii);
4560     mii.cbSize = sizeof(MENUITEMINFO);
4561     mii.fMask = MIIM_TYPE | MIIM_DATA;
4562
4563     // find if we have this letter in any owner drawn item
4564     const int count = ::GetMenuItemCount(hmenu);
4565     for ( int i = 0; i < count; i++ )
4566     {
4567         if ( ::GetMenuItemInfo(hmenu, i, TRUE, &mii) )
4568         {
4569             if ( mii.fType == MFT_OWNERDRAW )
4570             {
4571                 //  dwItemData member of the MENUITEMINFO is a
4572                 //  pointer to the associated wxMenuItem -- see the
4573                 //  menu creation code
4574                 wxMenuItem *item = (wxMenuItem*)mii.dwItemData;
4575
4576                 const wxChar *p = wxStrchr(item->GetText(), _T('&'));
4577                 while ( p++ )
4578                 {
4579                     if ( *p == _T('&') )
4580                     {
4581                         // this is not the accel char, find the real one
4582                         p = wxStrchr(p + 1, _T('&'));
4583                     }
4584                     else // got the accel char
4585                     {
4586                         // FIXME-UNICODE: this comparison doesn't risk to work
4587                         // for non ASCII accelerator characters I'm afraid, but
4588                         // what can we do?
4589                         if ( wxToupper(*p) == chAccel )
4590                         {
4591                             return i;
4592                         }
4593                         else
4594                         {
4595                             // this one doesn't match
4596                             break;
4597                         }
4598                     }
4599                 }
4600             }
4601         }
4602         else // failed to get the menu text?
4603         {
4604             // it's not fatal, so don't show error, but still log
4605             // it
4606             wxLogLastError(_T("GetMenuItemInfo"));
4607         }
4608     }
4609 #endif
4610     return wxNOT_FOUND;
4611 }
4612
4613 // ---------------------------------------------------------------------------
4614 // joystick
4615 // ---------------------------------------------------------------------------
4616
4617 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
4618 {
4619 #ifdef JOY_BUTTON1
4620     int change = 0;
4621     if ( flags & JOY_BUTTON1CHG )
4622         change = wxJOY_BUTTON1;
4623     if ( flags & JOY_BUTTON2CHG )
4624         change = wxJOY_BUTTON2;
4625     if ( flags & JOY_BUTTON3CHG )
4626         change = wxJOY_BUTTON3;
4627     if ( flags & JOY_BUTTON4CHG )
4628         change = wxJOY_BUTTON4;
4629
4630     int buttons = 0;
4631     if ( flags & JOY_BUTTON1 )
4632         buttons |= wxJOY_BUTTON1;
4633     if ( flags & JOY_BUTTON2 )
4634         buttons |= wxJOY_BUTTON2;
4635     if ( flags & JOY_BUTTON3 )
4636         buttons |= wxJOY_BUTTON3;
4637     if ( flags & JOY_BUTTON4 )
4638         buttons |= wxJOY_BUTTON4;
4639
4640     // the event ids aren't consecutive so we can't use table based lookup
4641     int joystick;
4642     wxEventType eventType;
4643     switch ( msg )
4644     {
4645         case MM_JOY1MOVE:
4646             joystick = 1;
4647             eventType = wxEVT_JOY_MOVE;
4648             break;
4649
4650         case MM_JOY2MOVE:
4651             joystick = 2;
4652             eventType = wxEVT_JOY_MOVE;
4653             break;
4654
4655         case MM_JOY1ZMOVE:
4656             joystick = 1;
4657             eventType = wxEVT_JOY_ZMOVE;
4658             break;
4659
4660         case MM_JOY2ZMOVE:
4661             joystick = 2;
4662             eventType = wxEVT_JOY_ZMOVE;
4663             break;
4664
4665         case MM_JOY1BUTTONDOWN:
4666             joystick = 1;
4667             eventType = wxEVT_JOY_BUTTON_DOWN;
4668             break;
4669
4670         case MM_JOY2BUTTONDOWN:
4671             joystick = 2;
4672             eventType = wxEVT_JOY_BUTTON_DOWN;
4673             break;
4674
4675         case MM_JOY1BUTTONUP:
4676             joystick = 1;
4677             eventType = wxEVT_JOY_BUTTON_UP;
4678             break;
4679
4680         case MM_JOY2BUTTONUP:
4681             joystick = 2;
4682             eventType = wxEVT_JOY_BUTTON_UP;
4683             break;
4684
4685         default:
4686             wxFAIL_MSG(wxT("no such joystick event"));
4687
4688             return FALSE;
4689     }
4690
4691     wxJoystickEvent event(eventType, buttons, joystick, change);
4692     event.SetPosition(wxPoint(x, y));
4693     event.SetEventObject(this);
4694
4695     return GetEventHandler()->ProcessEvent(event);
4696 #else
4697     return FALSE;
4698 #endif
4699 }
4700
4701 // ---------------------------------------------------------------------------
4702 // scrolling
4703 // ---------------------------------------------------------------------------
4704
4705 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
4706                               WXWORD pos, WXHWND control)
4707 {
4708     if ( control )
4709     {
4710         wxWindow *child = wxFindWinFromHandle(control);
4711         if ( child )
4712             return child->MSWOnScroll(orientation, wParam, pos, control);
4713     }
4714
4715     wxScrollWinEvent event;
4716     event.SetPosition(pos);
4717     event.SetOrientation(orientation);
4718     event.m_eventObject = this;
4719
4720     switch ( wParam )
4721     {
4722     case SB_TOP:
4723         event.m_eventType = wxEVT_SCROLLWIN_TOP;
4724         break;
4725
4726     case SB_BOTTOM:
4727         event.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
4728         break;
4729
4730     case SB_LINEUP:
4731         event.m_eventType = wxEVT_SCROLLWIN_LINEUP;
4732         break;
4733
4734     case SB_LINEDOWN:
4735         event.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
4736         break;
4737
4738     case SB_PAGEUP:
4739         event.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
4740         break;
4741
4742     case SB_PAGEDOWN:
4743         event.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
4744         break;
4745
4746     case SB_THUMBPOSITION:
4747     case SB_THUMBTRACK:
4748         // under Win32, the scrollbar range and position are 32 bit integers,
4749         // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4750         // explicitly query the scrollbar for the correct position (this must
4751         // be done only for these two SB_ events as they are the only one
4752         // carrying the scrollbar position)
4753         {
4754             WinStruct<SCROLLINFO> scrollInfo;
4755             scrollInfo.fMask = SIF_TRACKPOS;
4756
4757             if ( !::GetScrollInfo(GetHwnd(),
4758                                   orientation == wxHORIZONTAL ? SB_HORZ
4759                                                               : SB_VERT,
4760                                   &scrollInfo) )
4761             {
4762                 // Not neccessarily an error, if there are no scrollbars yet.
4763                 // wxLogLastError(_T("GetScrollInfo"));
4764             }
4765
4766             event.SetPosition(scrollInfo.nTrackPos);
4767         }
4768
4769         event.m_eventType = wParam == SB_THUMBPOSITION
4770                                 ? wxEVT_SCROLLWIN_THUMBRELEASE
4771                                 : wxEVT_SCROLLWIN_THUMBTRACK;
4772         break;
4773
4774     default:
4775         return FALSE;
4776     }
4777
4778     return GetEventHandler()->ProcessEvent(event);
4779 }
4780
4781 // ===========================================================================
4782 // global functions
4783 // ===========================================================================
4784
4785 void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
4786 {
4787     TEXTMETRIC tm;
4788     HDC dc = ::GetDC((HWND) wnd);
4789     HFONT fnt =0;
4790     HFONT was = 0;
4791     if ( the_font )
4792     {
4793         //    the_font->UseResource();
4794         //    the_font->RealizeResource();
4795         fnt = (HFONT)((wxFont *)the_font)->GetResourceHandle(); // const_cast
4796         if ( fnt )
4797             was = (HFONT) SelectObject(dc,fnt);
4798     }
4799     GetTextMetrics(dc, &tm);
4800     if ( the_font && fnt && was )
4801     {
4802         SelectObject(dc,was);
4803     }
4804     ReleaseDC((HWND)wnd, dc);
4805
4806     if ( x )
4807         *x = tm.tmAveCharWidth;
4808     if ( y )
4809         *y = tm.tmHeight + tm.tmExternalLeading;
4810
4811     //  if ( the_font )
4812     //    the_font->ReleaseResource();
4813 }
4814
4815 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4816 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4817 int wxCharCodeMSWToWX(int keySym)
4818 {
4819     int id;
4820     switch (keySym)
4821     {
4822         case VK_CANCEL:     id = WXK_CANCEL; break;
4823         case VK_BACK:       id = WXK_BACK; break;
4824         case VK_TAB:        id = WXK_TAB; break;
4825         case VK_CLEAR:      id = WXK_CLEAR; break;
4826         case VK_RETURN:     id = WXK_RETURN; break;
4827         case VK_SHIFT:      id = WXK_SHIFT; break;
4828         case VK_CONTROL:    id = WXK_CONTROL; break;
4829         case VK_MENU :      id = WXK_MENU; break;
4830         case VK_PAUSE:      id = WXK_PAUSE; break;
4831         case VK_CAPITAL:    id = WXK_CAPITAL; break;
4832         case VK_SPACE:      id = WXK_SPACE; break;
4833         case VK_ESCAPE:     id = WXK_ESCAPE; break;
4834         case VK_PRIOR:      id = WXK_PRIOR; break;
4835         case VK_NEXT :      id = WXK_NEXT; break;
4836         case VK_END:        id = WXK_END; break;
4837         case VK_HOME :      id = WXK_HOME; break;
4838         case VK_LEFT :      id = WXK_LEFT; break;
4839         case VK_UP:         id = WXK_UP; break;
4840         case VK_RIGHT:      id = WXK_RIGHT; break;
4841         case VK_DOWN :      id = WXK_DOWN; break;
4842         case VK_SELECT:     id = WXK_SELECT; break;
4843         case VK_PRINT:      id = WXK_PRINT; break;
4844         case VK_EXECUTE:    id = WXK_EXECUTE; break;
4845         case VK_INSERT:     id = WXK_INSERT; break;
4846         case VK_DELETE:     id = WXK_DELETE; break;
4847         case VK_HELP :      id = WXK_HELP; break;
4848         case VK_NUMPAD0:    id = WXK_NUMPAD0; break;
4849         case VK_NUMPAD1:    id = WXK_NUMPAD1; break;
4850         case VK_NUMPAD2:    id = WXK_NUMPAD2; break;
4851         case VK_NUMPAD3:    id = WXK_NUMPAD3; break;
4852         case VK_NUMPAD4:    id = WXK_NUMPAD4; break;
4853         case VK_NUMPAD5:    id = WXK_NUMPAD5; break;
4854         case VK_NUMPAD6:    id = WXK_NUMPAD6; break;
4855         case VK_NUMPAD7:    id = WXK_NUMPAD7; break;
4856         case VK_NUMPAD8:    id = WXK_NUMPAD8; break;
4857         case VK_NUMPAD9:    id = WXK_NUMPAD9; break;
4858         case VK_MULTIPLY:   id = WXK_NUMPAD_MULTIPLY; break;
4859         case VK_ADD:        id = WXK_NUMPAD_ADD; break;
4860         case VK_SUBTRACT:   id = WXK_NUMPAD_SUBTRACT; break;
4861         case VK_DECIMAL:    id = WXK_NUMPAD_DECIMAL; break;
4862         case VK_DIVIDE:     id = WXK_NUMPAD_DIVIDE; break;
4863         case VK_F1:         id = WXK_F1; break;
4864         case VK_F2:         id = WXK_F2; break;
4865         case VK_F3:         id = WXK_F3; break;
4866         case VK_F4:         id = WXK_F4; break;
4867         case VK_F5:         id = WXK_F5; break;
4868         case VK_F6:         id = WXK_F6; break;
4869         case VK_F7:         id = WXK_F7; break;
4870         case VK_F8:         id = WXK_F8; break;
4871         case VK_F9:         id = WXK_F9; break;
4872         case VK_F10:        id = WXK_F10; break;
4873         case VK_F11:        id = WXK_F11; break;
4874         case VK_F12:        id = WXK_F12; break;
4875         case VK_F13:        id = WXK_F13; break;
4876         case VK_F14:        id = WXK_F14; break;
4877         case VK_F15:        id = WXK_F15; break;
4878         case VK_F16:        id = WXK_F16; break;
4879         case VK_F17:        id = WXK_F17; break;
4880         case VK_F18:        id = WXK_F18; break;
4881         case VK_F19:        id = WXK_F19; break;
4882         case VK_F20:        id = WXK_F20; break;
4883         case VK_F21:        id = WXK_F21; break;
4884         case VK_F22:        id = WXK_F22; break;
4885         case VK_F23:        id = WXK_F23; break;
4886         case VK_F24:        id = WXK_F24; break;
4887         case VK_NUMLOCK:    id = WXK_NUMLOCK; break;
4888         case VK_SCROLL:     id = WXK_SCROLL; break;
4889
4890         case VK_OEM_1:      id = ';'; break;
4891         case VK_OEM_PLUS:   id = '+'; break;
4892         case VK_OEM_COMMA:  id = ','; break;
4893         case VK_OEM_MINUS:  id = '-'; break;
4894         case VK_OEM_PERIOD: id = '.'; break;
4895         case VK_OEM_2:      id = '/'; break;
4896         case VK_OEM_3:      id = '~'; break;
4897         case VK_OEM_4:      id = '['; break;
4898         case VK_OEM_5:      id = '\\'; break;
4899         case VK_OEM_6:      id = ']'; break;
4900         case VK_OEM_7:      id = '\''; break;
4901
4902 #ifdef VK_APPS
4903         case VK_LWIN:       id = WXK_WINDOWS_LEFT; break;
4904         case VK_RWIN:       id = WXK_WINDOWS_RIGHT; break;
4905         case VK_APPS:       id = WXK_WINDOWS_MENU; break;
4906 #endif // VK_APPS defined
4907
4908         default:
4909             id = 0;
4910     }
4911
4912     return id;
4913 }
4914
4915 int wxCharCodeWXToMSW(int id, bool *isVirtual)
4916 {
4917     *isVirtual = TRUE;
4918     int keySym;
4919     switch (id)
4920     {
4921     case WXK_CANCEL:    keySym = VK_CANCEL; break;
4922     case WXK_CLEAR:     keySym = VK_CLEAR; break;
4923     case WXK_SHIFT:     keySym = VK_SHIFT; break;
4924     case WXK_CONTROL:   keySym = VK_CONTROL; break;
4925     case WXK_MENU :     keySym = VK_MENU; break;
4926     case WXK_PAUSE:     keySym = VK_PAUSE; break;
4927     case WXK_PRIOR:     keySym = VK_PRIOR; break;
4928     case WXK_NEXT :     keySym = VK_NEXT; break;
4929     case WXK_END:       keySym = VK_END; break;
4930     case WXK_HOME :     keySym = VK_HOME; break;
4931     case WXK_LEFT :     keySym = VK_LEFT; break;
4932     case WXK_UP:        keySym = VK_UP; break;
4933     case WXK_RIGHT:     keySym = VK_RIGHT; break;
4934     case WXK_DOWN :     keySym = VK_DOWN; break;
4935     case WXK_SELECT:    keySym = VK_SELECT; break;
4936     case WXK_PRINT:     keySym = VK_PRINT; break;
4937     case WXK_EXECUTE:   keySym = VK_EXECUTE; break;
4938     case WXK_INSERT:    keySym = VK_INSERT; break;
4939     case WXK_DELETE:    keySym = VK_DELETE; break;
4940     case WXK_HELP :     keySym = VK_HELP; break;
4941     case WXK_NUMPAD0:   keySym = VK_NUMPAD0; break;
4942     case WXK_NUMPAD1:   keySym = VK_NUMPAD1; break;
4943     case WXK_NUMPAD2:   keySym = VK_NUMPAD2; break;
4944     case WXK_NUMPAD3:   keySym = VK_NUMPAD3; break;
4945     case WXK_NUMPAD4:   keySym = VK_NUMPAD4; break;
4946     case WXK_NUMPAD5:   keySym = VK_NUMPAD5; break;
4947     case WXK_NUMPAD6:   keySym = VK_NUMPAD6; break;
4948     case WXK_NUMPAD7:   keySym = VK_NUMPAD7; break;
4949     case WXK_NUMPAD8:   keySym = VK_NUMPAD8; break;
4950     case WXK_NUMPAD9:   keySym = VK_NUMPAD9; break;
4951     case WXK_NUMPAD_MULTIPLY:  keySym = VK_MULTIPLY; break;
4952     case WXK_NUMPAD_ADD:       keySym = VK_ADD; break;
4953     case WXK_NUMPAD_SUBTRACT:  keySym = VK_SUBTRACT; break;
4954     case WXK_NUMPAD_DECIMAL:   keySym = VK_DECIMAL; break;
4955     case WXK_NUMPAD_DIVIDE:    keySym = VK_DIVIDE; break;
4956     case WXK_F1:        keySym = VK_F1; break;
4957     case WXK_F2:        keySym = VK_F2; break;
4958     case WXK_F3:        keySym = VK_F3; break;
4959     case WXK_F4:        keySym = VK_F4; break;
4960     case WXK_F5:        keySym = VK_F5; break;
4961     case WXK_F6:        keySym = VK_F6; break;
4962     case WXK_F7:        keySym = VK_F7; break;
4963     case WXK_F8:        keySym = VK_F8; break;
4964     case WXK_F9:        keySym = VK_F9; break;
4965     case WXK_F10:       keySym = VK_F10; break;
4966     case WXK_F11:       keySym = VK_F11; break;
4967     case WXK_F12:       keySym = VK_F12; break;
4968     case WXK_F13:       keySym = VK_F13; break;
4969     case WXK_F14:       keySym = VK_F14; break;
4970     case WXK_F15:       keySym = VK_F15; break;
4971     case WXK_F16:       keySym = VK_F16; break;
4972     case WXK_F17:       keySym = VK_F17; break;
4973     case WXK_F18:       keySym = VK_F18; break;
4974     case WXK_F19:       keySym = VK_F19; break;
4975     case WXK_F20:       keySym = VK_F20; break;
4976     case WXK_F21:       keySym = VK_F21; break;
4977     case WXK_F22:       keySym = VK_F22; break;
4978     case WXK_F23:       keySym = VK_F23; break;
4979     case WXK_F24:       keySym = VK_F24; break;
4980     case WXK_NUMLOCK:   keySym = VK_NUMLOCK; break;
4981     case WXK_SCROLL:    keySym = VK_SCROLL; break;
4982     default:
4983         {
4984             *isVirtual = FALSE;
4985             keySym = id;
4986             break;
4987         }
4988     }
4989     return keySym;
4990 }
4991
4992 wxWindow *wxGetActiveWindow()
4993 {
4994     HWND hWnd = GetActiveWindow();
4995     if ( hWnd != 0 )
4996     {
4997         return wxFindWinFromHandle((WXHWND) hWnd);
4998     }
4999     return NULL;
5000 }
5001
5002 extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
5003 {
5004     HWND hwnd = (HWND)hWnd;
5005
5006     // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5007     // by code in msw/radiobox.cpp), for all the others we just search up the
5008     // window hierarchy
5009     wxWindow *win = (wxWindow *)NULL;
5010     if ( hwnd )
5011     {
5012         win = wxFindWinFromHandle((WXHWND)hwnd);
5013         if ( !win )
5014         {
5015 #if wxUSE_RADIOBOX
5016             // native radiobuttons return DLGC_RADIOBUTTON here and for any
5017             // wxWindow class which overrides WM_GETDLGCODE processing to
5018             // do it as well, win would be already non NULL
5019             if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
5020             {
5021                 win = (wxWindow *)::GetWindowLong(hwnd, GWL_USERDATA);
5022             }
5023             //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5024 #endif // wxUSE_RADIOBOX
5025
5026             // spin control text buddy window should be mapped to spin ctrl
5027             // itself so try it too
5028 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5029             if ( !win )
5030             {
5031                 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
5032             }
5033 #endif // wxUSE_SPINCTRL
5034         }
5035     }
5036
5037     while ( hwnd && !win )
5038     {
5039         // this is a really ugly hack needed to avoid mistakenly returning the
5040         // parent frame wxWindow for the find/replace modeless dialog HWND -
5041         // this, in turn, is needed to call IsDialogMessage() from
5042         // wxApp::ProcessMessage() as for this we must return NULL from here
5043         //
5044         // FIXME: this is clearly not the best way to do it but I think we'll
5045         //        need to change HWND <-> wxWindow code more heavily than I can
5046         //        do it now to fix it
5047 #ifndef __WXMICROWIN__
5048         if ( ::GetWindow(hwnd, GW_OWNER) )
5049         {
5050             // it's a dialog box, don't go upwards
5051             break;
5052         }
5053 #endif
5054
5055         hwnd = ::GetParent(hwnd);
5056         win = wxFindWinFromHandle((WXHWND)hwnd);
5057     }
5058
5059     return win;
5060 }
5061
5062 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5063
5064 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5065 // in active frames and dialogs, regardless of where the focus is.
5066 static HHOOK wxTheKeyboardHook = 0;
5067 static FARPROC wxTheKeyboardHookProc = 0;
5068 int APIENTRY _EXPORT
5069 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
5070
5071 void wxSetKeyboardHook(bool doIt)
5072 {
5073     if ( doIt )
5074     {
5075         wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
5076         wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
5077
5078             GetCurrentThreadId()
5079         //      (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5080             );
5081     }
5082     else
5083     {
5084         UnhookWindowsHookEx(wxTheKeyboardHook);
5085     }
5086 }
5087
5088 int APIENTRY _EXPORT
5089 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
5090 {
5091     DWORD hiWord = HIWORD(lParam);
5092     if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
5093     {
5094         int id = wxCharCodeMSWToWX(wParam);
5095         if ( id != 0 )
5096         {
5097             wxKeyEvent event(wxEVT_CHAR_HOOK);
5098             if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
5099                 event.m_altDown = TRUE;
5100
5101             event.m_eventObject = NULL;
5102             event.m_keyCode = id;
5103             event.m_shiftDown = wxIsShiftDown();
5104             event.m_controlDown = wxIsCtrlDown();
5105 #ifndef __WXWINCE__
5106             event.SetTimestamp(::GetMessageTime());
5107 #endif
5108             wxWindow *win = wxGetActiveWindow();
5109             wxEvtHandler *handler;
5110             if ( win )
5111             {
5112                 handler = win->GetEventHandler();
5113                 event.SetId(win->GetId());
5114             }
5115             else
5116             {
5117                 handler = wxTheApp;
5118                 event.SetId(-1);
5119             }
5120
5121             if ( handler && handler->ProcessEvent(event) )
5122             {
5123                 // processed
5124                 return 1;
5125             }
5126         }
5127     }
5128
5129     return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
5130 }
5131
5132 #endif // !__WXMICROWIN__
5133
5134 #ifdef __WXDEBUG__
5135 const char *wxGetMessageName(int message)
5136 {
5137     switch ( message )
5138     {
5139         case 0x0000: return "WM_NULL";
5140         case 0x0001: return "WM_CREATE";
5141         case 0x0002: return "WM_DESTROY";
5142         case 0x0003: return "WM_MOVE";
5143         case 0x0005: return "WM_SIZE";
5144         case 0x0006: return "WM_ACTIVATE";
5145         case 0x0007: return "WM_SETFOCUS";
5146         case 0x0008: return "WM_KILLFOCUS";
5147         case 0x000A: return "WM_ENABLE";
5148         case 0x000B: return "WM_SETREDRAW";
5149         case 0x000C: return "WM_SETTEXT";
5150         case 0x000D: return "WM_GETTEXT";
5151         case 0x000E: return "WM_GETTEXTLENGTH";
5152         case 0x000F: return "WM_PAINT";
5153         case 0x0010: return "WM_CLOSE";
5154         case 0x0011: return "WM_QUERYENDSESSION";
5155         case 0x0012: return "WM_QUIT";
5156         case 0x0013: return "WM_QUERYOPEN";
5157         case 0x0014: return "WM_ERASEBKGND";
5158         case 0x0015: return "WM_SYSCOLORCHANGE";
5159         case 0x0016: return "WM_ENDSESSION";
5160         case 0x0017: return "WM_SYSTEMERROR";
5161         case 0x0018: return "WM_SHOWWINDOW";
5162         case 0x0019: return "WM_CTLCOLOR";
5163         case 0x001A: return "WM_WININICHANGE";
5164         case 0x001B: return "WM_DEVMODECHANGE";
5165         case 0x001C: return "WM_ACTIVATEAPP";
5166         case 0x001D: return "WM_FONTCHANGE";
5167         case 0x001E: return "WM_TIMECHANGE";
5168         case 0x001F: return "WM_CANCELMODE";
5169         case 0x0020: return "WM_SETCURSOR";
5170         case 0x0021: return "WM_MOUSEACTIVATE";
5171         case 0x0022: return "WM_CHILDACTIVATE";
5172         case 0x0023: return "WM_QUEUESYNC";
5173         case 0x0024: return "WM_GETMINMAXINFO";
5174         case 0x0026: return "WM_PAINTICON";
5175         case 0x0027: return "WM_ICONERASEBKGND";
5176         case 0x0028: return "WM_NEXTDLGCTL";
5177         case 0x002A: return "WM_SPOOLERSTATUS";
5178         case 0x002B: return "WM_DRAWITEM";
5179         case 0x002C: return "WM_MEASUREITEM";
5180         case 0x002D: return "WM_DELETEITEM";
5181         case 0x002E: return "WM_VKEYTOITEM";
5182         case 0x002F: return "WM_CHARTOITEM";
5183         case 0x0030: return "WM_SETFONT";
5184         case 0x0031: return "WM_GETFONT";
5185         case 0x0037: return "WM_QUERYDRAGICON";
5186         case 0x0039: return "WM_COMPAREITEM";
5187         case 0x0041: return "WM_COMPACTING";
5188         case 0x0044: return "WM_COMMNOTIFY";
5189         case 0x0046: return "WM_WINDOWPOSCHANGING";
5190         case 0x0047: return "WM_WINDOWPOSCHANGED";
5191         case 0x0048: return "WM_POWER";
5192
5193         case 0x004A: return "WM_COPYDATA";
5194         case 0x004B: return "WM_CANCELJOURNAL";
5195         case 0x004E: return "WM_NOTIFY";
5196         case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5197         case 0x0051: return "WM_INPUTLANGCHANGE";
5198         case 0x0052: return "WM_TCARD";
5199         case 0x0053: return "WM_HELP";
5200         case 0x0054: return "WM_USERCHANGED";
5201         case 0x0055: return "WM_NOTIFYFORMAT";
5202         case 0x007B: return "WM_CONTEXTMENU";
5203         case 0x007C: return "WM_STYLECHANGING";
5204         case 0x007D: return "WM_STYLECHANGED";
5205         case 0x007E: return "WM_DISPLAYCHANGE";
5206         case 0x007F: return "WM_GETICON";
5207         case 0x0080: return "WM_SETICON";
5208
5209         case 0x0081: return "WM_NCCREATE";
5210         case 0x0082: return "WM_NCDESTROY";
5211         case 0x0083: return "WM_NCCALCSIZE";
5212         case 0x0084: return "WM_NCHITTEST";
5213         case 0x0085: return "WM_NCPAINT";
5214         case 0x0086: return "WM_NCACTIVATE";
5215         case 0x0087: return "WM_GETDLGCODE";
5216         case 0x00A0: return "WM_NCMOUSEMOVE";
5217         case 0x00A1: return "WM_NCLBUTTONDOWN";
5218         case 0x00A2: return "WM_NCLBUTTONUP";
5219         case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5220         case 0x00A4: return "WM_NCRBUTTONDOWN";
5221         case 0x00A5: return "WM_NCRBUTTONUP";
5222         case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5223         case 0x00A7: return "WM_NCMBUTTONDOWN";
5224         case 0x00A8: return "WM_NCMBUTTONUP";
5225         case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5226         case 0x0100: return "WM_KEYDOWN";
5227         case 0x0101: return "WM_KEYUP";
5228         case 0x0102: return "WM_CHAR";
5229         case 0x0103: return "WM_DEADCHAR";
5230         case 0x0104: return "WM_SYSKEYDOWN";
5231         case 0x0105: return "WM_SYSKEYUP";
5232         case 0x0106: return "WM_SYSCHAR";
5233         case 0x0107: return "WM_SYSDEADCHAR";
5234         case 0x0108: return "WM_KEYLAST";
5235
5236         case 0x010D: return "WM_IME_STARTCOMPOSITION";
5237         case 0x010E: return "WM_IME_ENDCOMPOSITION";
5238         case 0x010F: return "WM_IME_COMPOSITION";
5239
5240         case 0x0110: return "WM_INITDIALOG";
5241         case 0x0111: return "WM_COMMAND";
5242         case 0x0112: return "WM_SYSCOMMAND";
5243         case 0x0113: return "WM_TIMER";
5244         case 0x0114: return "WM_HSCROLL";
5245         case 0x0115: return "WM_VSCROLL";
5246         case 0x0116: return "WM_INITMENU";
5247         case 0x0117: return "WM_INITMENUPOPUP";
5248         case 0x011F: return "WM_MENUSELECT";
5249         case 0x0120: return "WM_MENUCHAR";
5250         case 0x0121: return "WM_ENTERIDLE";
5251         case 0x0200: return "WM_MOUSEMOVE";
5252         case 0x0201: return "WM_LBUTTONDOWN";
5253         case 0x0202: return "WM_LBUTTONUP";
5254         case 0x0203: return "WM_LBUTTONDBLCLK";
5255         case 0x0204: return "WM_RBUTTONDOWN";
5256         case 0x0205: return "WM_RBUTTONUP";
5257         case 0x0206: return "WM_RBUTTONDBLCLK";
5258         case 0x0207: return "WM_MBUTTONDOWN";
5259         case 0x0208: return "WM_MBUTTONUP";
5260         case 0x0209: return "WM_MBUTTONDBLCLK";
5261         case 0x020A: return "WM_MOUSEWHEEL";
5262         case 0x0210: return "WM_PARENTNOTIFY";
5263         case 0x0211: return "WM_ENTERMENULOOP";
5264         case 0x0212: return "WM_EXITMENULOOP";
5265
5266         case 0x0213: return "WM_NEXTMENU";
5267         case 0x0214: return "WM_SIZING";
5268         case 0x0215: return "WM_CAPTURECHANGED";
5269         case 0x0216: return "WM_MOVING";
5270         case 0x0218: return "WM_POWERBROADCAST";
5271         case 0x0219: return "WM_DEVICECHANGE";
5272
5273         case 0x0220: return "WM_MDICREATE";
5274         case 0x0221: return "WM_MDIDESTROY";
5275         case 0x0222: return "WM_MDIACTIVATE";
5276         case 0x0223: return "WM_MDIRESTORE";
5277         case 0x0224: return "WM_MDINEXT";
5278         case 0x0225: return "WM_MDIMAXIMIZE";
5279         case 0x0226: return "WM_MDITILE";
5280         case 0x0227: return "WM_MDICASCADE";
5281         case 0x0228: return "WM_MDIICONARRANGE";
5282         case 0x0229: return "WM_MDIGETACTIVE";
5283         case 0x0230: return "WM_MDISETMENU";
5284         case 0x0233: return "WM_DROPFILES";
5285
5286         case 0x0281: return "WM_IME_SETCONTEXT";
5287         case 0x0282: return "WM_IME_NOTIFY";
5288         case 0x0283: return "WM_IME_CONTROL";
5289         case 0x0284: return "WM_IME_COMPOSITIONFULL";
5290         case 0x0285: return "WM_IME_SELECT";
5291         case 0x0286: return "WM_IME_CHAR";
5292         case 0x0290: return "WM_IME_KEYDOWN";
5293         case 0x0291: return "WM_IME_KEYUP";
5294
5295         case 0x0300: return "WM_CUT";
5296         case 0x0301: return "WM_COPY";
5297         case 0x0302: return "WM_PASTE";
5298         case 0x0303: return "WM_CLEAR";
5299         case 0x0304: return "WM_UNDO";
5300         case 0x0305: return "WM_RENDERFORMAT";
5301         case 0x0306: return "WM_RENDERALLFORMATS";
5302         case 0x0307: return "WM_DESTROYCLIPBOARD";
5303         case 0x0308: return "WM_DRAWCLIPBOARD";
5304         case 0x0309: return "WM_PAINTCLIPBOARD";
5305         case 0x030A: return "WM_VSCROLLCLIPBOARD";
5306         case 0x030B: return "WM_SIZECLIPBOARD";
5307         case 0x030C: return "WM_ASKCBFORMATNAME";
5308         case 0x030D: return "WM_CHANGECBCHAIN";
5309         case 0x030E: return "WM_HSCROLLCLIPBOARD";
5310         case 0x030F: return "WM_QUERYNEWPALETTE";
5311         case 0x0310: return "WM_PALETTEISCHANGING";
5312         case 0x0311: return "WM_PALETTECHANGED";
5313 #if wxUSE_HOTKEY
5314         case 0x0312: return "WM_HOTKEY";
5315 #endif
5316
5317         // common controls messages - although they're not strictly speaking
5318         // standard, it's nice to decode them nevertheless
5319
5320         // listview
5321         case 0x1000 + 0: return "LVM_GETBKCOLOR";
5322         case 0x1000 + 1: return "LVM_SETBKCOLOR";
5323         case 0x1000 + 2: return "LVM_GETIMAGELIST";
5324         case 0x1000 + 3: return "LVM_SETIMAGELIST";
5325         case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5326         case 0x1000 + 5: return "LVM_GETITEMA";
5327         case 0x1000 + 75: return "LVM_GETITEMW";
5328         case 0x1000 + 6: return "LVM_SETITEMA";
5329         case 0x1000 + 76: return "LVM_SETITEMW";
5330         case 0x1000 + 7: return "LVM_INSERTITEMA";
5331         case 0x1000 + 77: return "LVM_INSERTITEMW";
5332         case 0x1000 + 8: return "LVM_DELETEITEM";
5333         case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5334         case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5335         case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5336         case 0x1000 + 12: return "LVM_GETNEXTITEM";
5337         case 0x1000 + 13: return "LVM_FINDITEMA";
5338         case 0x1000 + 83: return "LVM_FINDITEMW";
5339         case 0x1000 + 14: return "LVM_GETITEMRECT";
5340         case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5341         case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5342         case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5343         case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5344         case 0x1000 + 18: return "LVM_HITTEST";
5345         case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5346         case 0x1000 + 20: return "LVM_SCROLL";
5347         case 0x1000 + 21: return "LVM_REDRAWITEMS";
5348         case 0x1000 + 22: return "LVM_ARRANGE";
5349         case 0x1000 + 23: return "LVM_EDITLABELA";
5350         case 0x1000 + 118: return "LVM_EDITLABELW";
5351         case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5352         case 0x1000 + 25: return "LVM_GETCOLUMNA";
5353         case 0x1000 + 95: return "LVM_GETCOLUMNW";
5354         case 0x1000 + 26: return "LVM_SETCOLUMNA";
5355         case 0x1000 + 96: return "LVM_SETCOLUMNW";
5356         case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5357         case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5358         case 0x1000 + 28: return "LVM_DELETECOLUMN";
5359         case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5360         case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5361         case 0x1000 + 31: return "LVM_GETHEADER";
5362         case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5363         case 0x1000 + 34: return "LVM_GETVIEWRECT";
5364         case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5365         case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5366         case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5367         case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5368         case 0x1000 + 39: return "LVM_GETTOPINDEX";
5369         case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5370         case 0x1000 + 41: return "LVM_GETORIGIN";
5371         case 0x1000 + 42: return "LVM_UPDATE";
5372         case 0x1000 + 43: return "LVM_SETITEMSTATE";
5373         case 0x1000 + 44: return "LVM_GETITEMSTATE";
5374         case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5375         case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5376         case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5377         case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5378         case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5379         case 0x1000 + 48: return "LVM_SORTITEMS";
5380         case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5381         case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5382         case 0x1000 + 51: return "LVM_GETITEMSPACING";
5383         case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5384         case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5385         case 0x1000 + 53: return "LVM_SETICONSPACING";
5386         case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5387         case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5388         case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5389         case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5390         case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5391         case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5392         case 0x1000 + 60: return "LVM_SETHOTITEM";
5393         case 0x1000 + 61: return "LVM_GETHOTITEM";
5394         case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5395         case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5396         case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5397         case 0x1000 + 65: return "LVM_SETWORKAREA";
5398
5399         // tree view
5400         case 0x1100 + 0: return "TVM_INSERTITEMA";
5401         case 0x1100 + 50: return "TVM_INSERTITEMW";
5402         case 0x1100 + 1: return "TVM_DELETEITEM";
5403         case 0x1100 + 2: return "TVM_EXPAND";
5404         case 0x1100 + 4: return "TVM_GETITEMRECT";
5405         case 0x1100 + 5: return "TVM_GETCOUNT";
5406         case 0x1100 + 6: return "TVM_GETINDENT";
5407         case 0x1100 + 7: return "TVM_SETINDENT";
5408         case 0x1100 + 8: return "TVM_GETIMAGELIST";
5409         case 0x1100 + 9: return "TVM_SETIMAGELIST";
5410         case 0x1100 + 10: return "TVM_GETNEXTITEM";
5411         case 0x1100 + 11: return "TVM_SELECTITEM";
5412         case 0x1100 + 12: return "TVM_GETITEMA";
5413         case 0x1100 + 62: return "TVM_GETITEMW";
5414         case 0x1100 + 13: return "TVM_SETITEMA";
5415         case 0x1100 + 63: return "TVM_SETITEMW";
5416         case 0x1100 + 14: return "TVM_EDITLABELA";
5417         case 0x1100 + 65: return "TVM_EDITLABELW";
5418         case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5419         case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5420         case 0x1100 + 17: return "TVM_HITTEST";
5421         case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5422         case 0x1100 + 19: return "TVM_SORTCHILDREN";
5423         case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5424         case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5425         case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5426         case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5427         case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5428         case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5429         case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5430
5431         // header
5432         case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5433         case 0x1200 + 1: return "HDM_INSERTITEMA";
5434         case 0x1200 + 10: return "HDM_INSERTITEMW";
5435         case 0x1200 + 2: return "HDM_DELETEITEM";
5436         case 0x1200 + 3: return "HDM_GETITEMA";
5437         case 0x1200 + 11: return "HDM_GETITEMW";
5438         case 0x1200 + 4: return "HDM_SETITEMA";
5439         case 0x1200 + 12: return "HDM_SETITEMW";
5440         case 0x1200 + 5: return "HDM_LAYOUT";
5441         case 0x1200 + 6: return "HDM_HITTEST";
5442         case 0x1200 + 7: return "HDM_GETITEMRECT";
5443         case 0x1200 + 8: return "HDM_SETIMAGELIST";
5444         case 0x1200 + 9: return "HDM_GETIMAGELIST";
5445         case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5446         case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5447         case 0x1200 + 17: return "HDM_GETORDERARRAY";
5448         case 0x1200 + 18: return "HDM_SETORDERARRAY";
5449         case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5450
5451         // tab control
5452         case 0x1300 + 2: return "TCM_GETIMAGELIST";
5453         case 0x1300 + 3: return "TCM_SETIMAGELIST";
5454         case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5455         case 0x1300 + 5: return "TCM_GETITEMA";
5456         case 0x1300 + 60: return "TCM_GETITEMW";
5457         case 0x1300 + 6: return "TCM_SETITEMA";
5458         case 0x1300 + 61: return "TCM_SETITEMW";
5459         case 0x1300 + 7: return "TCM_INSERTITEMA";
5460         case 0x1300 + 62: return "TCM_INSERTITEMW";
5461         case 0x1300 + 8: return "TCM_DELETEITEM";
5462         case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5463         case 0x1300 + 10: return "TCM_GETITEMRECT";
5464         case 0x1300 + 11: return "TCM_GETCURSEL";
5465         case 0x1300 + 12: return "TCM_SETCURSEL";
5466         case 0x1300 + 13: return "TCM_HITTEST";
5467         case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5468         case 0x1300 + 40: return "TCM_ADJUSTRECT";
5469         case 0x1300 + 41: return "TCM_SETITEMSIZE";
5470         case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5471         case 0x1300 + 43: return "TCM_SETPADDING";
5472         case 0x1300 + 44: return "TCM_GETROWCOUNT";
5473         case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5474         case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5475         case 0x1300 + 47: return "TCM_GETCURFOCUS";
5476         case 0x1300 + 48: return "TCM_SETCURFOCUS";
5477         case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5478         case 0x1300 + 50: return "TCM_DESELECTALL";
5479
5480         // toolbar
5481         case WM_USER+1: return "TB_ENABLEBUTTON";
5482         case WM_USER+2: return "TB_CHECKBUTTON";
5483         case WM_USER+3: return "TB_PRESSBUTTON";
5484         case WM_USER+4: return "TB_HIDEBUTTON";
5485         case WM_USER+5: return "TB_INDETERMINATE";
5486         case WM_USER+9: return "TB_ISBUTTONENABLED";
5487         case WM_USER+10: return "TB_ISBUTTONCHECKED";
5488         case WM_USER+11: return "TB_ISBUTTONPRESSED";
5489         case WM_USER+12: return "TB_ISBUTTONHIDDEN";
5490         case WM_USER+13: return "TB_ISBUTTONINDETERMINATE";
5491         case WM_USER+17: return "TB_SETSTATE";
5492         case WM_USER+18: return "TB_GETSTATE";
5493         case WM_USER+19: return "TB_ADDBITMAP";
5494         case WM_USER+20: return "TB_ADDBUTTONS";
5495         case WM_USER+21: return "TB_INSERTBUTTON";
5496         case WM_USER+22: return "TB_DELETEBUTTON";
5497         case WM_USER+23: return "TB_GETBUTTON";
5498         case WM_USER+24: return "TB_BUTTONCOUNT";
5499         case WM_USER+25: return "TB_COMMANDTOINDEX";
5500         case WM_USER+26: return "TB_SAVERESTOREA";
5501         case WM_USER+76: return "TB_SAVERESTOREW";
5502         case WM_USER+27: return "TB_CUSTOMIZE";
5503         case WM_USER+28: return "TB_ADDSTRINGA";
5504         case WM_USER+77: return "TB_ADDSTRINGW";
5505         case WM_USER+29: return "TB_GETITEMRECT";
5506         case WM_USER+30: return "TB_BUTTONSTRUCTSIZE";
5507         case WM_USER+31: return "TB_SETBUTTONSIZE";
5508         case WM_USER+32: return "TB_SETBITMAPSIZE";
5509         case WM_USER+33: return "TB_AUTOSIZE";
5510         case WM_USER+35: return "TB_GETTOOLTIPS";
5511         case WM_USER+36: return "TB_SETTOOLTIPS";
5512         case WM_USER+37: return "TB_SETPARENT";
5513         case WM_USER+39: return "TB_SETROWS";
5514         case WM_USER+40: return "TB_GETROWS";
5515         case WM_USER+42: return "TB_SETCMDID";
5516         case WM_USER+43: return "TB_CHANGEBITMAP";
5517         case WM_USER+44: return "TB_GETBITMAP";
5518         case WM_USER+45: return "TB_GETBUTTONTEXTA";
5519         case WM_USER+75: return "TB_GETBUTTONTEXTW";
5520         case WM_USER+46: return "TB_REPLACEBITMAP";
5521         case WM_USER+47: return "TB_SETINDENT";
5522         case WM_USER+48: return "TB_SETIMAGELIST";
5523         case WM_USER+49: return "TB_GETIMAGELIST";
5524         case WM_USER+50: return "TB_LOADIMAGES";
5525         case WM_USER+51: return "TB_GETRECT";
5526         case WM_USER+52: return "TB_SETHOTIMAGELIST";
5527         case WM_USER+53: return "TB_GETHOTIMAGELIST";
5528         case WM_USER+54: return "TB_SETDISABLEDIMAGELIST";
5529         case WM_USER+55: return "TB_GETDISABLEDIMAGELIST";
5530         case WM_USER+56: return "TB_SETSTYLE";
5531         case WM_USER+57: return "TB_GETSTYLE";
5532         case WM_USER+58: return "TB_GETBUTTONSIZE";
5533         case WM_USER+59: return "TB_SETBUTTONWIDTH";
5534         case WM_USER+60: return "TB_SETMAXTEXTROWS";
5535         case WM_USER+61: return "TB_GETTEXTROWS";
5536         case WM_USER+41: return "TB_GETBITMAPFLAGS";
5537
5538         default:
5539             static char s_szBuf[128];
5540             sprintf(s_szBuf, "<unknown message = %d>", message);
5541             return s_szBuf;
5542     }
5543 }
5544 #endif //__WXDEBUG__
5545
5546 static void TranslateKbdEventToMouse(wxWindowMSW *win,
5547                                      int *x, int *y, WPARAM *flags)
5548 {
5549     // construct the key mask
5550     WPARAM& fwKeys = *flags;
5551
5552     fwKeys = MK_RBUTTON;
5553     if ( wxIsCtrlDown() )
5554         fwKeys |= MK_CONTROL;
5555     if ( wxIsShiftDown() )
5556         fwKeys |= MK_SHIFT;
5557
5558     // simulate right mouse button click
5559     DWORD dwPos = ::GetMessagePos();
5560     *x = GET_X_LPARAM(dwPos);
5561     *y = GET_Y_LPARAM(dwPos);
5562
5563     win->ScreenToClient(x, y);
5564 }
5565
5566 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
5567 {
5568     // prepare the DC
5569     TEXTMETRIC tm;
5570     HWND hwnd = GetHwndOf(win);
5571     HDC hdc = ::GetDC(hwnd);
5572
5573 #if !wxDIALOG_UNIT_COMPATIBILITY
5574     // and select the current font into it
5575     HFONT hfont = GetHfontOf(win->GetFont());
5576     if ( hfont )
5577     {
5578         hfont = (HFONT)::SelectObject(hdc, hfont);
5579     }
5580 #endif
5581
5582     // finally retrieve the text metrics from it
5583     GetTextMetrics(hdc, &tm);
5584
5585 #if !wxDIALOG_UNIT_COMPATIBILITY
5586     // and clean up
5587     if ( hfont )
5588     {
5589         (void)::SelectObject(hdc, hfont);
5590     }
5591 #endif
5592
5593     ::ReleaseDC(hwnd, hdc);
5594
5595     return tm;
5596 }
5597
5598 // Find the wxWindow at the current mouse position, returning the mouse
5599 // position.
5600 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
5601 {
5602     pt = wxGetMousePosition();
5603     return wxFindWindowAtPoint(pt);
5604 }
5605
5606 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
5607 {
5608     POINT pt2;
5609     pt2.x = pt.x;
5610     pt2.y = pt.y;
5611     HWND hWndHit = ::WindowFromPoint(pt2);
5612
5613     wxWindow* win = wxFindWinFromHandle((WXHWND) hWndHit) ;
5614     HWND hWnd = hWndHit;
5615
5616     // Try to find a window with a wxWindow associated with it
5617     while (!win && (hWnd != 0))
5618     {
5619         hWnd = ::GetParent(hWnd);
5620         win = wxFindWinFromHandle((WXHWND) hWnd) ;
5621     }
5622     return win;
5623 }
5624
5625 // Get the current mouse position.
5626 wxPoint wxGetMousePosition()
5627 {
5628     POINT pt;
5629     GetCursorPos( & pt );
5630
5631     return wxPoint(pt.x, pt.y);
5632 }
5633
5634 #if wxUSE_HOTKEY
5635
5636 bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
5637 {
5638     UINT win_modifiers=0;
5639     if ( modifiers & wxMOD_ALT )
5640         win_modifiers |= MOD_ALT;
5641     if ( modifiers & wxMOD_SHIFT )
5642         win_modifiers |= MOD_SHIFT;
5643     if ( modifiers & wxMOD_CONTROL )
5644         win_modifiers |= MOD_CONTROL;
5645     if ( modifiers & wxMOD_WIN )
5646         win_modifiers |= MOD_WIN;
5647
5648     if ( !::RegisterHotKey(GetHwnd(), hotkeyId, win_modifiers, keycode) )
5649     {
5650         wxLogLastError(_T("RegisterHotKey"));
5651
5652         return FALSE;
5653     }
5654
5655     return TRUE;
5656 }
5657
5658 bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
5659 {
5660     if ( !::UnregisterHotKey(GetHwnd(), hotkeyId) )
5661     {
5662         wxLogLastError(_T("UnregisterHotKey"));
5663
5664         return FALSE;
5665     }
5666
5667     return TRUE;
5668 }
5669
5670 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
5671 {
5672     int hotkeyId = wParam;
5673     int virtualKey = HIWORD(lParam);
5674     int win_modifiers = LOWORD(lParam);
5675
5676     wxKeyEvent event(CreateKeyEvent(wxEVT_HOTKEY, virtualKey, wParam, lParam));
5677     event.SetId(hotkeyId);
5678     event.m_shiftDown = (win_modifiers & MOD_SHIFT) != 0;
5679     event.m_controlDown = (win_modifiers & MOD_CONTROL) != 0;
5680     event.m_altDown = (win_modifiers & MOD_ALT) != 0;
5681     event.m_metaDown = (win_modifiers & MOD_WIN) != 0;
5682
5683     return GetEventHandler()->ProcessEvent(event);
5684 }
5685
5686 #endif // wxUSE_HOTKEY
5687
5688 // Not verified for WinCE
5689 #ifndef __WXWINCE__
5690 /*
5691  *      wxEventFixModule (needs a better name) allows message handling to continute while a menu
5692  *  is being shown - ie, to continue processing messages from a worker thread.
5693  *
5694  *  Code originally by Jason W. from wx-dev, reworked into a wxModule by Chris Mellon
5695  */
5696
5697 class wxEventFixModule : public wxModule {
5698 public:
5699         //base class virtuals
5700         virtual bool OnInit() {
5701                 wxEventFixModule::s_hMsgHookProc = SetWindowsHookEx(
5702                         WH_GETMESSAGE,
5703                         &wxEventFixModule::MsgHookProc,
5704                         NULL,
5705                         GetCurrentThreadId());
5706                         wxLogDebug(_T("Loaded event fix module"));
5707                         return true;
5708         };
5709         virtual void OnExit() {
5710                 UnhookWindowsHookEx(wxEventFixModule::s_hMsgHookProc);
5711
5712         };
5713         static LRESULT CALLBACK MsgHookProc(int nCode, WPARAM wParam, LPARAM lParam) {
5714                 MSG *msg = (MSG*)lParam;
5715                 switch (msg->message)
5716                 {
5717         case WM_NULL:
5718             static bool bInHookProc = false;
5719             if (!bInHookProc)
5720             {
5721                 bInHookProc = true;
5722                 wxTheApp->ProcessPendingEvents();
5723                 bInHookProc = false;
5724             }
5725             break;
5726                 }
5727                 return CallNextHookEx(wxEventFixModule::s_hMsgHookProc, nCode, wParam, lParam);
5728         };
5729 private:
5730         static HHOOK s_hMsgHookProc;
5731 DECLARE_DYNAMIC_CLASS(wxEventFixModule)
5732 };
5733 HHOOK wxEventFixModule::s_hMsgHookProc = 0;
5734
5735 IMPLEMENT_DYNAMIC_CLASS(wxEventFixModule, wxModule)
5736 #endif
5737     // __WXWINCE__
5738