src/msw/window.cpp

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