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