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