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