src/msw/window.cpp

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