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 USE_DEFERRED_SIZING
1571     // if SetSize() had been called at wx level but not realized at Windows
1572     // level yet (i.e. EndDeferWindowPos() not called), we still should return
1573     // the new and not the old position to the other wx code
1574     if ( m_pendingSize != wxDefaultSize )
1575     {
1576         if ( x )
1577             *x = m_pendingSize.x;
1578         if ( y )
1579             *y = m_pendingSize.y;
1580     }
1581     else // use current size
1582 #endif // USE_DEFERRED_SIZING
1583     {
1584         RECT rect = wxGetWindowRect(GetHwnd());
1585
1586         if ( x )
1587             *x = rect.right - rect.left;
1588         if ( y )
1589             *y = rect.bottom - rect.top;
1590     }
1591 }
1592
1593 // Get size *available for subwindows* i.e. excluding menu bar etc.
1594 void wxWindowMSW::DoGetClientSize(int *x, int *y) const
1595 {
1596 #if USE_DEFERRED_SIZING
1597     if ( m_pendingSize != wxDefaultSize )
1598     {
1599         // we need to calculate the client size corresponding to pending size
1600         RECT rect;
1601         rect.left = m_pendingPosition.x;
1602         rect.top = m_pendingPosition.y;
1603         rect.right = rect.left + m_pendingSize.x;
1604         rect.bottom = rect.top + m_pendingSize.y;
1605
1606         ::SendMessage(GetHwnd(), WM_NCCALCSIZE, FALSE, (LPARAM)&rect);
1607
1608         if ( x )
1609             *x = rect.right - rect.left;
1610         if ( y )
1611             *y = rect.bottom - rect.top;
1612     }
1613     else
1614 #endif // USE_DEFERRED_SIZING
1615     {
1616         RECT rect = wxGetClientRect(GetHwnd());
1617
1618         if ( x )
1619             *x = rect.right;
1620         if ( y )
1621             *y = rect.bottom;
1622     }
1623 }
1624
1625 void wxWindowMSW::DoGetPosition(int *x, int *y) const
1626 {
1627     wxWindow * const parent = GetParent();
1628
1629     wxPoint pos;
1630     if ( m_pendingPosition != wxDefaultPosition )
1631     {
1632         pos = m_pendingPosition;
1633     }
1634     else // use current position
1635     {
1636         RECT rect = wxGetWindowRect(GetHwnd());
1637
1638         POINT point;
1639         point.x = rect.left;
1640         point.y = rect.top;
1641
1642         // we do the adjustments with respect to the parent only for the "real"
1643         // children, not for the dialogs/frames
1644         if ( !IsTopLevel() )
1645         {
1646             // Since we now have the absolute screen coords, if there's a
1647             // parent we must subtract its top left corner
1648             if ( parent )
1649             {
1650                 ::ScreenToClient(GetHwndOf(parent), &point);
1651             }
1652         }
1653
1654         pos.x = point.x;
1655         pos.y = point.y;
1656     }
1657
1658     // we also must adjust by the client area offset: a control which is just
1659     // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1660     if ( parent && !IsTopLevel() )
1661     {
1662         const wxPoint pt(parent->GetClientAreaOrigin());
1663         pos.x -= pt.x;
1664         pos.y -= pt.y;
1665     }
1666
1667     if ( x )
1668         *x = pos.x;
1669     if ( y )
1670         *y = pos.y;
1671 }
1672
1673 void wxWindowMSW::DoScreenToClient(int *x, int *y) const
1674 {
1675     POINT pt;
1676     if ( x )
1677         pt.x = *x;
1678     if ( y )
1679         pt.y = *y;
1680
1681     ::ScreenToClient(GetHwnd(), &pt);
1682
1683     if ( x )
1684         *x = pt.x;
1685     if ( y )
1686         *y = pt.y;
1687 }
1688
1689 void wxWindowMSW::DoClientToScreen(int *x, int *y) const
1690 {
1691     POINT pt;
1692     if ( x )
1693         pt.x = *x;
1694     if ( y )
1695         pt.y = *y;
1696
1697     ::ClientToScreen(GetHwnd(), &pt);
1698
1699     if ( x )
1700         *x = pt.x;
1701     if ( y )
1702         *y = pt.y;
1703 }
1704
1705 bool
1706 wxWindowMSW::DoMoveSibling(WXHWND hwnd, int x, int y, int width, int height)
1707 {
1708 #if USE_DEFERRED_SIZING
1709     // if our parent had prepared a defer window handle for us, use it (unless
1710     // we are a top level window)
1711     wxWindowMSW * const parent = IsTopLevel() ? NULL : GetParent();
1712
1713     HDWP hdwp = parent ? (HDWP)parent->m_hDWP : NULL;
1714     if ( hdwp )
1715     {
1716         hdwp = ::DeferWindowPos(hdwp, (HWND)hwnd, NULL, x, y, width, height,
1717                                 SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_NOACTIVATE);
1718         if ( !hdwp )
1719         {
1720             wxLogLastError(_T("DeferWindowPos"));
1721         }
1722     }
1723
1724     if ( parent )
1725     {
1726         // hdwp must be updated as it may have been changed
1727         parent->m_hDWP = (WXHANDLE)hdwp;
1728     }
1729
1730     if ( hdwp )
1731     {
1732         // did deferred move, remember new coordinates of the window as they're
1733         // different from what Windows would return for it
1734         return true;
1735     }
1736
1737     // otherwise (or if deferring failed) move the window in place immediately
1738 #endif // USE_DEFERRED_SIZING
1739     if ( !::MoveWindow((HWND)hwnd, x, y, width, height, IsShown()) )
1740     {
1741         wxLogLastError(wxT("MoveWindow"));
1742     }
1743
1744     // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1745     // ignored otherwise
1746     return false;
1747 }
1748
1749 void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
1750 {
1751     // TODO: is this consistent with other platforms?
1752     // Still, negative width or height shouldn't be allowed
1753     if (width < 0)
1754         width = 0;
1755     if (height < 0)
1756         height = 0;
1757
1758     if ( DoMoveSibling(m_hWnd, x, y, width, height) )
1759     {
1760 #if USE_DEFERRED_SIZING
1761         m_pendingPosition = wxPoint(x, y);
1762         m_pendingSize = wxSize(width, height);
1763 #endif // USE_DEFERRED_SIZING
1764     }
1765 }
1766
1767 // set the size of the window: if the dimensions are positive, just use them,
1768 // but if any of them is equal to -1, it means that we must find the value for
1769 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1770 // which case -1 is a valid value for x and y)
1771 //
1772 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1773 // the width/height to best suit our contents, otherwise we reuse the current
1774 // width/height
1775 void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1776 {
1777     // get the current size and position...
1778     int currentX, currentY;
1779     int currentW, currentH;
1780
1781     GetPosition(&currentX, &currentY);
1782     GetSize(&currentW, &currentH);
1783
1784     // ... and don't do anything (avoiding flicker) if it's already ok unless
1785     // we're forced to resize the window
1786     if ( x == currentX && y == currentY &&
1787          width == currentW && height == currentH &&
1788             !(sizeFlags & wxSIZE_FORCE) )
1789     {
1790         return;
1791     }
1792
1793     if ( x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1794         x = currentX;
1795     if ( y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1796         y = currentY;
1797
1798     AdjustForParentClientOrigin(x, y, sizeFlags);
1799
1800     wxSize size = wxDefaultSize;
1801     if ( width == wxDefaultCoord )
1802     {
1803         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
1804         {
1805             size = DoGetBestSize();
1806             width = size.x;
1807         }
1808         else
1809         {
1810             // just take the current one
1811             width = currentW;
1812         }
1813     }
1814
1815     if ( height == wxDefaultCoord )
1816     {
1817         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
1818         {
1819             if ( size.x == wxDefaultCoord )
1820             {
1821                 size = DoGetBestSize();
1822             }
1823             //else: already called DoGetBestSize() above
1824
1825             height = size.y;
1826         }
1827         else
1828         {
1829             // just take the current one
1830             height = currentH;
1831         }
1832     }
1833
1834     DoMoveWindow(x, y, width, height);
1835 }
1836
1837 void wxWindowMSW::DoSetClientSize(int width, int height)
1838 {
1839     // setting the client size is less obvious than it could have been
1840     // because in the result of changing the total size the window scrollbar
1841     // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
1842     // doesn't take neither into account) and so the client size will not be
1843     // correct as the difference between the total and client size changes --
1844     // so we keep changing it until we get it right
1845     //
1846     // normally this loop shouldn't take more than 3 iterations (usually 1 but
1847     // if scrollbars [dis]appear as the result of the first call, then 2 and it
1848     // may become 3 if the window had 0 size originally and so we didn't
1849     // calculate the scrollbar correction correctly during the first iteration)
1850     // but just to be on the safe side we check for it instead of making it an
1851     // "infinite" loop (i.e. leaving break inside as the only way to get out)
1852     for ( int i = 0; i < 4; i++ )
1853     {
1854         RECT rectClient;
1855         ::GetClientRect(GetHwnd(), &rectClient);
1856
1857         // if the size is already ok, stop here (NB: rectClient.left = top = 0)
1858         if ( (rectClient.right == width || width == wxDefaultCoord) &&
1859              (rectClient.bottom == height || height == wxDefaultCoord) )
1860         {
1861             break;
1862         }
1863
1864         // Find the difference between the entire window (title bar and all)
1865         // and the client area; add this to the new client size to move the
1866         // window
1867         RECT rectWin;
1868         ::GetWindowRect(GetHwnd(), &rectWin);
1869
1870         const int widthWin = rectWin.right - rectWin.left,
1871                   heightWin = rectWin.bottom - rectWin.top;
1872
1873         // MoveWindow positions the child windows relative to the parent, so
1874         // adjust if necessary
1875         if ( !IsTopLevel() )
1876         {
1877             wxWindow *parent = GetParent();
1878             if ( parent )
1879             {
1880                 ::ScreenToClient(GetHwndOf(parent), (POINT *)&rectWin);
1881             }
1882         }
1883
1884         // don't call DoMoveWindow() because we want to move window immediately
1885         // and not defer it here as otherwise the value returned by
1886         // GetClient/WindowRect() wouldn't change as the window wouldn't be
1887         // really resized
1888         if ( !::MoveWindow(GetHwnd(),
1889                            rectWin.left,
1890                            rectWin.top,
1891                            width + widthWin - rectClient.right,
1892                            height + heightWin - rectClient.bottom,
1893                            TRUE) )
1894         {
1895             wxLogLastError(_T("MoveWindow"));
1896         }
1897     }
1898 }
1899
1900 // ---------------------------------------------------------------------------
1901 // text metrics
1902 // ---------------------------------------------------------------------------
1903
1904 int wxWindowMSW::GetCharHeight() const
1905 {
1906     return wxGetTextMetrics(this).tmHeight;
1907 }
1908
1909 int wxWindowMSW::GetCharWidth() const
1910 {
1911     // +1 is needed because Windows apparently adds it when calculating the
1912     // dialog units size in pixels
1913 #if wxDIALOG_UNIT_COMPATIBILITY
1914     return wxGetTextMetrics(this).tmAveCharWidth;
1915 #else
1916     return wxGetTextMetrics(this).tmAveCharWidth + 1;
1917 #endif
1918 }
1919
1920 void wxWindowMSW::GetTextExtent(const wxString& string,
1921                              int *x, int *y,
1922                              int *descent, int *externalLeading,
1923                              const wxFont *theFont) const
1924 {
1925     wxASSERT_MSG( !theFont || theFont->Ok(),
1926                     _T("invalid font in GetTextExtent()") );
1927
1928     wxFont fontToUse;
1929     if (theFont)
1930         fontToUse = *theFont;
1931     else
1932         fontToUse = GetFont();
1933
1934     WindowHDC hdc(GetHwnd());
1935     SelectInHDC selectFont(hdc, GetHfontOf(fontToUse));
1936
1937     SIZE sizeRect;
1938     TEXTMETRIC tm;
1939     ::GetTextExtentPoint32(hdc, string, string.length(), &sizeRect);
1940     GetTextMetrics(hdc, &tm);
1941
1942     if ( x )
1943         *x = sizeRect.cx;
1944     if ( y )
1945         *y = sizeRect.cy;
1946     if ( descent )
1947         *descent = tm.tmDescent;
1948     if ( externalLeading )
1949         *externalLeading = tm.tmExternalLeading;
1950 }
1951
1952 // ---------------------------------------------------------------------------
1953 // popup menu
1954 // ---------------------------------------------------------------------------
1955
1956 #if wxUSE_MENUS_NATIVE
1957
1958 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1959 // immediately, without waiting for the next event loop iteration
1960 //
1961 // NB: this function should probably be made public later as it can almost
1962 //     surely replace wxYield() elsewhere as well
1963 static void wxYieldForCommandsOnly()
1964 {
1965     // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1966     // want to process it here)
1967     MSG msg;
1968     while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE) )
1969     {
1970         if ( msg.message == WM_QUIT )
1971         {
1972             // if we retrieved a WM_QUIT, insert back into the message queue.
1973             ::PostQuitMessage(0);
1974             break;
1975         }
1976
1977         // luckily (as we don't have access to wxEventLoopImpl method from here
1978         // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1979         // immediately
1980         ::TranslateMessage(&msg);
1981         ::DispatchMessage(&msg);
1982     }
1983 }
1984
1985 bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
1986 {
1987     menu->SetInvokingWindow(this);
1988     menu->UpdateUI();
1989
1990     if ( x == wxDefaultCoord && y == wxDefaultCoord )
1991     {
1992         wxPoint mouse = ScreenToClient(wxGetMousePosition());
1993         x = mouse.x; y = mouse.y;
1994     }
1995
1996     HWND hWnd = GetHwnd();
1997     HMENU hMenu = GetHmenuOf(menu);
1998     POINT point;
1999     point.x = x;
2000     point.y = y;
2001     ::ClientToScreen(hWnd, &point);
2002     wxCurrentPopupMenu = menu;
2003 #if defined(__WXWINCE__)
2004     UINT flags = 0;
2005 #else
2006     UINT flags = TPM_RIGHTBUTTON | TPM_RECURSE;
2007 #endif
2008     ::TrackPopupMenu(hMenu, flags, point.x, point.y, 0, hWnd, NULL);
2009
2010     // we need to do it right now as otherwise the events are never going to be
2011     // sent to wxCurrentPopupMenu from HandleCommand()
2012     //
2013     // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2014     // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2015     // destroyed as soon as we return (it can be a local variable in the caller
2016     // for example) and so we do need to process the event immediately
2017     wxYieldForCommandsOnly();
2018
2019     wxCurrentPopupMenu = NULL;
2020
2021     menu->SetInvokingWindow(NULL);
2022
2023     return true;
2024 }
2025
2026 #endif // wxUSE_MENUS_NATIVE
2027
2028 // ===========================================================================
2029 // pre/post message processing
2030 // ===========================================================================
2031
2032 WXLRESULT wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2033 {
2034     if ( m_oldWndProc )
2035         return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
2036     else
2037         return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
2038 }
2039
2040 bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
2041 {
2042     // wxUniversal implements tab traversal itself
2043 #ifndef __WXUNIVERSAL__
2044     if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
2045     {
2046         // intercept dialog navigation keys
2047         MSG *msg = (MSG *)pMsg;
2048
2049         // here we try to do all the job which ::IsDialogMessage() usually does
2050         // internally
2051         if ( msg->message == WM_KEYDOWN )
2052         {
2053             bool bCtrlDown = wxIsCtrlDown();
2054             bool bShiftDown = wxIsShiftDown();
2055
2056             // WM_GETDLGCODE: ask the control if it wants the key for itself,
2057             // don't process it if it's the case (except for Ctrl-Tab/Enter
2058             // combinations which are always processed)
2059             LONG lDlgCode = ::SendMessage(msg->hwnd, WM_GETDLGCODE, 0, 0);
2060
2061             // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2062             // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2063             // it, of course, implies them
2064             if ( lDlgCode & DLGC_WANTALLKEYS )
2065             {
2066                 lDlgCode |= DLGC_WANTTAB | DLGC_WANTARROWS;
2067             }
2068
2069             bool bForward = true,
2070                  bWindowChange = false,
2071                  bFromTab = false;
2072
2073             // should we process this message specially?
2074             bool bProcess = true;
2075             switch ( msg->wParam )
2076             {
2077                 case VK_TAB:
2078                     if ( lDlgCode & DLGC_WANTTAB ) {
2079                         bProcess = false;
2080                     }
2081                     else {
2082                         // Ctrl-Tab cycles thru notebook pages
2083                         bWindowChange = bCtrlDown;
2084                         bForward = !bShiftDown;
2085                         bFromTab = true;
2086                     }
2087                     break;
2088
2089                 case VK_UP:
2090                 case VK_LEFT:
2091                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
2092                         bProcess = false;
2093                     else
2094                         bForward = false;
2095                     break;
2096
2097                 case VK_DOWN:
2098                 case VK_RIGHT:
2099                     if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
2100                         bProcess = false;
2101                     break;
2102
2103                 case VK_PRIOR:
2104                     bForward = false;
2105                     // fall through
2106
2107                 case VK_NEXT:
2108                     // we treat PageUp/Dn as arrows because chances are that
2109                     // a control which needs arrows also needs them for
2110                     // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2111                     if ( (lDlgCode & DLGC_WANTARROWS) || !bCtrlDown )
2112                         bProcess = false;
2113                     else
2114                         bWindowChange = true;
2115                     break;
2116
2117                 case VK_RETURN:
2118                     {
2119                         if ( (lDlgCode & DLGC_WANTMESSAGE) && !bCtrlDown )
2120                         {
2121                             // control wants to process Enter itself, don't
2122                             // call IsDialogMessage() which would interpret
2123                             // it
2124                             return false;
2125                         }
2126
2127                         // currently active button should get enter press even
2128                         // if there is a default button elsewhere
2129                         if ( lDlgCode & DLGC_DEFPUSHBUTTON )
2130                         {
2131                             // let IsDialogMessage() handle this for all
2132                             // buttons except the owner-drawn ones which it
2133                             // just seems to ignore
2134                             long style = ::GetWindowLong(msg->hwnd, GWL_STYLE);
2135                             if ( (style & BS_OWNERDRAW) == BS_OWNERDRAW )
2136                             {
2137                                 // emulate the button click
2138                                 wxWindow *
2139                                     btn = wxFindWinFromHandle((WXHWND)msg->hwnd);
2140                                 if ( btn )
2141                                     btn->MSWCommand(BN_CLICKED, 0 /* unused */);
2142                             }
2143
2144                             bProcess = false;
2145                         }
2146                         else // not a button itself
2147                         {
2148 #if wxUSE_BUTTON
2149                             wxButton *btn = wxDynamicCast(GetDefaultItem(),
2150                                                           wxButton);
2151                             if ( btn && btn->IsEnabled() )
2152                             {
2153                                 // if we do have a default button, do press it
2154                                 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
2155
2156                                 return true;
2157                             }
2158                             else // no default button
2159 #endif // wxUSE_BUTTON
2160                             {
2161 #ifdef __WXWINCE__
2162                                 wxJoystickEvent event(wxEVT_JOY_BUTTON_DOWN);
2163                                 event.SetEventObject(this);
2164                                 if(GetEventHandler()->ProcessEvent(event))
2165                                     return true;
2166 #endif
2167                                 // this is a quick and dirty test for a text
2168                                 // control
2169                                 if ( !(lDlgCode & DLGC_HASSETSEL) )
2170                                 {
2171                                     // don't process Enter, the control might
2172                                     // need it for itself and don't let
2173                                     // ::IsDialogMessage() have it as it can
2174                                     // eat the Enter events sometimes
2175                                     return false;
2176                                 }
2177                                 else if (!IsTopLevel())
2178                                 {
2179                                     // if not a top level window, let parent
2180                                     // handle it
2181                                     return false;
2182                                 }
2183                                 //else: treat Enter as TAB: pass to the next
2184                                 //      control as this is the best thing to do
2185                                 //      if the text doesn't handle Enter itself
2186                             }
2187                         }
2188                     }
2189                     break;
2190
2191                 default:
2192                     bProcess = false;
2193             }
2194
2195             if ( bProcess )
2196             {
2197                 wxNavigationKeyEvent event;
2198                 event.SetDirection(bForward);
2199                 event.SetWindowChange(bWindowChange);
2200                 event.SetFromTab(bFromTab);
2201                 event.SetEventObject(this);
2202
2203                 if ( GetEventHandler()->ProcessEvent(event) )
2204                 {
2205                     // as we don't call IsDialogMessage(), which would take of
2206                     // this by default, we need to manually send this message
2207                     // so that controls can change their UI state if needed
2208                     MSWUpdateUIState(UIS_CLEAR, UISF_HIDEFOCUS);
2209
2210                     return true;
2211                 }
2212             }
2213         }
2214
2215         // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2216         // message even when there is no cancel button and when the message is
2217         // needed by the control itself: in particular, it prevents the tree in
2218         // place edit control from being closed with Escape in a dialog
2219         if ( msg->message != WM_KEYDOWN || msg->wParam != VK_ESCAPE )
2220         {
2221             // ::IsDialogMessage() is broken and may sometimes hang the
2222             // application by going into an infinite loop, so we try to detect
2223             // [some of] the situations when this may happen and not call it
2224             // then
2225
2226             // assume we can call it by default
2227             bool canSafelyCallIsDlgMsg = true;
2228
2229             HWND hwndFocus = ::GetFocus();
2230
2231             // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2232             // an infinite loop, because it will recursively check the child
2233             // windows but not the window itself and so if none of the children
2234             // accepts focus it loops forever (as it only stops when it gets
2235             // back to the window it started from)
2236             //
2237             // while it is very unusual that a window with WS_EX_CONTROLPARENT
2238             // style has the focus, it can happen. One such possibility is if
2239             // all windows are either toplevel, wxDialog, wxPanel or static
2240             // controls and no window can actually accept keyboard input.
2241 #if !defined(__WXWINCE__)
2242             if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
2243             {
2244                 // pessimistic by default
2245                 canSafelyCallIsDlgMsg = false;
2246                 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2247                       node;
2248                       node = node->GetNext() )
2249                 {
2250                     wxWindow * const win = node->GetData();
2251                     if ( win->AcceptsFocus() &&
2252                             !(::GetWindowLong(GetHwndOf(win), GWL_EXSTYLE) &
2253                                 WS_EX_CONTROLPARENT) )
2254                     {
2255                         // it shouldn't hang...
2256                         canSafelyCallIsDlgMsg = true;
2257
2258                         break;
2259                     }
2260                 }
2261             }
2262 #endif // !__WXWINCE__
2263
2264             if ( canSafelyCallIsDlgMsg )
2265             {
2266                 // ::IsDialogMessage() can enter in an infinite loop when the
2267                 // currently focused window is disabled or hidden and its
2268                 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2269                 // this case
2270                 while ( hwndFocus )
2271                 {
2272                     if ( !::IsWindowEnabled(hwndFocus) ||
2273                             !::IsWindowVisible(hwndFocus) )
2274                     {
2275                         // it would enter an infinite loop if we do this!
2276                         canSafelyCallIsDlgMsg = false;
2277
2278                         break;
2279                     }
2280
2281                     if ( !(::GetWindowLong(hwndFocus, GWL_STYLE) & WS_CHILD) )
2282                     {
2283                         // it's a top level window, don't go further -- e.g. even
2284                         // if the parent of a dialog is disabled, this doesn't
2285                         // break navigation inside the dialog
2286                         break;
2287                     }
2288
2289                     hwndFocus = ::GetParent(hwndFocus);
2290                 }
2291             }
2292
2293             // let IsDialogMessage() have the message if it's safe to call it
2294             if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
2295             {
2296                 // IsDialogMessage() did something...
2297                 return true;
2298             }
2299         }
2300     }
2301 #endif // __WXUNIVERSAL__
2302
2303 #if wxUSE_TOOLTIPS
2304     if ( m_tooltip )
2305     {
2306         // relay mouse move events to the tooltip control
2307         MSG *msg = (MSG *)pMsg;
2308         if ( msg->message == WM_MOUSEMOVE )
2309             wxToolTip::RelayEvent(pMsg);
2310     }
2311 #endif // wxUSE_TOOLTIPS
2312
2313     return false;
2314 }
2315
2316 bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
2317 {
2318 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2319     return m_acceleratorTable.Translate(this, pMsg);
2320 #else
2321     (void) pMsg;
2322     return false;
2323 #endif // wxUSE_ACCEL
2324 }
2325
2326 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
2327 {
2328     // preprocess all messages by default
2329     return true;
2330 }
2331
2332 // ---------------------------------------------------------------------------
2333 // message params unpackers
2334 // ---------------------------------------------------------------------------
2335
2336 void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
2337                              WORD *id, WXHWND *hwnd, WORD *cmd)
2338 {
2339     *id = LOWORD(wParam);
2340     *hwnd = (WXHWND)lParam;
2341     *cmd = HIWORD(wParam);
2342 }
2343
2344 void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
2345                               WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
2346 {
2347     *state = LOWORD(wParam);
2348     *minimized = HIWORD(wParam);
2349     *hwnd = (WXHWND)lParam;
2350 }
2351
2352 void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
2353                             WXWORD *code, WXWORD *pos, WXHWND *hwnd)
2354 {
2355     *code = LOWORD(wParam);
2356     *pos = HIWORD(wParam);
2357     *hwnd = (WXHWND)lParam;
2358 }
2359
2360 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
2361                                  WXHDC *hdc, WXHWND *hwnd)
2362 {
2363     *hwnd = (WXHWND)lParam;
2364     *hdc = (WXHDC)wParam;
2365 }
2366
2367 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
2368                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
2369 {
2370     *item = (WXWORD)wParam;
2371     *flags = HIWORD(wParam);
2372     *hmenu = (WXHMENU)lParam;
2373 }
2374
2375 // ---------------------------------------------------------------------------
2376 // Main wxWidgets window proc and the window proc for wxWindow
2377 // ---------------------------------------------------------------------------
2378
2379 // Hook for new window just as it's being created, when the window isn't yet
2380 // associated with the handle
2381 static wxWindowMSW *gs_winBeingCreated = NULL;
2382
2383 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2384 // window being created and insures that it's always unset back later
2385 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW *winBeingCreated)
2386 {
2387     gs_winBeingCreated = winBeingCreated;
2388 }
2389
2390 wxWindowCreationHook::~wxWindowCreationHook()
2391 {
2392     gs_winBeingCreated = NULL;
2393 }
2394
2395 // Main window proc
2396 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2397 {
2398     // trace all messages - useful for the debugging
2399 #ifdef __WXDEBUG__
2400     wxLogTrace(wxTraceMessages,
2401                wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2402                wxGetMessageName(message), (long)hWnd, (long)wParam, lParam);
2403 #endif // __WXDEBUG__
2404
2405     wxWindowMSW *wnd = wxFindWinFromHandle((WXHWND) hWnd);
2406
2407     // when we get the first message for the HWND we just created, we associate
2408     // it with wxWindow stored in gs_winBeingCreated
2409     if ( !wnd && gs_winBeingCreated )
2410     {
2411         wxAssociateWinWithHandle(hWnd, gs_winBeingCreated);
2412         wnd = gs_winBeingCreated;
2413         gs_winBeingCreated = NULL;
2414         wnd->SetHWND((WXHWND)hWnd);
2415     }
2416
2417     LRESULT rc;
2418
2419     if ( wnd && wxEventLoop::AllowProcessing(wnd) )
2420         rc = wnd->MSWWindowProc(message, wParam, lParam);
2421     else
2422         rc = ::DefWindowProc(hWnd, message, wParam, lParam);
2423
2424     return rc;
2425 }
2426
2427 WXLRESULT wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
2428 {
2429     // did we process the message?
2430     bool processed = false;
2431
2432     // the return value
2433     union
2434     {
2435         bool        allow;
2436         WXLRESULT   result;
2437         WXHBRUSH    hBrush;
2438     } rc;
2439
2440     // for most messages we should return 0 when we do process the message
2441     rc.result = 0;
2442
2443     switch ( message )
2444     {
2445         case WM_CREATE:
2446             {
2447                 bool mayCreate;
2448                 processed = HandleCreate((WXLPCREATESTRUCT)lParam, &mayCreate);
2449                 if ( processed )
2450                 {
2451                     // return 0 to allow window creation
2452                     rc.result = mayCreate ? 0 : -1;
2453                 }
2454             }
2455             break;
2456
2457         case WM_DESTROY:
2458             // never set processed to true and *always* pass WM_DESTROY to
2459             // DefWindowProc() as Windows may do some internal cleanup when
2460             // processing it and failing to pass the message along may cause
2461             // memory and resource leaks!
2462             (void)HandleDestroy();
2463             break;
2464
2465         case WM_SIZE:
2466             processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
2467             break;
2468
2469         case WM_MOVE:
2470             processed = HandleMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2471             break;
2472
2473 #if !defined(__WXWINCE__)
2474         case WM_MOVING:
2475             {
2476                 LPRECT pRect = (LPRECT)lParam;
2477                 wxRect rc;
2478                 rc.SetLeft(pRect->left);
2479                 rc.SetTop(pRect->top);
2480                 rc.SetRight(pRect->right);
2481                 rc.SetBottom(pRect->bottom);
2482                 processed = HandleMoving(rc);
2483                 if (processed) {
2484                     pRect->left = rc.GetLeft();
2485                     pRect->top = rc.GetTop();
2486                     pRect->right = rc.GetRight();
2487                     pRect->bottom = rc.GetBottom();
2488                 }
2489             }
2490             break;
2491
2492         case WM_SIZING:
2493             {
2494                 LPRECT pRect = (LPRECT)lParam;
2495                 wxRect rc;
2496                 rc.SetLeft(pRect->left);
2497                 rc.SetTop(pRect->top);
2498                 rc.SetRight(pRect->right);
2499                 rc.SetBottom(pRect->bottom);
2500                 processed = HandleSizing(rc);
2501                 if (processed) {
2502                     pRect->left = rc.GetLeft();
2503                     pRect->top = rc.GetTop();
2504                     pRect->right = rc.GetRight();
2505                     pRect->bottom = rc.GetBottom();
2506                 }
2507             }
2508             break;
2509 #endif // !__WXWINCE__
2510
2511 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2512         case WM_ACTIVATEAPP:
2513             // This implicitly sends a wxEVT_ACTIVATE_APP event
2514             wxTheApp->SetActive(wParam != 0, FindFocus());
2515             break;
2516 #endif
2517
2518         case WM_ACTIVATE:
2519             {
2520                 WXWORD state, minimized;
2521                 WXHWND hwnd;
2522                 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
2523
2524                 processed = HandleActivate(state, minimized != 0, (WXHWND)hwnd);
2525             }
2526             break;
2527
2528         case WM_SETFOCUS:
2529             processed = HandleSetFocus((WXHWND)(HWND)wParam);
2530             break;
2531
2532         case WM_KILLFOCUS:
2533             processed = HandleKillFocus((WXHWND)(HWND)wParam);
2534             break;
2535
2536         case WM_PRINTCLIENT:
2537             processed = HandlePrintClient((WXHDC)wParam);
2538             break;
2539
2540         case WM_PAINT:
2541             if ( wParam )
2542             {
2543                 wxPaintDCEx dc((wxWindow *)this, (WXHDC)wParam);
2544
2545                 processed = HandlePaint();
2546             }
2547             else // no DC given
2548             {
2549                 processed = HandlePaint();
2550             }
2551             break;
2552
2553         case WM_CLOSE:
2554 #ifdef __WXUNIVERSAL__
2555             // Universal uses its own wxFrame/wxDialog, so we don't receive
2556             // close events unless we have this.
2557             Close();
2558 #endif // __WXUNIVERSAL__
2559
2560             // don't let the DefWindowProc() destroy our window - we'll do it
2561             // ourselves in ~wxWindow
2562             processed = true;
2563             rc.result = TRUE;
2564             break;
2565
2566         case WM_SHOWWINDOW:
2567             processed = HandleShow(wParam != 0, (int)lParam);
2568             break;
2569
2570         case WM_MOUSEMOVE:
2571             processed = HandleMouseMove(GET_X_LPARAM(lParam),
2572                                         GET_Y_LPARAM(lParam),
2573                                         wParam);
2574             break;
2575
2576 #ifdef HAVE_TRACKMOUSEEVENT
2577         case WM_MOUSELEAVE:
2578             // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
2579             if ( m_mouseInWindow )
2580             {
2581                 GenerateMouseLeave();
2582             }
2583
2584             // always pass processed back as false, this allows the window
2585             // manager to process the message too.  This is needed to
2586             // ensure windows XP themes work properly as the mouse moves
2587             // over widgets like buttons. So don't set processed to true here.
2588             break;
2589 #endif // HAVE_TRACKMOUSEEVENT
2590
2591 #if wxUSE_MOUSEWHEEL
2592         case WM_MOUSEWHEEL:
2593             processed = HandleMouseWheel(wParam, lParam);
2594             break;
2595 #endif
2596
2597         case WM_LBUTTONDOWN:
2598         case WM_LBUTTONUP:
2599         case WM_LBUTTONDBLCLK:
2600         case WM_RBUTTONDOWN:
2601         case WM_RBUTTONUP:
2602         case WM_RBUTTONDBLCLK:
2603         case WM_MBUTTONDOWN:
2604         case WM_MBUTTONUP:
2605         case WM_MBUTTONDBLCLK:
2606             {
2607 #ifdef __WXMICROWIN__
2608                 // MicroWindows seems to ignore the fact that a window is
2609                 // disabled. So catch mouse events and throw them away if
2610                 // necessary.
2611                 wxWindowMSW* win = this;
2612                 for ( ;; )
2613                 {
2614                     if (!win->IsEnabled())
2615                     {
2616                         processed = true;
2617                         break;
2618                     }
2619
2620                     win = win->GetParent();
2621                     if ( !win || win->IsTopLevel() )
2622                         break;
2623                 }
2624
2625                 if ( processed )
2626                     break;
2627
2628 #endif // __WXMICROWIN__
2629                 int x = GET_X_LPARAM(lParam),
2630                     y = GET_Y_LPARAM(lParam);
2631
2632 #ifdef __WXWINCE__
2633                 // redirect the event to a static control if necessary by
2634                 // finding one under mouse because under CE the static controls
2635                 // don't generate mouse events (even with SS_NOTIFY)
2636                 wxWindowMSW *win;
2637                 if ( GetCapture() == this )
2638                 {
2639                     // but don't do it if the mouse is captured by this window
2640                     // because then it should really get this event itself
2641                     win = this;
2642                 }
2643                 else
2644                 {
2645                     win = FindWindowForMouseEvent(this, &x, &y);
2646
2647                     // this should never happen
2648                     wxCHECK_MSG( win, 0,
2649                                  _T("FindWindowForMouseEvent() returned NULL") );
2650                 }
2651 #ifdef __POCKETPC__
2652                 if (IsContextMenuEnabled() && message == WM_LBUTTONDOWN)
2653                 {
2654                     SHRGINFO shrgi = {0};
2655
2656                     shrgi.cbSize = sizeof(SHRGINFO);
2657                     shrgi.hwndClient = (HWND) GetHWND();
2658                     shrgi.ptDown.x = x;
2659                     shrgi.ptDown.y = y;
2660
2661                     shrgi.dwFlags = SHRG_RETURNCMD;
2662                     // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2663
2664                     if (GN_CONTEXTMENU == ::SHRecognizeGesture(&shrgi))
2665                     {
2666                         wxPoint pt(x, y);
2667                         pt = ClientToScreen(pt);
2668
2669                         wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
2670
2671                         evtCtx.SetEventObject(this);
2672                         if (GetEventHandler()->ProcessEvent(evtCtx))
2673                         {
2674                             processed = true;
2675                             return true;
2676                         }
2677                     }
2678                 }
2679 #endif
2680
2681 #else // !__WXWINCE__
2682                 wxWindowMSW *win = this;
2683 #endif // __WXWINCE__/!__WXWINCE__
2684
2685                 processed = win->HandleMouseEvent(message, x, y, wParam);
2686
2687                 // if the app didn't eat the event, handle it in the default
2688                 // way, that is by giving this window the focus
2689                 if ( !processed )
2690                 {
2691                     // for the standard classes their WndProc sets the focus to
2692                     // them anyhow and doing it from here results in some weird
2693                     // problems, so don't do it for them (unnecessary anyhow)
2694                     if ( !win->IsOfStandardClass() )
2695                     {
2696                         if ( message == WM_LBUTTONDOWN && win->AcceptsFocus() )
2697                             win->SetFocus();
2698                     }
2699                 }
2700             }
2701             break;
2702
2703 #ifdef MM_JOY1MOVE
2704         case MM_JOY1MOVE:
2705         case MM_JOY2MOVE:
2706         case MM_JOY1ZMOVE:
2707         case MM_JOY2ZMOVE:
2708         case MM_JOY1BUTTONDOWN:
2709         case MM_JOY2BUTTONDOWN:
2710         case MM_JOY1BUTTONUP:
2711         case MM_JOY2BUTTONUP:
2712             processed = HandleJoystickEvent(message,
2713                                             GET_X_LPARAM(lParam),
2714                                             GET_Y_LPARAM(lParam),
2715                                             wParam);
2716             break;
2717 #endif // __WXMICROWIN__
2718
2719         case WM_COMMAND:
2720             {
2721                 WORD id, cmd;
2722                 WXHWND hwnd;
2723                 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
2724
2725                 processed = HandleCommand(id, cmd, hwnd);
2726             }
2727             break;
2728
2729         case WM_NOTIFY:
2730             processed = HandleNotify((int)wParam, lParam, &rc.result);
2731             break;
2732
2733         // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2734         // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2735         // apparently doesn't always behave properly and needs some help
2736 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2737         case WM_NOTIFYFORMAT:
2738             if ( lParam == NF_QUERY )
2739             {
2740                 processed = true;
2741                 rc.result = NFR_UNICODE;
2742             }
2743             break;
2744 #endif // wxUSE_UNICODE_MSLU
2745
2746             // for these messages we must return true if process the message
2747 #ifdef WM_DRAWITEM
2748         case WM_DRAWITEM:
2749         case WM_MEASUREITEM:
2750             {
2751                 int idCtrl = (UINT)wParam;
2752                 if ( message == WM_DRAWITEM )
2753                 {
2754                     processed = MSWOnDrawItem(idCtrl,
2755                                               (WXDRAWITEMSTRUCT *)lParam);
2756                 }
2757                 else
2758                 {
2759                     processed = MSWOnMeasureItem(idCtrl,
2760                                                  (WXMEASUREITEMSTRUCT *)lParam);
2761                 }
2762
2763                 if ( processed )
2764                     rc.result = TRUE;
2765             }
2766             break;
2767 #endif // defined(WM_DRAWITEM)
2768
2769         case WM_GETDLGCODE:
2770             if ( !IsOfStandardClass() )
2771             {
2772                 // we always want to get the char events
2773                 rc.result = DLGC_WANTCHARS;
2774
2775                 if ( GetWindowStyleFlag() & wxWANTS_CHARS )
2776                 {
2777                     // in fact, we want everything
2778                     rc.result |= DLGC_WANTARROWS |
2779                                  DLGC_WANTTAB |
2780                                  DLGC_WANTALLKEYS;
2781                 }
2782
2783                 processed = true;
2784             }
2785             //else: get the dlg code from the DefWindowProc()
2786             break;
2787
2788         case WM_SYSKEYDOWN:
2789         case WM_KEYDOWN:
2790             // If this has been processed by an event handler, return 0 now
2791             // (we've handled it).
2792             m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
2793             if ( m_lastKeydownProcessed )
2794             {
2795                 processed = true;
2796             }
2797
2798             if ( !processed )
2799             {
2800                 switch ( wParam )
2801                 {
2802                     // we consider these messages "not interesting" to OnChar, so
2803                     // just don't do anything more with them
2804                     case VK_SHIFT:
2805                     case VK_CONTROL:
2806                     case VK_MENU:
2807                     case VK_CAPITAL:
2808                     case VK_NUMLOCK:
2809                     case VK_SCROLL:
2810                         processed = true;
2811                         break;
2812
2813                     // avoid duplicate messages to OnChar for these ASCII keys:
2814                     // they will be translated by TranslateMessage() and received
2815                     // in WM_CHAR
2816                     case VK_ESCAPE:
2817                     case VK_SPACE:
2818                     case VK_RETURN:
2819                     case VK_BACK:
2820                     case VK_TAB:
2821                     case VK_ADD:
2822                     case VK_SUBTRACT:
2823                     case VK_MULTIPLY:
2824                     case VK_DIVIDE:
2825                     case VK_NUMPAD0:
2826                     case VK_NUMPAD1:
2827                     case VK_NUMPAD2:
2828                     case VK_NUMPAD3:
2829                     case VK_NUMPAD4:
2830                     case VK_NUMPAD5:
2831                     case VK_NUMPAD6:
2832                     case VK_NUMPAD7:
2833                     case VK_NUMPAD8:
2834                     case VK_NUMPAD9:
2835                     case VK_OEM_1:
2836                     case VK_OEM_2:
2837                     case VK_OEM_3:
2838                     case VK_OEM_4:
2839                     case VK_OEM_5:
2840                     case VK_OEM_6:
2841                     case VK_OEM_7:
2842                     case VK_OEM_PLUS:
2843                     case VK_OEM_COMMA:
2844                     case VK_OEM_MINUS:
2845                     case VK_OEM_PERIOD:
2846                         // but set processed to false, not true to still pass them
2847                         // to the control's default window proc - otherwise
2848                         // built-in keyboard handling won't work
2849                         processed = false;
2850                         break;
2851
2852 #ifdef VK_APPS
2853                     // special case of VK_APPS: treat it the same as right mouse
2854                     // click because both usually pop up a context menu
2855                     case VK_APPS:
2856                         processed = HandleMouseEvent(WM_RBUTTONDOWN, -1, -1, 0);
2857                         break;
2858 #endif // VK_APPS
2859
2860                     default:
2861                         // do generate a CHAR event
2862                         processed = HandleChar((WORD)wParam, lParam);
2863                 }
2864             }
2865             if (message == WM_SYSKEYDOWN)  // Let Windows still handle the SYSKEYs
2866                 processed = false;
2867             break;
2868
2869         case WM_SYSKEYUP:
2870         case WM_KEYUP:
2871 #ifdef VK_APPS
2872             // special case of VK_APPS: treat it the same as right mouse button
2873             if ( wParam == VK_APPS )
2874             {
2875                 processed = HandleMouseEvent(WM_RBUTTONUP, -1, -1, 0);
2876             }
2877             else
2878 #endif // VK_APPS
2879             {
2880                 processed = HandleKeyUp((WORD) wParam, lParam);
2881             }
2882             break;
2883
2884         case WM_SYSCHAR:
2885         case WM_CHAR: // Always an ASCII character
2886             if ( m_lastKeydownProcessed )
2887             {
2888                 // The key was handled in the EVT_KEY_DOWN and handling
2889                 // a key in an EVT_KEY_DOWN handler is meant, by
2890                 // design, to prevent EVT_CHARs from happening
2891                 m_lastKeydownProcessed = false;
2892                 processed = true;
2893             }
2894             else
2895             {
2896                 processed = HandleChar((WORD)wParam, lParam, true);
2897             }
2898             break;
2899
2900 #if wxUSE_HOTKEY
2901         case WM_HOTKEY:
2902             processed = HandleHotKey((WORD)wParam, lParam);
2903             break;
2904 #endif // wxUSE_HOTKEY
2905
2906         case WM_HSCROLL:
2907         case WM_VSCROLL:
2908             {
2909                 WXWORD code, pos;
2910                 WXHWND hwnd;
2911                 UnpackScroll(wParam, lParam, &code, &pos, &hwnd);
2912
2913                 processed = MSWOnScroll(message == WM_HSCROLL ? wxHORIZONTAL
2914                                                               : wxVERTICAL,
2915                                         code, pos, hwnd);
2916             }
2917             break;
2918
2919         // CTLCOLOR messages are sent by children to query the parent for their
2920         // colors
2921 #ifndef __WXMICROWIN__
2922         case WM_CTLCOLORMSGBOX:
2923         case WM_CTLCOLOREDIT:
2924         case WM_CTLCOLORLISTBOX:
2925         case WM_CTLCOLORBTN:
2926         case WM_CTLCOLORDLG:
2927         case WM_CTLCOLORSCROLLBAR:
2928         case WM_CTLCOLORSTATIC:
2929             {
2930                 WXHDC hdc;
2931                 WXHWND hwnd;
2932                 UnpackCtlColor(wParam, lParam, &hdc, &hwnd);
2933
2934                 processed = HandleCtlColor(&rc.hBrush, (WXHDC)hdc, (WXHWND)hwnd);
2935             }
2936             break;
2937 #endif // !__WXMICROWIN__
2938
2939         case WM_SYSCOLORCHANGE:
2940             // the return value for this message is ignored
2941             processed = HandleSysColorChange();
2942             break;
2943
2944 #if !defined(__WXWINCE__)
2945         case WM_DISPLAYCHANGE:
2946             processed = HandleDisplayChange();
2947             break;
2948 #endif
2949
2950         case WM_PALETTECHANGED:
2951             processed = HandlePaletteChanged((WXHWND) (HWND) wParam);
2952             break;
2953
2954         case WM_CAPTURECHANGED:
2955             processed = HandleCaptureChanged((WXHWND) (HWND) lParam);
2956             break;
2957
2958         case WM_SETTINGCHANGE:
2959             processed = HandleSettingChange(wParam, lParam);
2960             break;
2961
2962         case WM_QUERYNEWPALETTE:
2963             processed = HandleQueryNewPalette();
2964             break;
2965
2966         case WM_ERASEBKGND:
2967             processed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
2968             if ( processed )
2969             {
2970                 // we processed the message, i.e. erased the background
2971                 rc.result = TRUE;
2972             }
2973             break;
2974
2975 #if !defined(__WXWINCE__)
2976         case WM_DROPFILES:
2977             processed = HandleDropFiles(wParam);
2978             break;
2979 #endif
2980
2981         case WM_INITDIALOG:
2982             processed = HandleInitDialog((WXHWND)(HWND)wParam);
2983
2984             if ( processed )
2985             {
2986                 // we never set focus from here
2987                 rc.result = FALSE;
2988             }
2989             break;
2990
2991 #if !defined(__WXWINCE__)
2992         case WM_QUERYENDSESSION:
2993             processed = HandleQueryEndSession(lParam, &rc.allow);
2994             break;
2995
2996         case WM_ENDSESSION:
2997             processed = HandleEndSession(wParam != 0, lParam);
2998             break;
2999
3000         case WM_GETMINMAXINFO:
3001             processed = HandleGetMinMaxInfo((MINMAXINFO*)lParam);
3002             break;
3003 #endif
3004
3005         case WM_SETCURSOR:
3006             processed = HandleSetCursor((WXHWND)(HWND)wParam,
3007                                         LOWORD(lParam),     // hit test
3008                                         HIWORD(lParam));    // mouse msg
3009
3010             if ( processed )
3011             {
3012                 // returning TRUE stops the DefWindowProc() from further
3013                 // processing this message - exactly what we need because we've
3014                 // just set the cursor.
3015                 rc.result = TRUE;
3016             }
3017             break;
3018
3019 #if wxUSE_ACCESSIBILITY
3020         case WM_GETOBJECT:
3021             {
3022                 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3023                 LPARAM dwObjId = (LPARAM) (DWORD) lParam;
3024
3025                 if (dwObjId == (LPARAM)OBJID_CLIENT && GetOrCreateAccessible())
3026                 {
3027                     return LresultFromObject(IID_IAccessible, wParam, (IUnknown*) GetAccessible()->GetIAccessible());
3028                 }
3029                 break;
3030             }
3031 #endif
3032
3033 #if defined(WM_HELP)
3034         case WM_HELP:
3035             {
3036                 // by default, WM_HELP is propagated by DefWindowProc() upwards
3037                 // to the window parent but as we do it ourselves already
3038                 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3039                 // to get the other events if we process this message at all
3040                 processed = true;
3041
3042                 // WM_HELP doesn't use lParam under CE
3043 #ifndef __WXWINCE__
3044                 HELPINFO* info = (HELPINFO*) lParam;
3045                 if ( info->iContextType == HELPINFO_WINDOW )
3046                 {
3047 #endif // !__WXWINCE__
3048                     wxHelpEvent helpEvent
3049                                 (
3050                                     wxEVT_HELP,
3051                                     GetId(),
3052 #ifdef __WXWINCE__
3053                                     wxGetMousePosition() // what else?
3054 #else
3055                                     wxPoint(info->MousePos.x, info->MousePos.y)
3056 #endif
3057                                 );
3058
3059                     helpEvent.SetEventObject(this);
3060                     GetEventHandler()->ProcessEvent(helpEvent);
3061 #ifndef __WXWINCE__
3062                 }
3063                 else if ( info->iContextType == HELPINFO_MENUITEM )
3064                 {
3065                     wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId);
3066                     helpEvent.SetEventObject(this);
3067                     GetEventHandler()->ProcessEvent(helpEvent);
3068
3069                 }
3070                 else // unknown help event?
3071                 {
3072                     processed = false;
3073                 }
3074 #endif // !__WXWINCE__
3075             }
3076             break;
3077 #endif // WM_HELP
3078
3079 #if !defined(__WXWINCE__)
3080         case WM_CONTEXTMENU:
3081             {
3082                 // we don't convert from screen to client coordinates as
3083                 // the event may be handled by a parent window
3084                 wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
3085
3086                 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
3087
3088                 // we could have got an event from our child, reflect it back
3089                 // to it if this is the case
3090                 wxWindowMSW *win = NULL;
3091                 if ( (WXHWND)wParam != m_hWnd )
3092                 {
3093                     win = FindItemByHWND((WXHWND)wParam);
3094                 }
3095
3096                 if ( !win )
3097                     win = this;
3098
3099                 evtCtx.SetEventObject(win);
3100                 processed = win->GetEventHandler()->ProcessEvent(evtCtx);
3101             }
3102             break;
3103 #endif
3104
3105         case WM_MENUCHAR:
3106             // we're only interested in our own menus, not MF_SYSMENU
3107             if ( HIWORD(wParam) == MF_POPUP )
3108             {
3109                 // handle menu chars for ownerdrawn menu items
3110                 int i = HandleMenuChar(toupper(LOWORD(wParam)), lParam);
3111                 if ( i != wxNOT_FOUND )
3112                 {
3113                     rc.result = MAKELRESULT(i, MNC_EXECUTE);
3114                     processed = true;
3115                 }
3116             }
3117             break;
3118
3119 #ifndef __WXWINCE__
3120         case WM_POWERBROADCAST:
3121             {
3122                 bool vetoed;
3123                 processed = HandlePower(wParam, lParam, &vetoed);
3124                 rc.result = processed && vetoed ? BROADCAST_QUERY_DENY : TRUE;
3125             }
3126             break;
3127 #endif // __WXWINCE__
3128     }
3129
3130     if ( !processed )
3131     {
3132 #ifdef __WXDEBUG__
3133         wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
3134                    wxGetMessageName(message));
3135 #endif // __WXDEBUG__
3136         rc.result = MSWDefWindowProc(message, wParam, lParam);
3137     }
3138
3139     return rc.result;
3140 }
3141
3142 // ----------------------------------------------------------------------------
3143 // wxWindow <-> HWND map
3144 // ----------------------------------------------------------------------------
3145
3146 wxWinHashTable *wxWinHandleHash = NULL;
3147
3148 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
3149 {
3150     return (wxWindow*)wxWinHandleHash->Get((long)hWnd);
3151 }
3152
3153 void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
3154 {
3155     // adding NULL hWnd is (first) surely a result of an error and
3156     // (secondly) breaks menu command processing
3157     wxCHECK_RET( hWnd != (HWND)NULL,
3158                  wxT("attempt to add a NULL hWnd to window list ignored") );
3159
3160     wxWindow *oldWin = wxFindWinFromHandle((WXHWND) hWnd);
3161 #ifdef __WXDEBUG__
3162     if ( oldWin && (oldWin != win) )
3163     {
3164         wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3165                    (int) hWnd, win->GetClassInfo()->GetClassName());
3166     }
3167     else
3168 #endif // __WXDEBUG__
3169     if (!oldWin)
3170     {
3171         wxWinHandleHash->Put((long)hWnd, (wxWindow *)win);
3172     }
3173 }
3174
3175 void wxRemoveHandleAssociation(wxWindowMSW *win)
3176 {
3177     wxWinHandleHash->Delete((long)win->GetHWND());
3178 }
3179
3180 // ----------------------------------------------------------------------------
3181 // various MSW speciic class dependent functions
3182 // ----------------------------------------------------------------------------
3183
3184 // Default destroyer - override if you destroy it in some other way
3185 // (e.g. with MDI child windows)
3186 void wxWindowMSW::MSWDestroyWindow()
3187 {
3188 }
3189
3190 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
3191                                            const wxSize& size,
3192                                            int& x, int& y,
3193                                            int& w, int& h) const
3194 {
3195     // yes, those are just some arbitrary hardcoded numbers
3196     static const int DEFAULT_Y = 200;
3197
3198     bool nonDefault = false;
3199
3200     if ( pos.x == wxDefaultCoord )
3201     {
3202         // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3203         // can just as well set it to CW_USEDEFAULT as well
3204         x =
3205         y = CW_USEDEFAULT;
3206     }
3207     else
3208     {
3209         // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3210         // neither because it is not handled as a special value by Windows then
3211         // and so we have to choose some default value for it
3212         x = pos.x;
3213         y = pos.y == wxDefaultCoord ? DEFAULT_Y : pos.y;
3214
3215         nonDefault = true;
3216     }
3217
3218     /*
3219       NB: there used to be some code here which set the initial size of the
3220           window to the client size of the parent if no explicit size was
3221           specified. This was wrong because wxWidgets programs often assume
3222           that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3223           it. To see why, you should understand that Windows sends WM_SIZE from
3224           inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3225           from some base class ctor and so this WM_SIZE is not processed in the
3226           real class' OnSize() (because it's not fully constructed yet and the
3227           event goes to some base class OnSize() instead). So the WM_SIZE we
3228           rely on is the one sent when the parent frame resizes its children
3229           but here is the problem: if the child already has just the right
3230           size, nothing will happen as both wxWidgets and Windows check for
3231           this and ignore any attempts to change the window size to the size it
3232           already has - so no WM_SIZE would be sent.
3233      */
3234
3235
3236     // we don't use CW_USEDEFAULT here for several reasons:
3237     //
3238     //  1. it results in huge frames on modern screens (1000*800 is not
3239     //     uncommon on my 1280*1024 screen) which is way too big for a half
3240     //     empty frame of most of wxWidgets samples for example)
3241     //
3242     //  2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3243     //     the default is for whatever reason 8*8 which breaks client <->
3244     //     window size calculations (it would be nice if it didn't, but it
3245     //     does and the simplest way to fix it seemed to change the broken
3246     //     default size anyhow)
3247     //
3248     //  3. there is just no advantage in doing it: with x and y it is
3249     //     possible that [future versions of] Windows position the new top
3250     //     level window in some smart way which we can't do, but we can
3251     //     guess a reasonably good size for a new window just as well
3252     //     ourselves
3253
3254     // However, on PocketPC devices, we must use the default
3255     // size if possible.
3256 #ifdef _WIN32_WCE
3257     if (size.x == wxDefaultCoord)
3258         w = CW_USEDEFAULT;
3259     else
3260         w = size.x;
3261     if (size.y == wxDefaultCoord)
3262         h = CW_USEDEFAULT;
3263     else
3264         h = size.y;
3265 #else
3266     if ( size.x == wxDefaultCoord || size.y == wxDefaultCoord)
3267     {
3268         nonDefault = true;
3269     }
3270     w = WidthDefault(size.x);
3271     h = HeightDefault(size.y);
3272 #endif
3273
3274     AdjustForParentClientOrigin(x, y);
3275
3276     return nonDefault;
3277 }
3278
3279 WXHWND wxWindowMSW::MSWGetParent() const
3280 {
3281     return m_parent ? m_parent->GetHWND() : WXHWND(NULL);
3282 }
3283
3284 bool wxWindowMSW::MSWCreate(const wxChar *wclass,
3285                             const wxChar *title,
3286                             const wxPoint& pos,
3287                             const wxSize& size,
3288                             WXDWORD style,
3289                             WXDWORD extendedStyle)
3290 {
3291     // choose the position/size for the new window
3292     int x, y, w, h;
3293     (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
3294
3295     // controlId is menu handle for the top level windows, so set it to 0
3296     // unless we're creating a child window
3297     int controlId = style & WS_CHILD ? GetId() : 0;
3298
3299     // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3300     // which is the same but without CS_[HV]REDRAW class styles so using it
3301     // ensures that the window is not fully repainted on each resize
3302     wxString className(wclass);
3303     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
3304     {
3305         className += wxT("NR");
3306     }
3307
3308     // do create the window
3309     wxWindowCreationHook hook(this);
3310
3311     m_hWnd = (WXHWND)::CreateWindowEx
3312                        (
3313                         extendedStyle,
3314                         className,
3315                         title ? title : m_windowName.c_str(),
3316                         style,
3317                         x, y, w, h,
3318                         (HWND)MSWGetParent(),
3319                         (HMENU)controlId,
3320                         wxGetInstance(),
3321                         NULL                        // no extra data
3322                        );
3323
3324     if ( !m_hWnd )
3325     {
3326         wxLogSysError(_("Can't create window of class %s"), className.c_str());
3327
3328         return false;
3329     }
3330
3331     SubclassWin(m_hWnd);
3332
3333     return true;
3334 }
3335
3336 // ===========================================================================
3337 // MSW message handlers
3338 // ===========================================================================
3339
3340 // ---------------------------------------------------------------------------
3341 // WM_NOTIFY
3342 // ---------------------------------------------------------------------------
3343
3344 bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
3345 {
3346 #ifndef __WXMICROWIN__
3347     LPNMHDR hdr = (LPNMHDR)lParam;
3348     HWND hWnd = hdr->hwndFrom;
3349     wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
3350
3351     // if the control is one of our windows, let it handle the message itself
3352     if ( win )
3353     {
3354         return win->MSWOnNotify(idCtrl, lParam, result);
3355     }
3356
3357     // VZ: why did we do it? normally this is unnecessary and, besides, it
3358     //     breaks the message processing for the toolbars because the tooltip
3359     //     notifications were being forwarded to the toolbar child controls
3360     //     (if it had any) before being passed to the toolbar itself, so in my
3361     //     example the tooltip for the combobox was always shown instead of the
3362     //     correct button tooltips
3363 #if 0
3364     // try all our children
3365     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3366     while ( node )
3367     {
3368         wxWindow *child = node->GetData();
3369         if ( child->MSWOnNotify(idCtrl, lParam, result) )
3370         {
3371             return true;
3372         }
3373
3374         node = node->GetNext();
3375     }
3376 #endif // 0
3377
3378     // by default, handle it ourselves
3379     return MSWOnNotify(idCtrl, lParam, result);
3380 #else // __WXMICROWIN__
3381     return false;
3382 #endif
3383 }
3384
3385 #if wxUSE_TOOLTIPS
3386
3387 bool wxWindowMSW::HandleTooltipNotify(WXUINT code,
3388                                       WXLPARAM lParam,
3389                                       const wxString& ttip)
3390 {
3391     // I don't know why it happens, but the versions of comctl32.dll starting
3392     // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3393     // this message is supposed to be sent to Unicode programs only) -- hence
3394     // we need to handle it as well, otherwise no tooltips will be shown in
3395     // this case
3396 #ifndef __WXWINCE__
3397     if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW)
3398             || ttip.empty() )
3399     {
3400         // not a tooltip message or no tooltip to show anyhow
3401         return false;
3402     }
3403 #endif
3404
3405     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
3406
3407     // We don't want to use the szText buffer because it has a limit of 80
3408     // bytes and this is not enough, especially for Unicode build where it
3409     // limits the tooltip string length to only 40 characters
3410     //
3411     // The best would be, of course, to not impose any length limitations at
3412     // all but then the buffer would have to be dynamic and someone would have
3413     // to free it and we don't have the tooltip owner object here any more, so
3414     // for now use our own static buffer with a higher fixed max length.
3415     //
3416     // Note that using a static buffer should not be a problem as only a single
3417     // tooltip can be shown at the same time anyhow.
3418 #if !wxUSE_UNICODE
3419     if ( code == (WXUINT) TTN_NEEDTEXTW )
3420     {
3421         // We need to convert tooltip from multi byte to Unicode on the fly.
3422         static wchar_t buf[513];
3423
3424         // Truncate tooltip length if needed as otherwise we might not have
3425         // enough space for it in the buffer and MultiByteToWideChar() would
3426         // return an error
3427         size_t tipLength = wxMin(ttip.length(), WXSIZEOF(buf) - 1);
3428
3429         // Convert to WideChar without adding the NULL character. The NULL
3430         // character is added afterwards (this is more efficient).
3431         int len = ::MultiByteToWideChar
3432                     (
3433                         CP_ACP,
3434                         0,                      // no flags
3435                         ttip,
3436                         tipLength,
3437                         buf,
3438                         WXSIZEOF(buf) - 1
3439                     );
3440
3441         if ( !len )
3442         {
3443             wxLogLastError(_T("MultiByteToWideChar()"));
3444         }
3445
3446         buf[len] = L'\0';
3447         ttText->lpszText = (LPSTR) buf;
3448     }
3449     else // TTN_NEEDTEXTA
3450 #endif // !wxUSE_UNICODE
3451     {
3452         // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3453         // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3454         // to copy the string we have into the buffer
3455         static wxChar buf[513];
3456         wxStrncpy(buf, ttip.c_str(), WXSIZEOF(buf) - 1);
3457         buf[WXSIZEOF(buf) - 1] = _T('\0');
3458         ttText->lpszText = buf;
3459     }
3460
3461     return true;
3462 }
3463
3464 #endif // wxUSE_TOOLTIPS
3465
3466 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
3467                               WXLPARAM lParam,
3468                               WXLPARAM* WXUNUSED(result))
3469 {
3470 #if wxUSE_TOOLTIPS
3471     if ( m_tooltip )
3472     {
3473         NMHDR* hdr = (NMHDR *)lParam;
3474         if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
3475         {
3476             // processed
3477             return true;
3478         }
3479     }
3480 #else
3481     wxUnusedVar(lParam);
3482 #endif // wxUSE_TOOLTIPS
3483
3484     return false;
3485 }
3486
3487 // ---------------------------------------------------------------------------
3488 // end session messages
3489 // ---------------------------------------------------------------------------
3490
3491 bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
3492 {
3493 #ifdef ENDSESSION_LOGOFF
3494     wxCloseEvent event(wxEVT_QUERY_END_SESSION, wxID_ANY);
3495     event.SetEventObject(wxTheApp);
3496     event.SetCanVeto(true);
3497     event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
3498
3499     bool rc = wxTheApp->ProcessEvent(event);
3500
3501     if ( rc )
3502     {
3503         // we may end only if the app didn't veto session closing (double
3504         // negation...)
3505         *mayEnd = !event.GetVeto();
3506     }
3507
3508     return rc;
3509 #else
3510     wxUnusedVar(logOff);
3511     wxUnusedVar(mayEnd);
3512     return false;
3513 #endif
3514 }
3515
3516 bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
3517 {
3518 #ifdef ENDSESSION_LOGOFF
3519     // do nothing if the session isn't ending
3520     if ( !endSession )
3521         return false;
3522
3523     // only send once
3524     if ( (this != wxTheApp->GetTopWindow()) )
3525         return false;
3526
3527     wxCloseEvent event(wxEVT_END_SESSION, wxID_ANY);
3528     event.SetEventObject(wxTheApp);
3529     event.SetCanVeto(false);
3530     event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
3531
3532     return wxTheApp->ProcessEvent(event);
3533 #else
3534     wxUnusedVar(endSession);
3535     wxUnusedVar(logOff);
3536     return false;
3537 #endif
3538 }
3539
3540 // ---------------------------------------------------------------------------
3541 // window creation/destruction
3542 // ---------------------------------------------------------------------------
3543
3544 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT WXUNUSED_IN_WINCE(cs),
3545                                bool *mayCreate)
3546 {
3547     // VZ: why is this commented out for WinCE? If it doesn't support
3548     //     WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3549     //     not with multiple #ifdef's!
3550 #ifndef __WXWINCE__
3551     if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
3552         EnsureParentHasControlParentStyle(GetParent());
3553 #endif // !__WXWINCE__
3554
3555     *mayCreate = true;
3556
3557     return true;
3558 }
3559
3560 bool wxWindowMSW::HandleDestroy()
3561 {
3562     SendDestroyEvent();
3563
3564     // delete our drop target if we've got one
3565 #if wxUSE_DRAG_AND_DROP
3566     if ( m_dropTarget != NULL )
3567     {
3568         m_dropTarget->Revoke(m_hWnd);
3569
3570         delete m_dropTarget;
3571         m_dropTarget = NULL;
3572     }
3573 #endif // wxUSE_DRAG_AND_DROP
3574
3575     // WM_DESTROY handled
3576     return true;
3577 }
3578
3579 // ---------------------------------------------------------------------------
3580 // activation/focus
3581 // ---------------------------------------------------------------------------
3582
3583 bool wxWindowMSW::HandleActivate(int state,
3584                               bool WXUNUSED(minimized),
3585                               WXHWND WXUNUSED(activate))
3586 {
3587     wxActivateEvent event(wxEVT_ACTIVATE,
3588                           (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
3589                           m_windowId);
3590     event.SetEventObject(this);
3591
3592     return GetEventHandler()->ProcessEvent(event);
3593 }
3594
3595 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
3596 {
3597     // Strangly enough, some controls get set focus events when they are being
3598     // deleted, even if they already had focus before.
3599     if ( m_isBeingDeleted )
3600     {
3601         return false;
3602     }
3603
3604     // notify the parent keeping track of focus for the kbd navigation
3605     // purposes that we got it
3606     wxChildFocusEvent eventFocus((wxWindow *)this);
3607     (void)GetEventHandler()->ProcessEvent(eventFocus);
3608
3609 #if wxUSE_CARET
3610     // Deal with caret
3611     if ( m_caret )
3612     {
3613         m_caret->OnSetFocus();
3614     }
3615 #endif // wxUSE_CARET
3616
3617 #if wxUSE_TEXTCTRL
3618     // If it's a wxTextCtrl don't send the event as it will be done
3619     // after the control gets to process it from EN_FOCUS handler
3620     if ( wxDynamicCastThis(wxTextCtrl) )
3621     {
3622         return false;
3623     }
3624 #endif // wxUSE_TEXTCTRL
3625
3626     wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
3627     event.SetEventObject(this);
3628
3629     // wxFindWinFromHandle() may return NULL, it is ok
3630     event.SetWindow(wxFindWinFromHandle(hwnd));
3631
3632     return GetEventHandler()->ProcessEvent(event);
3633 }
3634
3635 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
3636 {
3637 #if wxUSE_CARET
3638     // Deal with caret
3639     if ( m_caret )
3640     {
3641         m_caret->OnKillFocus();
3642     }
3643 #endif // wxUSE_CARET
3644
3645 #if wxUSE_TEXTCTRL
3646     // If it's a wxTextCtrl don't send the event as it will be done
3647     // after the control gets to process it.
3648     wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
3649     if ( ctrl )
3650     {
3651         return false;
3652     }
3653 #endif
3654
3655     // Don't send the event when in the process of being deleted.  This can
3656     // only cause problems if the event handler tries to access the object.
3657     if ( m_isBeingDeleted )
3658     {
3659         return false;
3660     }
3661
3662     wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
3663     event.SetEventObject(this);
3664
3665     // wxFindWinFromHandle() may return NULL, it is ok
3666     event.SetWindow(wxFindWinFromHandle(hwnd));
3667
3668     return GetEventHandler()->ProcessEvent(event);
3669 }
3670
3671 // ---------------------------------------------------------------------------
3672 // labels
3673 // ---------------------------------------------------------------------------
3674
3675 void wxWindowMSW::SetLabel( const wxString& label)
3676 {
3677     SetWindowText(GetHwnd(), label.c_str());
3678 }
3679
3680 wxString wxWindowMSW::GetLabel() const
3681 {
3682     return wxGetWindowText(GetHWND());
3683 }
3684
3685 // ---------------------------------------------------------------------------
3686 // miscellaneous
3687 // ---------------------------------------------------------------------------
3688
3689 bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
3690 {
3691     wxShowEvent event(GetId(), show);
3692     event.SetEventObject(this);
3693
3694     return GetEventHandler()->ProcessEvent(event);
3695 }
3696
3697 bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
3698 {
3699     wxInitDialogEvent event(GetId());
3700     event.SetEventObject(this);
3701
3702     return GetEventHandler()->ProcessEvent(event);
3703 }
3704
3705 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
3706 {
3707 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3708     wxUnusedVar(wParam);
3709     return false;
3710 #else // __WXMICROWIN__
3711     HDROP hFilesInfo = (HDROP) wParam;
3712
3713     // Get the total number of files dropped
3714     UINT gwFilesDropped = ::DragQueryFile
3715                             (
3716                                 (HDROP)hFilesInfo,
3717                                 (UINT)-1,
3718                                 (LPTSTR)0,
3719                                 (UINT)0
3720                             );
3721
3722     wxString *files = new wxString[gwFilesDropped];
3723     for ( UINT wIndex = 0; wIndex < gwFilesDropped; wIndex++ )
3724     {
3725         // first get the needed buffer length (+1 for terminating NUL)
3726         size_t len = ::DragQueryFile(hFilesInfo, wIndex, NULL, 0) + 1;
3727
3728         // and now get the file name
3729         ::DragQueryFile(hFilesInfo, wIndex,
3730                         wxStringBuffer(files[wIndex], len), len);
3731     }
3732     DragFinish (hFilesInfo);
3733
3734     wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
3735     event.SetEventObject(this);
3736
3737     POINT dropPoint;
3738     DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
3739     event.m_pos.x = dropPoint.x;
3740     event.m_pos.y = dropPoint.y;
3741
3742     return GetEventHandler()->ProcessEvent(event);
3743 #endif
3744 }
3745
3746
3747 bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
3748                                   short nHitTest,
3749                                   int WXUNUSED(mouseMsg))
3750 {
3751 #ifndef __WXMICROWIN__
3752     // the logic is as follows:
3753     // -1. don't set cursor for non client area, including but not limited to
3754     //     the title bar, scrollbars, &c
3755     //  0. allow the user to override default behaviour by using EVT_SET_CURSOR
3756     //  1. if we have the cursor set it unless wxIsBusy()
3757     //  2. if we're a top level window, set some cursor anyhow
3758     //  3. if wxIsBusy(), set the busy cursor, otherwise the global one
3759
3760     if ( nHitTest != HTCLIENT )
3761     {
3762         return false;
3763     }
3764
3765     HCURSOR hcursor = 0;
3766
3767     // first ask the user code - it may wish to set the cursor in some very
3768     // specific way (for example, depending on the current position)
3769     POINT pt;
3770 #ifdef __WXWINCE__
3771     if ( !::GetCursorPosWinCE(&pt))
3772 #else
3773     if ( !::GetCursorPos(&pt) )
3774 #endif
3775     {
3776         wxLogLastError(wxT("GetCursorPos"));
3777     }
3778
3779     int x = pt.x,
3780         y = pt.y;
3781     ScreenToClient(&x, &y);
3782     wxSetCursorEvent event(x, y);
3783
3784     bool processedEvtSetCursor = GetEventHandler()->ProcessEvent(event);
3785     if ( processedEvtSetCursor && event.HasCursor() )
3786     {
3787         hcursor = GetHcursorOf(event.GetCursor());
3788     }
3789
3790     if ( !hcursor )
3791     {
3792         bool isBusy = wxIsBusy();
3793
3794         // the test for processedEvtSetCursor is here to prevent using m_cursor
3795         // if the user code caught EVT_SET_CURSOR() and returned nothing from
3796         // it - this is a way to say that our cursor shouldn't be used for this
3797         // point
3798         if ( !processedEvtSetCursor && m_cursor.Ok() )
3799         {
3800             hcursor = GetHcursorOf(m_cursor);
3801         }
3802
3803         if ( !GetParent() )
3804         {
3805             if ( isBusy )
3806             {
3807                 hcursor = wxGetCurrentBusyCursor();
3808             }
3809             else if ( !hcursor )
3810             {
3811                 const wxCursor *cursor = wxGetGlobalCursor();
3812                 if ( cursor && cursor->Ok() )
3813                 {
3814                     hcursor = GetHcursorOf(*cursor);
3815                 }
3816             }
3817         }
3818     }
3819
3820     if ( hcursor )
3821     {
3822 //        wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3823
3824         ::SetCursor(hcursor);
3825
3826         // cursor set, stop here
3827         return true;
3828     }
3829 #endif // __WXMICROWIN__
3830
3831     // pass up the window chain
3832     return false;
3833 }
3834
3835 bool wxWindowMSW::HandlePower(WXWPARAM WXUNUSED_IN_WINCE(wParam),
3836                               WXLPARAM WXUNUSED(lParam),
3837                               bool *WXUNUSED_IN_WINCE(vetoed))
3838 {
3839 #ifdef __WXWINCE__
3840     // FIXME
3841     return false;
3842 #else
3843     wxEventType evtType;
3844     switch ( wParam )
3845     {
3846         case PBT_APMQUERYSUSPEND:
3847             evtType = wxEVT_POWER_SUSPENDING;
3848             break;
3849
3850         case PBT_APMQUERYSUSPENDFAILED:
3851             evtType = wxEVT_POWER_SUSPEND_CANCEL;
3852             break;
3853
3854         case PBT_APMSUSPEND:
3855             evtType = wxEVT_POWER_SUSPENDED;
3856             break;
3857
3858         case PBT_APMRESUMESUSPEND:
3859 #ifdef PBT_APMRESUMEAUTOMATIC
3860         case PBT_APMRESUMEAUTOMATIC:
3861 #endif
3862             evtType = wxEVT_POWER_RESUME;
3863             break;
3864
3865         default:
3866             wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam);
3867             // fall through
3868
3869         // these messages are currently not mapped to wx events
3870         case PBT_APMQUERYSTANDBY:
3871         case PBT_APMQUERYSTANDBYFAILED:
3872         case PBT_APMSTANDBY:
3873         case PBT_APMRESUMESTANDBY:
3874         case PBT_APMBATTERYLOW:
3875         case PBT_APMPOWERSTATUSCHANGE:
3876         case PBT_APMOEMEVENT:
3877         case PBT_APMRESUMECRITICAL:
3878             evtType = wxEVT_NULL;
3879             break;
3880     }
3881
3882     // don't handle unknown messages
3883     if ( evtType == wxEVT_NULL )
3884         return false;
3885
3886     // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
3887
3888     wxPowerEvent event(evtType);
3889     if ( !GetEventHandler()->ProcessEvent(event) )
3890         return false;
3891
3892     *vetoed = event.IsVetoed();
3893
3894     return true;
3895 #endif
3896 }
3897
3898 // ---------------------------------------------------------------------------
3899 // owner drawn stuff
3900 // ---------------------------------------------------------------------------
3901
3902 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3903         (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3904     #define WXUNUSED_UNLESS_ODRAWN(param) param
3905 #else
3906     #define WXUNUSED_UNLESS_ODRAWN(param)
3907 #endif
3908
3909 bool
3910 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
3911                            WXDRAWITEMSTRUCT * WXUNUSED_UNLESS_ODRAWN(itemStruct))
3912 {
3913 #if wxUSE_OWNER_DRAWN
3914
3915 #if wxUSE_MENUS_NATIVE
3916     // is it a menu item?
3917     DRAWITEMSTRUCT *pDrawStruct = (DRAWITEMSTRUCT *)itemStruct;
3918     if ( id == 0 && pDrawStruct->CtlType == ODT_MENU )
3919     {
3920         wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
3921
3922         // see comment before the same test in MSWOnMeasureItem() below
3923         if ( !pMenuItem )
3924             return false;
3925
3926         wxCHECK_MSG( wxDynamicCast(pMenuItem, wxMenuItem),
3927                          false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3928
3929         // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3930         // the DC from being released
3931         wxDCTemp dc((WXHDC)pDrawStruct->hDC);
3932         wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
3933                     pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
3934                     pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
3935
3936         return pMenuItem->OnDrawItem
3937                (
3938                 dc,
3939                 rect,
3940                 (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
3941                 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
3942                );
3943     }
3944 #endif // wxUSE_MENUS_NATIVE
3945
3946 #endif // USE_OWNER_DRAWN
3947
3948 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3949
3950 #if wxUSE_OWNER_DRAWN
3951     wxControl *item = wxDynamicCast(FindItem(id), wxControl);
3952 #else // !wxUSE_OWNER_DRAWN
3953     // we may still have owner-drawn buttons internally because we have to make
3954     // them owner-drawn to support colour change
3955     wxControl *item =
3956 #                     if wxUSE_BUTTON
3957                          wxDynamicCast(FindItem(id), wxButton)
3958 #                     else
3959                          NULL
3960 #                     endif
3961                     ;
3962 #endif // USE_OWNER_DRAWN
3963
3964     if ( item )
3965     {
3966         return item->MSWOnDraw(itemStruct);
3967     }
3968
3969 #endif // wxUSE_CONTROLS
3970
3971     return false;
3972 }
3973
3974 bool
3975 wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
3976 {
3977 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3978     // is it a menu item?
3979     MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
3980     if ( id == 0 && pMeasureStruct->CtlType == ODT_MENU )
3981     {
3982         wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
3983
3984         // according to Carsten Fuchs the pointer may be NULL under XP if an
3985         // MDI child frame is initially maximized, see this for more info:
3986         // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
3987         //
3988         // so silently ignore it instead of asserting
3989         if ( !pMenuItem )
3990             return false;
3991
3992         wxCHECK_MSG( wxDynamicCast(pMenuItem, wxMenuItem),
3993                         false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3994
3995         size_t w, h;
3996         bool rc = pMenuItem->OnMeasureItem(&w, &h);
3997
3998         pMeasureStruct->itemWidth = w;
3999         pMeasureStruct->itemHeight = h;
4000
4001         return rc;
4002     }
4003
4004     wxControl *item = wxDynamicCast(FindItem(id), wxControl);
4005     if ( item )
4006     {
4007         return item->MSWOnMeasure(itemStruct);
4008     }
4009 #else
4010     wxUnusedVar(id);
4011     wxUnusedVar(itemStruct);
4012 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4013
4014     return false;
4015 }
4016
4017 // ---------------------------------------------------------------------------
4018 // colours and palettes
4019 // ---------------------------------------------------------------------------
4020
4021 bool wxWindowMSW::HandleSysColorChange()
4022 {
4023     wxSysColourChangedEvent event;
4024     event.SetEventObject(this);
4025
4026     (void)GetEventHandler()->ProcessEvent(event);
4027
4028     // always let the system carry on the default processing to allow the
4029     // native controls to react to the colours update
4030     return false;
4031 }
4032
4033 bool wxWindowMSW::HandleDisplayChange()
4034 {
4035     wxDisplayChangedEvent event;
4036     event.SetEventObject(this);
4037
4038     return GetEventHandler()->ProcessEvent(event);
4039 }
4040
4041 #ifndef __WXMICROWIN__
4042
4043 bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush, WXHDC hDC, WXHWND hWnd)
4044 {
4045 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4046     wxUnusedVar(hDC);
4047     wxUnusedVar(hWnd);
4048 #else
4049     wxControl *item = wxDynamicCast(FindItemByHWND(hWnd, true), wxControl);
4050
4051     if ( item )
4052         *brush = item->MSWControlColor(hDC, hWnd);
4053     else
4054 #endif // wxUSE_CONTROLS
4055         *brush = NULL;
4056
4057     return *brush != NULL;
4058 }
4059
4060 #endif // __WXMICROWIN__
4061
4062 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
4063 {
4064 #if wxUSE_PALETTE
4065     // same as below except we don't respond to our own messages
4066     if ( hWndPalChange != GetHWND() )
4067     {
4068         // check to see if we our our parents have a custom palette
4069         wxWindowMSW *win = this;
4070         while ( win && !win->HasCustomPalette() )
4071         {
4072             win = win->GetParent();
4073         }
4074
4075         if ( win && win->HasCustomPalette() )
4076         {
4077             // realize the palette to see whether redrawing is needed
4078             HDC hdc = ::GetDC((HWND) hWndPalChange);
4079             win->m_palette.SetHPALETTE((WXHPALETTE)
4080                     ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
4081
4082             int result = ::RealizePalette(hdc);
4083
4084             // restore the palette (before releasing the DC)
4085             win->m_palette.SetHPALETTE((WXHPALETTE)
4086                     ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
4087             ::RealizePalette(hdc);
4088             ::ReleaseDC((HWND) hWndPalChange, hdc);
4089
4090             // now check for the need to redraw
4091             if (result > 0)
4092                 ::InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
4093         }
4094
4095     }
4096 #endif // wxUSE_PALETTE
4097
4098     wxPaletteChangedEvent event(GetId());
4099     event.SetEventObject(this);
4100     event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
4101
4102     return GetEventHandler()->ProcessEvent(event);
4103 }
4104
4105 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture)
4106 {
4107     wxMouseCaptureChangedEvent event(GetId(), wxFindWinFromHandle(hWndGainedCapture));
4108     event.SetEventObject(this);
4109
4110     return GetEventHandler()->ProcessEvent(event);
4111 }
4112
4113 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam)
4114 {
4115     // despite MSDN saying "(This message cannot be sent directly to a window.)"
4116     // we need to send this to child windows (it is only sent to top-level
4117     // windows) so {list,tree}ctrls can adjust their font size if necessary
4118     // this is exactly how explorer does it to enable the font size changes
4119
4120     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
4121     while ( node )
4122     {
4123         // top-level windows already get this message from the system
4124         wxWindow *win = node->GetData();
4125         if ( !win->IsTopLevel() )
4126         {
4127             ::SendMessage(GetHwndOf(win), WM_SETTINGCHANGE, wParam, lParam);
4128         }
4129
4130         node = node->GetNext();
4131     }
4132
4133     // let the system handle it
4134     return false;
4135 }
4136
4137 bool wxWindowMSW::HandleQueryNewPalette()
4138 {
4139
4140 #if wxUSE_PALETTE
4141     // check to see if we our our parents have a custom palette
4142     wxWindowMSW *win = this;
4143     while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
4144     if (win->HasCustomPalette()) {
4145         /* realize the palette to see whether redrawing is needed */
4146         HDC hdc = ::GetDC((HWND) GetHWND());
4147         win->m_palette.SetHPALETTE( (WXHPALETTE)
4148              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
4149
4150         int result = ::RealizePalette(hdc);
4151         /* restore the palette (before releasing the DC) */
4152         win->m_palette.SetHPALETTE( (WXHPALETTE)
4153              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), TRUE) );
4154         ::RealizePalette(hdc);
4155         ::ReleaseDC((HWND) GetHWND(), hdc);
4156         /* now check for the need to redraw */
4157         if (result > 0)
4158             ::InvalidateRect((HWND) GetHWND(), NULL, TRUE);
4159         }
4160 #endif // wxUSE_PALETTE
4161
4162     wxQueryNewPaletteEvent event(GetId());
4163     event.SetEventObject(this);
4164
4165     return GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
4166 }
4167
4168 // Responds to colour changes: passes event on to children.
4169 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
4170 {
4171     // the top level window also reset the standard colour map as it might have
4172     // changed (there is no need to do it for the non top level windows as we
4173     // only have to do it once)
4174     if ( IsTopLevel() )
4175     {
4176         // FIXME-MT
4177         gs_hasStdCmap = false;
4178     }
4179     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
4180     while ( node )
4181     {
4182         // Only propagate to non-top-level windows because Windows already
4183         // sends this event to all top-level ones
4184         wxWindow *win = node->GetData();
4185         if ( !win->IsTopLevel() )
4186         {
4187             // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4188             // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4189             // the standard controls
4190             ::SendMessage(GetHwndOf(win), WM_SYSCOLORCHANGE, 0, 0);
4191         }
4192
4193         node = node->GetNext();
4194     }
4195 }
4196
4197 extern wxCOLORMAP *wxGetStdColourMap()
4198 {
4199     static COLORREF s_stdColours[wxSTD_COL_MAX];
4200     static wxCOLORMAP s_cmap[wxSTD_COL_MAX];
4201
4202     if ( !gs_hasStdCmap )
4203     {
4204         static bool s_coloursInit = false;
4205
4206         if ( !s_coloursInit )
4207         {
4208             // When a bitmap is loaded, the RGB values can change (apparently
4209             // because Windows adjusts them to care for the old programs always
4210             // using 0xc0c0c0 while the transparent colour for the new Windows
4211             // versions is different). But we do this adjustment ourselves so
4212             // we want to avoid Windows' "help" and for this we need to have a
4213             // reference bitmap which can tell us what the RGB values change
4214             // to.
4215             wxLogNull logNo; // suppress error if we couldn't load the bitmap
4216             wxBitmap stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4217             if ( stdColourBitmap.Ok() )
4218             {
4219                 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4220                 wxASSERT_MSG( stdColourBitmap.GetWidth() == wxSTD_COL_MAX,
4221                               _T("forgot to update wxBITMAP_STD_COLOURS!") );
4222
4223                 wxMemoryDC memDC;
4224                 memDC.SelectObject(stdColourBitmap);
4225
4226                 wxColour colour;
4227                 for ( size_t i = 0; i < WXSIZEOF(s_stdColours); i++ )
4228                 {
4229                     memDC.GetPixel(i, 0, &colour);
4230                     s_stdColours[i] = wxColourToRGB(colour);
4231                 }
4232             }
4233             else // wxBITMAP_STD_COLOURS couldn't be loaded
4234             {
4235                 s_stdColours[0] = RGB(000,000,000);     // black
4236                 s_stdColours[1] = RGB(128,128,128);     // dark grey
4237                 s_stdColours[2] = RGB(192,192,192);     // light grey
4238                 s_stdColours[3] = RGB(255,255,255);     // white
4239                 //s_stdColours[4] = RGB(000,000,255);     // blue
4240                 //s_stdColours[5] = RGB(255,000,255);     // magenta
4241             }
4242
4243             s_coloursInit = true;
4244         }
4245
4246         gs_hasStdCmap = true;
4247
4248         // create the colour map
4249 #define INIT_CMAP_ENTRY(col) \
4250             s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4251             s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4252
4253         INIT_CMAP_ENTRY(BTNTEXT);
4254         INIT_CMAP_ENTRY(BTNSHADOW);
4255         INIT_CMAP_ENTRY(BTNFACE);
4256         INIT_CMAP_ENTRY(BTNHIGHLIGHT);
4257
4258 #undef INIT_CMAP_ENTRY
4259     }
4260
4261     return s_cmap;
4262 }
4263
4264 // ---------------------------------------------------------------------------
4265 // painting
4266 // ---------------------------------------------------------------------------
4267
4268 bool wxWindowMSW::HandlePaint()
4269 {
4270     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4271     if ( !hRegion )
4272         wxLogLastError(wxT("CreateRectRgn"));
4273     if ( ::GetUpdateRgn(GetHwnd(), hRegion, FALSE) == ERROR )
4274         wxLogLastError(wxT("GetUpdateRgn"));
4275
4276     m_updateRegion = wxRegion((WXHRGN) hRegion);
4277
4278     wxPaintEvent event(m_windowId);
4279     event.SetEventObject(this);
4280
4281     bool processed = GetEventHandler()->ProcessEvent(event);
4282
4283     // note that we must generate NC event after the normal one as otherwise
4284     // BeginPaint() will happily overwrite our decorations with the background
4285     // colour
4286     wxNcPaintEvent eventNc(m_windowId);
4287     eventNc.SetEventObject(this);
4288     GetEventHandler()->ProcessEvent(eventNc);
4289
4290     return processed;
4291 }
4292
4293 // Can be called from an application's OnPaint handler
4294 void wxWindowMSW::OnPaint(wxPaintEvent& event)
4295 {
4296 #ifdef __WXUNIVERSAL__
4297     event.Skip();
4298 #else
4299     HDC hDC = (HDC) wxPaintDC::FindDCInCache((wxWindow*) event.GetEventObject());
4300     if (hDC != 0)
4301     {
4302         MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
4303     }
4304 #endif
4305 }
4306
4307 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
4308 {
4309     wxDCTemp dc(hdc);
4310
4311     dc.SetHDC(hdc);
4312     dc.SetWindow((wxWindow *)this);
4313
4314     wxEraseEvent event(m_windowId, &dc);
4315     event.SetEventObject(this);
4316     bool rc = GetEventHandler()->ProcessEvent(event);
4317
4318     // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4319     dc.SelectOldObjects(hdc);
4320
4321     return rc;
4322 }
4323
4324 void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
4325 {
4326     // standard non top level controls (i.e. except the dialogs) always erase
4327     // their background themselves in HandleCtlColor() or have some control-
4328     // specific ways to set the colours (common controls)
4329     if ( IsOfStandardClass() && !IsTopLevel() )
4330     {
4331         event.Skip();
4332         return;
4333     }
4334
4335     if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM )
4336     {
4337         // don't skip the event here, custom background means that the app
4338         // is drawing it itself in its OnPaint(), so don't draw it at all
4339         // now to avoid flicker
4340         return;
4341     }
4342
4343
4344     // do default background painting
4345     if ( !DoEraseBackground(GetHdcOf(*event.GetDC())) )
4346     {
4347         // let the system paint the background
4348         event.Skip();
4349     }
4350 }
4351
4352 bool wxWindowMSW::DoEraseBackground(WXHDC hDC)
4353 {
4354     HBRUSH hbr = (HBRUSH)MSWGetBgBrush(hDC);
4355     if ( !hbr )
4356         return false;
4357
4358     wxFillRect(GetHwnd(), (HDC)hDC, hbr);
4359
4360     return true;
4361 }
4362
4363 WXHBRUSH
4364 wxWindowMSW::MSWGetBgBrushForChild(WXHDC WXUNUSED(hDC), WXHWND hWnd)
4365 {
4366     if ( m_hasBgCol )
4367     {
4368         // our background colour applies to:
4369         //  1. this window itself, always
4370         //  2. all children unless the colour is "not inheritable"
4371         //  3. even if it is not inheritable, our immediate transparent
4372         //     children should still inherit it -- but not any transparent
4373         //     children because it would look wrong if a child of non
4374         //     transparent child would show our bg colour when the child itself
4375         //     does not
4376         wxWindow *win = wxFindWinFromHandle(hWnd);
4377         if ( win == this ||
4378                 m_inheritBgCol ||
4379                     (win && win->HasTransparentBackground() &&
4380                         win->GetParent() == this) )
4381         {
4382             // draw children with the same colour as the parent
4383             wxBrush *
4384                 brush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour());
4385
4386             return (WXHBRUSH)GetHbrushOf(*brush);
4387         }
4388     }
4389
4390     return 0;
4391 }
4392
4393 WXHBRUSH wxWindowMSW::MSWGetBgBrush(WXHDC hDC, WXHWND hWndToPaint)
4394 {
4395     if ( !hWndToPaint )
4396         hWndToPaint = GetHWND();
4397
4398     for ( wxWindowMSW *win = this; win; win = win->GetParent() )
4399     {
4400         WXHBRUSH hBrush = win->MSWGetBgBrushForChild(hDC, hWndToPaint);
4401         if ( hBrush )
4402             return hBrush;
4403
4404         // background is not inherited beyond top level windows
4405         if ( win->IsTopLevel() )
4406             break;
4407     }
4408
4409     return 0;
4410 }
4411
4412 bool wxWindowMSW::HandlePrintClient(WXHDC hDC)
4413 {
4414     // we receive this message when DrawThemeParentBackground() is
4415     // called from def window proc of several controls under XP and we
4416     // must draw properly themed background here
4417     //
4418     // note that naively I'd expect filling the client rect with the
4419     // brush returned by MSWGetBgBrush() work -- but for some reason it
4420     // doesn't and we have to call parents MSWPrintChild() which is
4421     // supposed to call DrawThemeBackground() with appropriate params
4422     //
4423     // also note that in this case lParam == PRF_CLIENT but we're
4424     // clearly expected to paint the background and nothing else!
4425
4426     if ( IsTopLevel() || InheritsBackgroundColour() )
4427         return false;
4428
4429     // sometimes we don't want the parent to handle it at all, instead
4430     // return whatever value this window wants
4431     if ( !MSWShouldPropagatePrintChild() )
4432         return MSWPrintChild(hDC, (wxWindow *)this);
4433
4434     for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
4435     {
4436         if ( win->MSWPrintChild(hDC, (wxWindow *)this) )
4437             return true;
4438
4439         if ( win->IsTopLevel() || win->InheritsBackgroundColour() )
4440             break;
4441     }
4442
4443     return false;
4444 }
4445
4446 // ---------------------------------------------------------------------------
4447 // moving and resizing
4448 // ---------------------------------------------------------------------------
4449
4450 bool wxWindowMSW::HandleMinimize()
4451 {
4452     wxIconizeEvent event(m_windowId);
4453     event.SetEventObject(this);
4454
4455     return GetEventHandler()->ProcessEvent(event);
4456 }
4457
4458 bool wxWindowMSW::HandleMaximize()
4459 {
4460     wxMaximizeEvent event(m_windowId);
4461     event.SetEventObject(this);
4462
4463     return GetEventHandler()->ProcessEvent(event);
4464 }
4465
4466 bool wxWindowMSW::HandleMove(int x, int y)
4467 {
4468     wxPoint point(x,y);
4469     wxMoveEvent event(point, m_windowId);
4470     event.SetEventObject(this);
4471
4472     return GetEventHandler()->ProcessEvent(event);
4473 }
4474
4475 bool wxWindowMSW::HandleMoving(wxRect& rect)
4476 {
4477     wxMoveEvent event(rect, m_windowId);
4478     event.SetEventObject(this);
4479
4480     bool rc = GetEventHandler()->ProcessEvent(event);
4481     if (rc)
4482         rect = event.GetRect();
4483     return rc;
4484 }
4485
4486 bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h), WXUINT wParam)
4487 {
4488 #if USE_DEFERRED_SIZING
4489     // when we resize this window, its children are probably going to be
4490     // repositioned as well, prepare to use DeferWindowPos() for them
4491     int numChildren = 0;
4492     for ( HWND child = ::GetWindow(GetHwndOf(this), GW_CHILD);
4493           child;
4494           child = ::GetWindow(child, GW_HWNDNEXT) )
4495     {
4496         numChildren ++;
4497     }
4498
4499     // Protect against valid m_hDWP being overwritten
4500     bool useDefer = false;
4501
4502     if ( numChildren > 1 )
4503     {
4504         if (!m_hDWP)
4505         {
4506             m_hDWP = (WXHANDLE)::BeginDeferWindowPos(numChildren);
4507             if ( !m_hDWP )
4508             {
4509                 wxLogLastError(_T("BeginDeferWindowPos"));
4510             }
4511             if (m_hDWP)
4512                 useDefer = true;
4513         }
4514     }
4515 #endif // USE_DEFERRED_SIZING
4516
4517     // update this window size
4518     bool processed = false;
4519     switch ( wParam )
4520     {
4521         default:
4522             wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4523             // fall through nevertheless
4524
4525         case SIZE_MAXHIDE:
4526         case SIZE_MAXSHOW:
4527             // we're not interested in these messages at all
4528             break;
4529
4530         case SIZE_MINIMIZED:
4531             processed = HandleMinimize();
4532             break;
4533
4534         case SIZE_MAXIMIZED:
4535             /* processed = */ HandleMaximize();
4536             // fall through to send a normal size event as well
4537
4538         case SIZE_RESTORED:
4539             // don't use w and h parameters as they specify the client size
4540             // while according to the docs EVT_SIZE handler is supposed to
4541             // receive the total size
4542             wxSizeEvent event(GetSize(), m_windowId);
4543             event.SetEventObject(this);
4544
4545             processed = GetEventHandler()->ProcessEvent(event);
4546     }
4547
4548 #if USE_DEFERRED_SIZING
4549     // and finally change the positions of all child windows at once
4550     if ( useDefer && m_hDWP )
4551     {
4552         // reset m_hDWP to NULL so that child windows don't try to use our
4553         // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4554         // happen anyhow normally but who knows what weird flow of control we
4555         // may have depending on what the users EVT_SIZE handler does...)
4556         HDWP hDWP = (HDWP)m_hDWP;
4557         m_hDWP = NULL;
4558
4559         // do put all child controls in place at once
4560         if ( !::EndDeferWindowPos(hDWP) )
4561         {
4562             wxLogLastError(_T("EndDeferWindowPos"));
4563         }
4564
4565         // Reset our children's pending pos/size values.
4566         for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
4567               node;
4568               node = node->GetNext() )
4569         {
4570             wxWindowMSW *child = node->GetData();
4571             child->m_pendingPosition = wxDefaultPosition;
4572             child->m_pendingSize = wxDefaultSize;
4573         }
4574     }
4575 #endif // USE_DEFERRED_SIZING
4576
4577     return processed;
4578 }
4579
4580 bool wxWindowMSW::HandleSizing(wxRect& rect)
4581 {
4582     wxSizeEvent event(rect, m_windowId);
4583     event.SetEventObject(this);
4584
4585     bool rc = GetEventHandler()->ProcessEvent(event);
4586     if (rc)
4587         rect = event.GetRect();
4588     return rc;
4589 }
4590
4591 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo))
4592 {
4593 #ifdef __WXWINCE__
4594     return false;
4595 #else
4596     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
4597
4598     bool rc = false;
4599
4600     int minWidth = GetMinWidth(),
4601         minHeight = GetMinHeight(),
4602         maxWidth = GetMaxWidth(),
4603         maxHeight = GetMaxHeight();
4604
4605     if ( minWidth != wxDefaultCoord )
4606     {
4607         info->ptMinTrackSize.x = minWidth;
4608         rc = true;
4609     }
4610
4611     if ( minHeight != wxDefaultCoord )
4612     {
4613         info->ptMinTrackSize.y = minHeight;
4614         rc = true;
4615     }
4616
4617     if ( maxWidth != wxDefaultCoord )
4618     {
4619         info->ptMaxTrackSize.x = maxWidth;
4620         rc = true;
4621     }
4622
4623     if ( maxHeight != wxDefaultCoord )
4624     {
4625         info->ptMaxTrackSize.y = maxHeight;
4626         rc = true;
4627     }
4628
4629     return rc;
4630 #endif
4631 }
4632
4633 // ---------------------------------------------------------------------------
4634 // command messages
4635 // ---------------------------------------------------------------------------
4636
4637 bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
4638 {
4639 #if wxUSE_MENUS_NATIVE
4640     if ( !cmd && wxCurrentPopupMenu )
4641     {
4642         wxMenu *popupMenu = wxCurrentPopupMenu;
4643         wxCurrentPopupMenu = NULL;
4644
4645         return popupMenu->MSWCommand(cmd, id);
4646     }
4647 #endif // wxUSE_MENUS_NATIVE
4648
4649     wxWindow *win = NULL;
4650
4651     // first try to find it from HWND - this works even with the broken
4652     // programs using the same ids for different controls
4653     if ( control )
4654     {
4655         win = wxFindWinFromHandle(control);
4656     }
4657
4658     // try the id
4659     if ( !win )
4660     {
4661         // must cast to a signed type before comparing with other ids!
4662         win = FindItem((signed short)id);
4663     }
4664
4665     if ( win )
4666     {
4667         return win->MSWCommand(cmd, id);
4668     }
4669
4670     // the messages sent from the in-place edit control used by the treectrl
4671     // for label editing have id == 0, but they should _not_ be treated as menu
4672     // messages (they are EN_XXX ones, in fact) so don't translate anything
4673     // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4674     if ( !control )
4675     {
4676         // If no child window, it may be an accelerator, e.g. for a popup menu
4677         // command
4678
4679         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
4680         event.SetEventObject(this);
4681         event.SetId(id);
4682         event.SetInt(id);
4683
4684         return GetEventHandler()->ProcessEvent(event);
4685     }
4686     else
4687     {
4688 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4689         // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4690         // notifications to its parent which we want to reflect back to
4691         // wxSpinCtrl
4692         wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
4693         if ( spin && spin->ProcessTextCommand(cmd, id) )
4694             return true;
4695 #endif // wxUSE_SPINCTRL
4696
4697 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
4698         // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
4699         // notifications to its parent which we want to reflect back to
4700         // wxChoice
4701         wxChoice *choice = wxChoice::GetChoiceForListBox(control);
4702         if ( choice && choice->MSWCommand(cmd, id) )
4703             return true;
4704 #endif
4705     }
4706
4707     return false;
4708 }
4709
4710 // ---------------------------------------------------------------------------
4711 // mouse events
4712 // ---------------------------------------------------------------------------
4713
4714 void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
4715                                  int x, int y,
4716                                  WXUINT flags)
4717 {
4718     // our client coords are not quite the same as Windows ones
4719     wxPoint pt = GetClientAreaOrigin();
4720     event.m_x = x - pt.x;
4721     event.m_y = y - pt.y;
4722
4723     event.m_shiftDown = (flags & MK_SHIFT) != 0;
4724     event.m_controlDown = (flags & MK_CONTROL) != 0;
4725     event.m_leftDown = (flags & MK_LBUTTON) != 0;
4726     event.m_middleDown = (flags & MK_MBUTTON) != 0;
4727     event.m_rightDown = (flags & MK_RBUTTON) != 0;
4728     event.m_altDown = ::GetKeyState(VK_MENU) < 0;
4729
4730 #ifndef __WXWINCE__
4731     event.SetTimestamp(::GetMessageTime());
4732 #endif
4733
4734     event.SetEventObject(this);
4735     event.SetId(GetId());
4736
4737 #if wxUSE_MOUSEEVENT_HACK
4738     gs_lastMouseEvent.pos = ClientToScreen(wxPoint(x, y));
4739     gs_lastMouseEvent.type = event.GetEventType();
4740 #endif // wxUSE_MOUSEEVENT_HACK
4741 }
4742
4743 #ifdef __WXWINCE__
4744 // Windows doesn't send the mouse events to the static controls (which are
4745 // transparent in the sense that their WM_NCHITTEST handler returns
4746 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4747 // and so we manually check if we don't have a child window under mouse and if
4748 // we do, send the event to it instead of the window Windows had sent WM_XXX
4749 // to.
4750 //
4751 // Notice that this is not done for the mouse move events because this could
4752 // (would?) be too slow, but only for clicks which means that the static texts
4753 // still don't get move, enter nor leave events.
4754 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y)
4755 {
4756     wxCHECK_MSG( x && y, win, _T("NULL pointer in FindWindowForMouseEvent") );
4757
4758     // first try to find a non transparent child: this allows us to send events
4759     // to a static text which is inside a static box, for example
4760     POINT pt = { *x, *y };
4761     HWND hwnd = GetHwndOf(win),
4762          hwndUnderMouse;
4763
4764 #ifdef __WXWINCE__
4765     hwndUnderMouse = ::ChildWindowFromPoint
4766                        (
4767                         hwnd,
4768                         pt
4769                        );
4770 #else
4771     hwndUnderMouse = ::ChildWindowFromPointEx
4772                        (
4773                         hwnd,
4774                         pt,
4775                         CWP_SKIPINVISIBLE   |
4776                         CWP_SKIPDISABLED    |
4777                         CWP_SKIPTRANSPARENT
4778                        );
4779 #endif
4780
4781     if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
4782     {
4783         // now try any child window at all
4784         hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
4785     }
4786
4787     // check that we have a child window which is susceptible to receive mouse
4788     // events: for this it must be shown and enabled
4789     if ( hwndUnderMouse &&
4790             hwndUnderMouse != hwnd &&
4791                 ::IsWindowVisible(hwndUnderMouse) &&
4792                     ::IsWindowEnabled(hwndUnderMouse) )
4793     {
4794         wxWindow *winUnderMouse = wxFindWinFromHandle((WXHWND)hwndUnderMouse);
4795         if ( winUnderMouse )
4796         {
4797             // translate the mouse coords to the other window coords
4798             win->ClientToScreen(x, y);
4799             winUnderMouse->ScreenToClient(x, y);
4800
4801             win = winUnderMouse;
4802         }
4803     }
4804
4805     return win;
4806 }
4807 #endif // __WXWINCE__
4808
4809 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
4810 {
4811     // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4812     // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4813     // from the message id and take the value in the table to get wxWin event
4814     // id
4815     static const wxEventType eventsMouse[] =
4816     {
4817         wxEVT_MOTION,
4818         wxEVT_LEFT_DOWN,
4819         wxEVT_LEFT_UP,
4820         wxEVT_LEFT_DCLICK,
4821         wxEVT_RIGHT_DOWN,
4822         wxEVT_RIGHT_UP,
4823         wxEVT_RIGHT_DCLICK,
4824         wxEVT_MIDDLE_DOWN,
4825         wxEVT_MIDDLE_UP,
4826         wxEVT_MIDDLE_DCLICK
4827     };
4828
4829     wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
4830     InitMouseEvent(event, x, y, flags);
4831
4832     return GetEventHandler()->ProcessEvent(event);
4833 }
4834
4835 bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
4836 {
4837     if ( !m_mouseInWindow )
4838     {
4839         // it would be wrong to assume that just because we get a mouse move
4840         // event that the mouse is inside the window: although this is usually
4841         // true, it is not if we had captured the mouse, so we need to check
4842         // the mouse coordinates here
4843         if ( !HasCapture() || IsMouseInWindow() )
4844         {
4845             // Generate an ENTER event
4846             m_mouseInWindow = true;
4847
4848 #ifdef HAVE_TRACKMOUSEEVENT
4849             WinStruct<TRACKMOUSEEVENT> trackinfo;
4850
4851             trackinfo.dwFlags = TME_LEAVE;
4852             trackinfo.hwndTrack = GetHwnd();
4853
4854             // Use the commctrl.h _TrackMouseEvent(), which will call the real
4855             // TrackMouseEvent() if available or emulate it
4856             _TrackMouseEvent(&trackinfo);
4857 #endif // HAVE_TRACKMOUSEEVENT
4858
4859             wxMouseEvent event(wxEVT_ENTER_WINDOW);
4860             InitMouseEvent(event, x, y, flags);
4861
4862             (void)GetEventHandler()->ProcessEvent(event);
4863         }
4864     }
4865 #ifdef HAVE_TRACKMOUSEEVENT
4866     else
4867     {
4868         // Check if we need to send a LEAVE event
4869         // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
4870         // send it here if we are using native mouse leave tracking
4871         if ( HasCapture() && !IsMouseInWindow() )
4872         {
4873             GenerateMouseLeave();
4874         }
4875     }
4876 #endif // HAVE_TRACKMOUSEEVENT
4877
4878 #if wxUSE_MOUSEEVENT_HACK
4879     // Windows often generates mouse events even if mouse position hasn't
4880     // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
4881     //
4882     // Filter this out as it can result in unexpected behaviour compared to
4883     // other platforms
4884     if ( gs_lastMouseEvent.type == wxEVT_RIGHT_DOWN ||
4885          gs_lastMouseEvent.type == wxEVT_LEFT_DOWN ||
4886          gs_lastMouseEvent.type == wxEVT_MIDDLE_DOWN ||
4887          gs_lastMouseEvent.type == wxEVT_MOTION )
4888     {
4889         if ( ClientToScreen(wxPoint(x, y)) == gs_lastMouseEvent.pos )
4890         {
4891             gs_lastMouseEvent.type = wxEVT_MOTION;
4892
4893             return false;
4894         }
4895     }
4896 #endif // wxUSE_MOUSEEVENT_HACK
4897
4898     return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
4899 }
4900
4901
4902 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
4903 {
4904 #if wxUSE_MOUSEWHEEL
4905     // notice that WM_MOUSEWHEEL position is in screen coords (as it's
4906     // forwarded up to the parent by DefWindowProc()) and not in the client
4907     // ones as all the other messages, translate them to the client coords for
4908     // consistency
4909     const wxPoint
4910         pt = ScreenToClient(wxPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));
4911     wxMouseEvent event(wxEVT_MOUSEWHEEL);
4912     InitMouseEvent(event, pt.x, pt.y, LOWORD(wParam));
4913     event.m_wheelRotation = (short)HIWORD(wParam);
4914     event.m_wheelDelta = WHEEL_DELTA;
4915
4916     static int s_linesPerRotation = -1;
4917     if ( s_linesPerRotation == -1 )
4918     {
4919         if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
4920                                      &s_linesPerRotation, 0))
4921         {
4922             // this is not supposed to happen
4923             wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4924
4925             // the default is 3, so use it if SystemParametersInfo() failed
4926             s_linesPerRotation = 3;
4927         }
4928     }
4929
4930     event.m_linesPerAction = s_linesPerRotation;
4931     return GetEventHandler()->ProcessEvent(event);
4932
4933 #else // !wxUSE_MOUSEWHEEL
4934     wxUnusedVar(wParam);
4935     wxUnusedVar(lParam);
4936
4937     return false;
4938 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
4939 }
4940
4941 void wxWindowMSW::GenerateMouseLeave()
4942 {
4943     m_mouseInWindow = false;
4944
4945     int state = 0;
4946     if ( wxIsShiftDown() )
4947         state |= MK_SHIFT;
4948     if ( wxIsCtrlDown() )
4949         state |= MK_CONTROL;
4950
4951     // Only the high-order bit should be tested
4952     if ( GetKeyState( VK_LBUTTON ) & (1<<15) )
4953         state |= MK_LBUTTON;
4954     if ( GetKeyState( VK_MBUTTON ) & (1<<15) )
4955         state |= MK_MBUTTON;
4956     if ( GetKeyState( VK_RBUTTON ) & (1<<15) )
4957         state |= MK_RBUTTON;
4958
4959     POINT pt;
4960 #ifdef __WXWINCE__
4961     if ( !::GetCursorPosWinCE(&pt) )
4962 #else
4963     if ( !::GetCursorPos(&pt) )
4964 #endif
4965     {
4966         wxLogLastError(_T("GetCursorPos"));
4967     }
4968
4969     // we need to have client coordinates here for symmetry with
4970     // wxEVT_ENTER_WINDOW
4971     RECT rect = wxGetWindowRect(GetHwnd());
4972     pt.x -= rect.left;
4973     pt.y -= rect.top;
4974
4975     wxMouseEvent event(wxEVT_LEAVE_WINDOW);
4976     InitMouseEvent(event, pt.x, pt.y, state);
4977
4978     (void)GetEventHandler()->ProcessEvent(event);
4979 }
4980
4981 // ---------------------------------------------------------------------------
4982 // keyboard handling
4983 // ---------------------------------------------------------------------------
4984
4985 // create the key event of the given type for the given key - used by
4986 // HandleChar and HandleKeyDown/Up
4987 wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
4988                                        int id,
4989                                        WXLPARAM lParam,
4990                                        WXWPARAM wParam) const
4991 {
4992     wxKeyEvent event(evType);
4993     event.SetId(GetId());
4994     event.m_shiftDown = wxIsShiftDown();
4995     event.m_controlDown = wxIsCtrlDown();
4996     event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
4997
4998     event.SetEventObject((wxWindow *)this); // const_cast
4999     event.m_keyCode = id;
5000 #if wxUSE_UNICODE
5001     event.m_uniChar = (wxChar) wParam;
5002 #endif
5003     event.m_rawCode = (wxUint32) wParam;
5004     event.m_rawFlags = (wxUint32) lParam;
5005 #ifndef __WXWINCE__
5006     event.SetTimestamp(::GetMessageTime());
5007 #endif
5008
5009     // translate the position to client coords
5010     POINT pt;
5011 #ifdef __WXWINCE__
5012     GetCursorPosWinCE(&pt);
5013 #else
5014     GetCursorPos(&pt);
5015 #endif
5016     RECT rect;
5017     GetWindowRect(GetHwnd(),&rect);
5018     pt.x -= rect.left;
5019     pt.y -= rect.top;
5020
5021     event.m_x = pt.x;
5022     event.m_y = pt.y;
5023
5024     return event;
5025 }
5026
5027 // isASCII is true only when we're called from WM_CHAR handler and not from
5028 // WM_KEYDOWN one
5029 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
5030 {
5031     int id;
5032     if ( isASCII )
5033     {
5034         id = wParam;
5035     }
5036     else // we're called from WM_KEYDOWN
5037     {
5038         // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5039         // to get numpad key codes: CHAR events should use the logical keys
5040         // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5041         id = wxCharCodeMSWToWX(wParam);
5042         if ( id == 0 )
5043         {
5044             // it's ASCII and will be processed here only when called from
5045             // WM_CHAR (i.e. when isASCII = true), don't process it now
5046             return false;
5047         }
5048     }
5049
5050     wxKeyEvent event(CreateKeyEvent(wxEVT_CHAR, id, lParam, wParam));
5051
5052     // the alphanumeric keys produced by pressing AltGr+something on European
5053     // keyboards have both Ctrl and Alt modifiers which may confuse the user
5054     // code as, normally, keys with Ctrl and/or Alt don't result in anything
5055     // alphanumeric, so pretend that there are no modifiers at all (the
5056     // KEY_DOWN event would still have the correct modifiers if they're really
5057     // needed)
5058     if ( event.m_controlDown && event.m_altDown &&
5059             (id >= 32 && id < 256) )
5060     {
5061         event.m_controlDown =
5062         event.m_altDown = false;
5063     }
5064
5065     return GetEventHandler()->ProcessEvent(event);
5066 }
5067
5068 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
5069 {
5070     int id = wxCharCodeMSWToWX(wParam, lParam);
5071
5072     if ( !id )
5073     {
5074         // normal ASCII char
5075         id = wParam;
5076     }
5077
5078     wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
5079     return GetEventHandler()->ProcessEvent(event);
5080 }
5081
5082 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
5083 {
5084     int id = wxCharCodeMSWToWX(wParam, lParam);
5085
5086     if ( !id )
5087     {
5088         // normal ASCII char
5089         id = wParam;
5090     }
5091
5092     wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
5093     return GetEventHandler()->ProcessEvent(event);
5094 }
5095
5096 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel),
5097                                 WXLPARAM WXUNUSED_IN_WINCE(lParam))
5098 {
5099     // FIXME: implement GetMenuItemCount for WinCE, possibly
5100     // in terms of GetMenuItemInfo
5101 #ifndef __WXWINCE__
5102     const HMENU hmenu = (HMENU)lParam;
5103
5104     MENUITEMINFO mii;
5105     wxZeroMemory(mii);
5106     mii.cbSize = sizeof(MENUITEMINFO);
5107
5108     // we could use MIIM_FTYPE here as we only need to know if the item is
5109     // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5110     // MIIM_FTYPE is not supported under Win95
5111     mii.fMask = MIIM_TYPE | MIIM_DATA;
5112
5113     // find if we have this letter in any owner drawn item
5114     const int count = ::GetMenuItemCount(hmenu);
5115     for ( int i = 0; i < count; i++ )
5116     {
5117         // previous loop iteration could modify it, reset it back before
5118         // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5119         mii.cch = 0;
5120
5121         if ( ::GetMenuItemInfo(hmenu, i, TRUE, &mii) )
5122         {
5123             if ( mii.fType == MFT_OWNERDRAW )
5124             {
5125                 //  dwItemData member of the MENUITEMINFO is a
5126                 //  pointer to the associated wxMenuItem -- see the
5127                 //  menu creation code
5128                 wxMenuItem *item = (wxMenuItem*)mii.dwItemData;
5129
5130                 const wxChar *p = wxStrchr(item->GetText(), _T('&'));
5131                 while ( p++ )
5132                 {
5133                     if ( *p == _T('&') )
5134                     {
5135                         // this is not the accel char, find the real one
5136                         p = wxStrchr(p + 1, _T('&'));
5137                     }
5138                     else // got the accel char
5139                     {
5140                         // FIXME-UNICODE: this comparison doesn't risk to work
5141                         // for non ASCII accelerator characters I'm afraid, but
5142                         // what can we do?
5143                         if ( (wchar_t)wxToupper(*p) == (wchar_t)chAccel )
5144                         {
5145                             return i;
5146                         }
5147                         else
5148                         {
5149                             // this one doesn't match
5150                             break;
5151                         }
5152                     }
5153                 }
5154             }
5155         }
5156         else // failed to get the menu text?
5157         {
5158             // it's not fatal, so don't show error, but still log it
5159             wxLogLastError(_T("GetMenuItemInfo"));
5160         }
5161     }
5162 #endif
5163     return wxNOT_FOUND;
5164 }
5165
5166 bool wxWindowMSW::HandleClipboardEvent( WXUINT nMsg )
5167 {
5168     const wxEventType type = ( nMsg == WM_CUT ) ? wxEVT_COMMAND_TEXT_CUT :
5169                              ( nMsg == WM_COPY ) ? wxEVT_COMMAND_TEXT_COPY :
5170                            /*( nMsg == WM_PASTE ) ? */ wxEVT_COMMAND_TEXT_PASTE;
5171     wxClipboardTextEvent evt(type, GetId());
5172
5173     evt.SetEventObject(this);
5174
5175     return GetEventHandler()->ProcessEvent(evt);
5176 }
5177
5178 // ---------------------------------------------------------------------------
5179 // joystick
5180 // ---------------------------------------------------------------------------
5181
5182 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
5183 {
5184 #ifdef JOY_BUTTON1
5185     int change = 0;
5186     if ( flags & JOY_BUTTON1CHG )
5187         change = wxJOY_BUTTON1;
5188     if ( flags & JOY_BUTTON2CHG )
5189         change = wxJOY_BUTTON2;
5190     if ( flags & JOY_BUTTON3CHG )
5191         change = wxJOY_BUTTON3;
5192     if ( flags & JOY_BUTTON4CHG )
5193         change = wxJOY_BUTTON4;
5194
5195     int buttons = 0;
5196     if ( flags & JOY_BUTTON1 )
5197         buttons |= wxJOY_BUTTON1;
5198     if ( flags & JOY_BUTTON2 )
5199         buttons |= wxJOY_BUTTON2;
5200     if ( flags & JOY_BUTTON3 )
5201         buttons |= wxJOY_BUTTON3;
5202     if ( flags & JOY_BUTTON4 )
5203         buttons |= wxJOY_BUTTON4;
5204
5205     // the event ids aren't consecutive so we can't use table based lookup
5206     int joystick;
5207     wxEventType eventType;
5208     switch ( msg )
5209     {
5210         case MM_JOY1MOVE:
5211             joystick = 1;
5212             eventType = wxEVT_JOY_MOVE;
5213             break;
5214
5215         case MM_JOY2MOVE:
5216             joystick = 2;
5217             eventType = wxEVT_JOY_MOVE;
5218             break;
5219
5220         case MM_JOY1ZMOVE:
5221             joystick = 1;
5222             eventType = wxEVT_JOY_ZMOVE;
5223             break;
5224
5225         case MM_JOY2ZMOVE:
5226             joystick = 2;
5227             eventType = wxEVT_JOY_ZMOVE;
5228             break;
5229
5230         case MM_JOY1BUTTONDOWN:
5231             joystick = 1;
5232             eventType = wxEVT_JOY_BUTTON_DOWN;
5233             break;
5234
5235         case MM_JOY2BUTTONDOWN:
5236             joystick = 2;
5237             eventType = wxEVT_JOY_BUTTON_DOWN;
5238             break;
5239
5240         case MM_JOY1BUTTONUP:
5241             joystick = 1;
5242             eventType = wxEVT_JOY_BUTTON_UP;
5243             break;
5244
5245         case MM_JOY2BUTTONUP:
5246             joystick = 2;
5247             eventType = wxEVT_JOY_BUTTON_UP;
5248             break;
5249
5250         default:
5251             wxFAIL_MSG(wxT("no such joystick event"));
5252
5253             return false;
5254     }
5255
5256     wxJoystickEvent event(eventType, buttons, joystick, change);
5257     event.SetPosition(wxPoint(x, y));
5258     event.SetEventObject(this);
5259
5260     return GetEventHandler()->ProcessEvent(event);
5261 #else
5262     wxUnusedVar(msg);
5263     wxUnusedVar(x);
5264     wxUnusedVar(y);
5265     wxUnusedVar(flags);
5266     return false;
5267 #endif
5268 }
5269
5270 // ---------------------------------------------------------------------------
5271 // scrolling
5272 // ---------------------------------------------------------------------------
5273
5274 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
5275                               WXWORD pos, WXHWND control)
5276 {
5277     if ( control && control != m_hWnd ) // Prevent infinite recursion
5278     {
5279         wxWindow *child = wxFindWinFromHandle(control);
5280         if ( child )
5281             return child->MSWOnScroll(orientation, wParam, pos, control);
5282     }
5283
5284     wxScrollWinEvent event;
5285     event.SetPosition(pos);
5286     event.SetOrientation(orientation);
5287     event.SetEventObject(this);
5288
5289     switch ( wParam )
5290     {
5291     case SB_TOP:
5292         event.SetEventType(wxEVT_SCROLLWIN_TOP);
5293         break;
5294
5295     case SB_BOTTOM:
5296         event.SetEventType(wxEVT_SCROLLWIN_BOTTOM);
5297         break;
5298
5299     case SB_LINEUP:
5300         event.SetEventType(wxEVT_SCROLLWIN_LINEUP);
5301         break;
5302
5303     case SB_LINEDOWN:
5304         event.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);
5305         break;
5306
5307     case SB_PAGEUP:
5308         event.SetEventType(wxEVT_SCROLLWIN_PAGEUP);
5309         break;
5310
5311     case SB_PAGEDOWN:
5312         event.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);
5313         break;
5314
5315     case SB_THUMBPOSITION:
5316     case SB_THUMBTRACK:
5317         // under Win32, the scrollbar range and position are 32 bit integers,
5318         // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5319         // explicitly query the scrollbar for the correct position (this must
5320         // be done only for these two SB_ events as they are the only one
5321         // carrying the scrollbar position)
5322         {
5323             WinStruct<SCROLLINFO> scrollInfo;
5324             scrollInfo.fMask = SIF_TRACKPOS;
5325
5326             if ( !::GetScrollInfo(GetHwnd(),
5327                                   orientation == wxHORIZONTAL ? SB_HORZ
5328                                                               : SB_VERT,
5329                                   &scrollInfo) )
5330             {
5331                 // Not necessarily an error, if there are no scrollbars yet.
5332                 // wxLogLastError(_T("GetScrollInfo"));
5333             }
5334
5335             event.SetPosition(scrollInfo.nTrackPos);
5336         }
5337
5338         event.SetEventType( wParam == SB_THUMBPOSITION
5339                                 ? wxEVT_SCROLLWIN_THUMBRELEASE
5340                                 : wxEVT_SCROLLWIN_THUMBTRACK );
5341         break;
5342
5343     default:
5344         return false;
5345     }
5346
5347     return GetEventHandler()->ProcessEvent(event);
5348 }
5349
5350 // ===========================================================================
5351 // global functions
5352 // ===========================================================================
5353
5354 void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font)
5355 {
5356     TEXTMETRIC tm;
5357     HDC dc = ::GetDC((HWND) wnd);
5358     HFONT was = 0;
5359
5360     //    the_font.UseResource();
5361     //    the_font.RealizeResource();
5362     HFONT fnt = (HFONT)the_font.GetResourceHandle(); // const_cast
5363     if ( fnt )
5364         was = (HFONT) SelectObject(dc,fnt);
5365
5366     GetTextMetrics(dc, &tm);
5367     if ( fnt && was )
5368     {
5369         SelectObject(dc,was);
5370     }
5371     ReleaseDC((HWND)wnd, dc);
5372
5373     if ( x )
5374         *x = tm.tmAveCharWidth;
5375     if ( y )
5376         *y = tm.tmHeight + tm.tmExternalLeading;
5377
5378     //   the_font.ReleaseResource();
5379 }
5380
5381 // use the "extended" bit (24) of lParam to distinguish extended keys
5382 // from normal keys as the same key is sent
5383 static inline
5384 int ChooseNormalOrExtended(int lParam, int keyNormal, int keyExtended)
5385 {
5386     // except that if lParam is 0, it means we don't have real lParam from
5387     // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5388     // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5389     // non-numpad (hence extended) key as this is a more common case
5390     return !lParam || (lParam & (1 << 24)) ? keyExtended : keyNormal;
5391 }
5392
5393 // this array contains the Windows virtual key codes which map one to one to
5394 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5395 //
5396 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5397 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5398 static const struct wxKeyMapping
5399 {
5400     int vk;
5401     wxKeyCode wxk;
5402 } gs_specialKeys[] =
5403 {
5404     { VK_CANCEL,        WXK_CANCEL },
5405     { VK_BACK,          WXK_BACK },
5406     { VK_TAB,           WXK_TAB },
5407     { VK_CLEAR,         WXK_CLEAR },
5408     { VK_SHIFT,         WXK_SHIFT },
5409     { VK_CONTROL,       WXK_CONTROL },
5410     { VK_MENU ,         WXK_ALT },
5411     { VK_PAUSE,         WXK_PAUSE },
5412     { VK_CAPITAL,       WXK_CAPITAL },
5413     { VK_SPACE,         WXK_SPACE },
5414     { VK_ESCAPE,        WXK_ESCAPE },
5415     { VK_SELECT,        WXK_SELECT },
5416     { VK_PRINT,         WXK_PRINT },
5417     { VK_EXECUTE,       WXK_EXECUTE },
5418     { VK_SNAPSHOT,      WXK_SNAPSHOT },
5419     { VK_HELP,          WXK_HELP },
5420
5421     { VK_NUMPAD0,       WXK_NUMPAD0 },
5422     { VK_NUMPAD1,       WXK_NUMPAD1 },
5423     { VK_NUMPAD2,       WXK_NUMPAD2 },
5424     { VK_NUMPAD3,       WXK_NUMPAD3 },
5425     { VK_NUMPAD4,       WXK_NUMPAD4 },
5426     { VK_NUMPAD5,       WXK_NUMPAD5 },
5427     { VK_NUMPAD6,       WXK_NUMPAD6 },
5428     { VK_NUMPAD7,       WXK_NUMPAD7 },
5429     { VK_NUMPAD8,       WXK_NUMPAD8 },
5430     { VK_NUMPAD9,       WXK_NUMPAD9 },
5431     { VK_MULTIPLY,      WXK_NUMPAD_MULTIPLY },
5432     { VK_ADD,           WXK_NUMPAD_ADD },
5433     { VK_SUBTRACT,      WXK_NUMPAD_SUBTRACT },
5434     { VK_DECIMAL,       WXK_NUMPAD_DECIMAL },
5435     { VK_DIVIDE,        WXK_NUMPAD_DIVIDE },
5436
5437     { VK_F1,            WXK_F1 },
5438     { VK_F2,            WXK_F2 },
5439     { VK_F3,            WXK_F3 },
5440     { VK_F4,            WXK_F4 },
5441     { VK_F5,            WXK_F5 },
5442     { VK_F6,            WXK_F6 },
5443     { VK_F7,            WXK_F7 },
5444     { VK_F8,            WXK_F8 },
5445     { VK_F9,            WXK_F9 },
5446     { VK_F10,           WXK_F10 },
5447     { VK_F11,           WXK_F11 },
5448     { VK_F12,           WXK_F12 },
5449     { VK_F13,           WXK_F13 },
5450     { VK_F14,           WXK_F14 },
5451     { VK_F15,           WXK_F15 },
5452     { VK_F16,           WXK_F16 },
5453     { VK_F17,           WXK_F17 },
5454     { VK_F18,           WXK_F18 },
5455     { VK_F19,           WXK_F19 },
5456     { VK_F20,           WXK_F20 },
5457     { VK_F21,           WXK_F21 },
5458     { VK_F22,           WXK_F22 },
5459     { VK_F23,           WXK_F23 },
5460     { VK_F24,           WXK_F24 },
5461
5462     { VK_NUMLOCK,       WXK_NUMLOCK },
5463     { VK_SCROLL,        WXK_SCROLL },
5464
5465 #ifdef VK_APPS
5466     { VK_LWIN,          WXK_WINDOWS_LEFT },
5467     { VK_RWIN,          WXK_WINDOWS_RIGHT },
5468     { VK_APPS,          WXK_WINDOWS_MENU },
5469 #endif // VK_APPS defined
5470 };
5471
5472 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5473 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5474 int wxCharCodeMSWToWX(int vk, WXLPARAM lParam)
5475 {
5476     // check the table first
5477     for ( size_t n = 0; n < WXSIZEOF(gs_specialKeys); n++ )
5478     {
5479         if ( gs_specialKeys[n].vk == vk )
5480             return gs_specialKeys[n].wxk;
5481     }
5482
5483     // keys requiring special handling
5484     int wxk;
5485     switch ( vk )
5486     {
5487         // the mapping for these keys may be incorrect on non-US keyboards so
5488         // maybe we shouldn't map them to ASCII values at all
5489         case VK_OEM_1:      wxk = ';'; break;
5490         case VK_OEM_PLUS:   wxk = '+'; break;
5491         case VK_OEM_COMMA:  wxk = ','; break;
5492         case VK_OEM_MINUS:  wxk = '-'; break;
5493         case VK_OEM_PERIOD: wxk = '.'; break;
5494         case VK_OEM_2:      wxk = '/'; break;
5495         case VK_OEM_3:      wxk = '~'; break;
5496         case VK_OEM_4:      wxk = '['; break;
5497         case VK_OEM_5:      wxk = '\\'; break;
5498         case VK_OEM_6:      wxk = ']'; break;
5499         case VK_OEM_7:      wxk = '\''; break;
5500
5501         // handle extended keys
5502         case VK_PRIOR:
5503             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_PAGEUP, WXK_PAGEUP);
5504             break;
5505
5506         case VK_NEXT:
5507             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_PAGEDOWN, WXK_PAGEDOWN);
5508             break;
5509
5510         case VK_END:
5511             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_END, WXK_END);
5512             break;
5513
5514         case VK_HOME:
5515             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_HOME, WXK_HOME);
5516             break;
5517
5518         case VK_LEFT:
5519             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_LEFT, WXK_LEFT);
5520             break;
5521
5522         case VK_UP:
5523             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_UP, WXK_UP);
5524             break;
5525
5526         case VK_RIGHT:
5527             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_RIGHT, WXK_RIGHT);
5528             break;
5529
5530         case VK_DOWN:
5531             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_DOWN, WXK_DOWN);
5532             break;
5533
5534         case VK_INSERT:
5535             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_INSERT, WXK_INSERT);
5536             break;
5537
5538         case VK_DELETE:
5539             wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_DELETE, WXK_DELETE);
5540             break;
5541
5542         case VK_RETURN:
5543             // don't use ChooseNormalOrExtended() here as the keys are reversed
5544             // here: numpad enter is the extended one
5545             wxk = lParam && (lParam & (1 << 24)) ? WXK_NUMPAD_ENTER : WXK_RETURN;
5546             break;
5547
5548         default:
5549             wxk = 0;
5550     }
5551
5552     return wxk;
5553 }
5554
5555 WXWORD wxCharCodeWXToMSW(int wxk, bool *isVirtual)
5556 {
5557     if ( isVirtual )
5558         *isVirtual = true;
5559
5560     // check the table first
5561     for ( size_t n = 0; n < WXSIZEOF(gs_specialKeys); n++ )
5562     {
5563         if ( gs_specialKeys[n].wxk == wxk )
5564             return gs_specialKeys[n].vk;
5565     }
5566
5567     // and then check for special keys not included in the table
5568     WXWORD vk;
5569     switch ( wxk )
5570     {
5571         case WXK_PAGEUP:
5572         case WXK_NUMPAD_PAGEUP:
5573             vk = VK_PRIOR;
5574             break;
5575
5576         case WXK_PAGEDOWN:
5577         case WXK_NUMPAD_PAGEDOWN:
5578             vk = VK_NEXT;
5579             break;
5580
5581         case WXK_END:
5582         case WXK_NUMPAD_END:
5583             vk = VK_END;
5584             break;
5585
5586         case WXK_HOME:
5587         case WXK_NUMPAD_HOME:
5588             vk = VK_HOME;
5589             break;
5590
5591         case WXK_LEFT:
5592         case WXK_NUMPAD_LEFT:
5593             vk = VK_LEFT;
5594             break;
5595
5596         case WXK_UP:
5597         case WXK_NUMPAD_UP:
5598             vk = VK_UP;
5599             break;
5600
5601         case WXK_RIGHT:
5602         case WXK_NUMPAD_RIGHT:
5603             vk = VK_RIGHT;
5604             break;
5605
5606         case WXK_DOWN:
5607         case WXK_NUMPAD_DOWN:
5608             vk = VK_DOWN;
5609             break;
5610
5611         case WXK_INSERT:
5612         case WXK_NUMPAD_INSERT:
5613             vk = VK_INSERT;
5614             break;
5615
5616         case WXK_DELETE:
5617         case WXK_NUMPAD_DELETE:
5618             vk = VK_DELETE;
5619             break;
5620
5621         default:
5622             if ( isVirtual )
5623                 *isVirtual = false;
5624             vk = (WXWORD)wxk;
5625             break;
5626     }
5627
5628     return vk;
5629 }
5630
5631 // small helper for wxGetKeyState() and wxGetMouseState()
5632 static inline bool wxIsKeyDown(WXWORD vk)
5633 {
5634     // the low order bit indicates whether the key was pressed since the last
5635     // call and the high order one indicates whether it is down right now and
5636     // we only want that one
5637     return (::GetAsyncKeyState(vk) & (1<<15)) != 0;
5638 }
5639
5640 bool wxGetKeyState(wxKeyCode key)
5641 {
5642     // although this does work under Windows, it is not supported under other
5643     // platforms so don't allow it, you must use wxGetMouseState() instead
5644     wxASSERT_MSG( key != VK_LBUTTON &&
5645                     key != VK_RBUTTON &&
5646                         key != VK_MBUTTON,
5647                     wxT("can't use wxGetKeyState() for mouse buttons") );
5648
5649     const WXWORD vk = wxCharCodeWXToMSW(key);
5650
5651     // if the requested key is a LED key, return true if the led is pressed
5652     if ( key == WXK_NUMLOCK || key == WXK_CAPITAL || key == WXK_SCROLL )
5653     {
5654         // low order bit means LED is highlighted and high order one means the
5655         // key is down; for compatibility with the other ports return true if
5656         // either one is set
5657         return ::GetKeyState(vk) != 0;
5658
5659     }
5660     else // normal key
5661     {
5662         return wxIsKeyDown(vk);
5663     }
5664 }
5665
5666
5667 wxMouseState wxGetMouseState()
5668 {
5669     wxMouseState ms;
5670     POINT pt;
5671     GetCursorPos( &pt );
5672
5673     ms.SetX(pt.x);
5674     ms.SetY(pt.y);
5675     ms.SetLeftDown(wxIsKeyDown(VK_LBUTTON));
5676     ms.SetMiddleDown(wxIsKeyDown(VK_MBUTTON));
5677     ms.SetRightDown(wxIsKeyDown(VK_RBUTTON));
5678
5679     ms.SetControlDown(wxIsKeyDown(VK_CONTROL));
5680     ms.SetShiftDown(wxIsKeyDown(VK_SHIFT));
5681     ms.SetAltDown(wxIsKeyDown(VK_MENU));
5682 //    ms.SetMetaDown();
5683
5684     return ms;
5685 }
5686
5687
5688 wxWindow *wxGetActiveWindow()
5689 {
5690     HWND hWnd = GetActiveWindow();
5691     if ( hWnd != 0 )
5692     {
5693         return wxFindWinFromHandle((WXHWND) hWnd);
5694     }
5695     return NULL;
5696 }
5697
5698 extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
5699 {
5700     HWND hwnd = (HWND)hWnd;
5701
5702     // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5703     // by code in msw/radiobox.cpp), for all the others we just search up the
5704     // window hierarchy
5705     wxWindow *win = (wxWindow *)NULL;
5706     if ( hwnd )
5707     {
5708         win = wxFindWinFromHandle((WXHWND)hwnd);
5709         if ( !win )
5710         {
5711 #if wxUSE_RADIOBOX
5712             // native radiobuttons return DLGC_RADIOBUTTON here and for any
5713             // wxWindow class which overrides WM_GETDLGCODE processing to
5714             // do it as well, win would be already non NULL
5715             if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
5716             {
5717                 win = (wxWindow *)wxGetWindowUserData(hwnd);
5718             }
5719             //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5720 #endif // wxUSE_RADIOBOX
5721
5722             // spin control text buddy window should be mapped to spin ctrl
5723             // itself so try it too
5724 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5725             if ( !win )
5726             {
5727                 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
5728             }
5729 #endif // wxUSE_SPINCTRL
5730         }
5731     }
5732
5733     while ( hwnd && !win )
5734     {
5735         // this is a really ugly hack needed to avoid mistakenly returning the
5736         // parent frame wxWindow for the find/replace modeless dialog HWND -
5737         // this, in turn, is needed to call IsDialogMessage() from
5738         // wxApp::ProcessMessage() as for this we must return NULL from here
5739         //
5740         // FIXME: this is clearly not the best way to do it but I think we'll
5741         //        need to change HWND <-> wxWindow code more heavily than I can
5742         //        do it now to fix it
5743 #ifndef __WXMICROWIN__
5744         if ( ::GetWindow(hwnd, GW_OWNER) )
5745         {
5746             // it's a dialog box, don't go upwards
5747             break;
5748         }
5749 #endif
5750
5751         hwnd = ::GetParent(hwnd);
5752         win = wxFindWinFromHandle((WXHWND)hwnd);
5753     }
5754
5755     return win;
5756 }
5757
5758 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5759
5760 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5761 // in active frames and dialogs, regardless of where the focus is.
5762 static HHOOK wxTheKeyboardHook = 0;
5763 static FARPROC wxTheKeyboardHookProc = 0;
5764 int APIENTRY _EXPORT
5765 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
5766
5767 void wxSetKeyboardHook(bool doIt)
5768 {
5769     if ( doIt )
5770     {
5771         wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
5772         wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
5773
5774             GetCurrentThreadId()
5775         //      (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5776             );
5777     }
5778     else
5779     {
5780         UnhookWindowsHookEx(wxTheKeyboardHook);
5781     }
5782 }
5783
5784 int APIENTRY _EXPORT
5785 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
5786 {
5787     DWORD hiWord = HIWORD(lParam);
5788     if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
5789     {
5790         int id = wxCharCodeMSWToWX(wParam, lParam);
5791         if ( id != 0 )
5792         {
5793             wxKeyEvent event(wxEVT_CHAR_HOOK);
5794             if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
5795                 event.m_altDown = true;
5796
5797             event.SetEventObject(NULL);
5798             event.m_keyCode = id;
5799             event.m_shiftDown = wxIsShiftDown();
5800             event.m_controlDown = wxIsCtrlDown();
5801 #ifndef __WXWINCE__
5802             event.SetTimestamp(::GetMessageTime());
5803 #endif
5804             wxWindow *win = wxGetActiveWindow();
5805             wxEvtHandler *handler;
5806             if ( win )
5807             {
5808                 handler = win->GetEventHandler();
5809                 event.SetId(win->GetId());
5810             }
5811             else
5812             {
5813                 handler = wxTheApp;
5814                 event.SetId(wxID_ANY);
5815             }
5816
5817             if ( handler && handler->ProcessEvent(event) )
5818             {
5819                 // processed
5820                 return 1;
5821             }
5822         }
5823     }
5824
5825     return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
5826 }
5827
5828 #endif // !__WXMICROWIN__
5829
5830 #ifdef __WXDEBUG__
5831 const wxChar *wxGetMessageName(int message)
5832 {
5833     switch ( message )
5834     {
5835         case 0x0000: return wxT("WM_NULL");
5836         case 0x0001: return wxT("WM_CREATE");
5837         case 0x0002: return wxT("WM_DESTROY");
5838         case 0x0003: return wxT("WM_MOVE");
5839         case 0x0005: return wxT("WM_SIZE");
5840         case 0x0006: return wxT("WM_ACTIVATE");
5841         case 0x0007: return wxT("WM_SETFOCUS");
5842         case 0x0008: return wxT("WM_KILLFOCUS");
5843         case 0x000A: return wxT("WM_ENABLE");
5844         case 0x000B: return wxT("WM_SETREDRAW");
5845         case 0x000C: return wxT("WM_SETTEXT");
5846         case 0x000D: return wxT("WM_GETTEXT");
5847         case 0x000E: return wxT("WM_GETTEXTLENGTH");
5848         case 0x000F: return wxT("WM_PAINT");
5849         case 0x0010: return wxT("WM_CLOSE");
5850         case 0x0011: return wxT("WM_QUERYENDSESSION");
5851         case 0x0012: return wxT("WM_QUIT");
5852         case 0x0013: return wxT("WM_QUERYOPEN");
5853         case 0x0014: return wxT("WM_ERASEBKGND");
5854         case 0x0015: return wxT("WM_SYSCOLORCHANGE");
5855         case 0x0016: return wxT("WM_ENDSESSION");
5856         case 0x0017: return wxT("WM_SYSTEMERROR");
5857         case 0x0018: return wxT("WM_SHOWWINDOW");
5858         case 0x0019: return wxT("WM_CTLCOLOR");
5859         case 0x001A: return wxT("WM_WININICHANGE");
5860         case 0x001B: return wxT("WM_DEVMODECHANGE");
5861         case 0x001C: return wxT("WM_ACTIVATEAPP");
5862         case 0x001D: return wxT("WM_FONTCHANGE");
5863         case 0x001E: return wxT("WM_TIMECHANGE");
5864         case 0x001F: return wxT("WM_CANCELMODE");
5865         case 0x0020: return wxT("WM_SETCURSOR");
5866         case 0x0021: return wxT("WM_MOUSEACTIVATE");
5867         case 0x0022: return wxT("WM_CHILDACTIVATE");
5868         case 0x0023: return wxT("WM_QUEUESYNC");
5869         case 0x0024: return wxT("WM_GETMINMAXINFO");
5870         case 0x0026: return wxT("WM_PAINTICON");
5871         case 0x0027: return wxT("WM_ICONERASEBKGND");
5872         case 0x0028: return wxT("WM_NEXTDLGCTL");
5873         case 0x002A: return wxT("WM_SPOOLERSTATUS");
5874         case 0x002B: return wxT("WM_DRAWITEM");
5875         case 0x002C: return wxT("WM_MEASUREITEM");
5876         case 0x002D: return wxT("WM_DELETEITEM");
5877         case 0x002E: return wxT("WM_VKEYTOITEM");
5878         case 0x002F: return wxT("WM_CHARTOITEM");
5879         case 0x0030: return wxT("WM_SETFONT");
5880         case 0x0031: return wxT("WM_GETFONT");
5881         case 0x0037: return wxT("WM_QUERYDRAGICON");
5882         case 0x0039: return wxT("WM_COMPAREITEM");
5883         case 0x0041: return wxT("WM_COMPACTING");
5884         case 0x0044: return wxT("WM_COMMNOTIFY");
5885         case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
5886         case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
5887         case 0x0048: return wxT("WM_POWER");
5888
5889         case 0x004A: return wxT("WM_COPYDATA");
5890         case 0x004B: return wxT("WM_CANCELJOURNAL");
5891         case 0x004E: return wxT("WM_NOTIFY");
5892         case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
5893         case 0x0051: return wxT("WM_INPUTLANGCHANGE");
5894         case 0x0052: return wxT("WM_TCARD");
5895         case 0x0053: return wxT("WM_HELP");
5896         case 0x0054: return wxT("WM_USERCHANGED");
5897         case 0x0055: return wxT("WM_NOTIFYFORMAT");
5898         case 0x007B: return wxT("WM_CONTEXTMENU");
5899         case 0x007C: return wxT("WM_STYLECHANGING");
5900         case 0x007D: return wxT("WM_STYLECHANGED");
5901         case 0x007E: return wxT("WM_DISPLAYCHANGE");
5902         case 0x007F: return wxT("WM_GETICON");
5903         case 0x0080: return wxT("WM_SETICON");
5904
5905         case 0x0081: return wxT("WM_NCCREATE");
5906         case 0x0082: return wxT("WM_NCDESTROY");
5907         case 0x0083: return wxT("WM_NCCALCSIZE");
5908         case 0x0084: return wxT("WM_NCHITTEST");
5909         case 0x0085: return wxT("WM_NCPAINT");
5910         case 0x0086: return wxT("WM_NCACTIVATE");
5911         case 0x0087: return wxT("WM_GETDLGCODE");
5912         case 0x00A0: return wxT("WM_NCMOUSEMOVE");
5913         case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
5914         case 0x00A2: return wxT("WM_NCLBUTTONUP");
5915         case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
5916         case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
5917         case 0x00A5: return wxT("WM_NCRBUTTONUP");
5918         case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
5919         case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
5920         case 0x00A8: return wxT("WM_NCMBUTTONUP");
5921         case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
5922         case 0x0100: return wxT("WM_KEYDOWN");
5923         case 0x0101: return wxT("WM_KEYUP");
5924         case 0x0102: return wxT("WM_CHAR");
5925         case 0x0103: return wxT("WM_DEADCHAR");
5926         case 0x0104: return wxT("WM_SYSKEYDOWN");
5927         case 0x0105: return wxT("WM_SYSKEYUP");
5928         case 0x0106: return wxT("WM_SYSCHAR");
5929         case 0x0107: return wxT("WM_SYSDEADCHAR");
5930         case 0x0108: return wxT("WM_KEYLAST");
5931
5932         case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
5933         case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
5934         case 0x010F: return wxT("WM_IME_COMPOSITION");
5935
5936         case 0x0110: return wxT("WM_INITDIALOG");
5937         case 0x0111: return wxT("WM_COMMAND");
5938         case 0x0112: return wxT("WM_SYSCOMMAND");
5939         case 0x0113: return wxT("WM_TIMER");
5940         case 0x0114: return wxT("WM_HSCROLL");
5941         case 0x0115: return wxT("WM_VSCROLL");
5942         case 0x0116: return wxT("WM_INITMENU");
5943         case 0x0117: return wxT("WM_INITMENUPOPUP");
5944         case 0x011F: return wxT("WM_MENUSELECT");
5945         case 0x0120: return wxT("WM_MENUCHAR");
5946         case 0x0121: return wxT("WM_ENTERIDLE");
5947         case 0x0200: return wxT("WM_MOUSEMOVE");
5948         case 0x0201: return wxT("WM_LBUTTONDOWN");
5949         case 0x0202: return wxT("WM_LBUTTONUP");
5950         case 0x0203: return wxT("WM_LBUTTONDBLCLK");
5951         case 0x0204: return wxT("WM_RBUTTONDOWN");
5952         case 0x0205: return wxT("WM_RBUTTONUP");
5953         case 0x0206: return wxT("WM_RBUTTONDBLCLK");
5954         case 0x0207: return wxT("WM_MBUTTONDOWN");
5955         case 0x0208: return wxT("WM_MBUTTONUP");
5956         case 0x0209: return wxT("WM_MBUTTONDBLCLK");
5957         case 0x020A: return wxT("WM_MOUSEWHEEL");
5958         case 0x0210: return wxT("WM_PARENTNOTIFY");
5959         case 0x0211: return wxT("WM_ENTERMENULOOP");
5960         case 0x0212: return wxT("WM_EXITMENULOOP");
5961
5962         case 0x0213: return wxT("WM_NEXTMENU");
5963         case 0x0214: return wxT("WM_SIZING");
5964         case 0x0215: return wxT("WM_CAPTURECHANGED");
5965         case 0x0216: return wxT("WM_MOVING");
5966         case 0x0218: return wxT("WM_POWERBROADCAST");
5967         case 0x0219: return wxT("WM_DEVICECHANGE");
5968
5969         case 0x0220: return wxT("WM_MDICREATE");
5970         case 0x0221: return wxT("WM_MDIDESTROY");
5971         case 0x0222: return wxT("WM_MDIACTIVATE");
5972         case 0x0223: return wxT("WM_MDIRESTORE");
5973         case 0x0224: return wxT("WM_MDINEXT");
5974         case 0x0225: return wxT("WM_MDIMAXIMIZE");
5975         case 0x0226: return wxT("WM_MDITILE");
5976         case 0x0227: return wxT("WM_MDICASCADE");
5977         case 0x0228: return wxT("WM_MDIICONARRANGE");
5978         case 0x0229: return wxT("WM_MDIGETACTIVE");
5979         case 0x0230: return wxT("WM_MDISETMENU");
5980         case 0x0233: return wxT("WM_DROPFILES");
5981
5982         case 0x0281: return wxT("WM_IME_SETCONTEXT");
5983         case 0x0282: return wxT("WM_IME_NOTIFY");
5984         case 0x0283: return wxT("WM_IME_CONTROL");
5985         case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
5986         case 0x0285: return wxT("WM_IME_SELECT");
5987         case 0x0286: return wxT("WM_IME_CHAR");
5988         case 0x0290: return wxT("WM_IME_KEYDOWN");
5989         case 0x0291: return wxT("WM_IME_KEYUP");
5990
5991         case 0x0300: return wxT("WM_CUT");
5992         case 0x0301: return wxT("WM_COPY");
5993         case 0x0302: return wxT("WM_PASTE");
5994         case 0x0303: return wxT("WM_CLEAR");
5995         case 0x0304: return wxT("WM_UNDO");
5996         case 0x0305: return wxT("WM_RENDERFORMAT");
5997         case 0x0306: return wxT("WM_RENDERALLFORMATS");
5998         case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
5999         case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6000         case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6001         case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6002         case 0x030B: return wxT("WM_SIZECLIPBOARD");
6003         case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6004         case 0x030D: return wxT("WM_CHANGECBCHAIN");
6005         case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6006         case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6007         case 0x0310: return wxT("WM_PALETTEISCHANGING");
6008         case 0x0311: return wxT("WM_PALETTECHANGED");
6009 #if wxUSE_HOTKEY
6010         case 0x0312: return wxT("WM_HOTKEY");
6011 #endif
6012
6013         // common controls messages - although they're not strictly speaking
6014         // standard, it's nice to decode them nevertheless
6015
6016         // listview
6017         case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6018         case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6019         case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6020         case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6021         case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6022         case 0x1000 + 5: return wxT("LVM_GETITEMA");
6023         case 0x1000 + 75: return wxT("LVM_GETITEMW");
6024         case 0x1000 + 6: return wxT("LVM_SETITEMA");
6025         case 0x1000 + 76: return wxT("LVM_SETITEMW");
6026         case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6027         case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6028         case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6029         case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6030         case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6031         case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6032         case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6033         case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6034         case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6035         case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6036         case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6037         case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6038         case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6039         case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6040         case 0x1000 + 18: return wxT("LVM_HITTEST");
6041         case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6042         case 0x1000 + 20: return wxT("LVM_SCROLL");
6043         case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6044         case 0x1000 + 22: return wxT("LVM_ARRANGE");
6045         case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6046         case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6047         case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6048         case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6049         case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6050         case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6051         case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6052         case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6053         case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6054         case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6055         case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6056         case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6057         case 0x1000 + 31: return wxT("LVM_GETHEADER");
6058         case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6059         case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6060         case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6061         case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6062         case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6063         case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6064         case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6065         case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6066         case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6067         case 0x1000 + 42: return wxT("LVM_UPDATE");
6068         case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6069         case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6070         case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6071         case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6072         case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6073         case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6074         case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6075         case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6076         case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6077         case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6078         case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6079         case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6080         case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6081         case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6082         case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6083         case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6084         case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6085         case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6086         case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6087         case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6088         case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6089         case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6090         case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6091         case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6092         case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6093         case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6094
6095         // tree view
6096         case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6097         case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6098         case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6099         case 0x1100 + 2: return wxT("TVM_EXPAND");
6100         case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6101         case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6102         case 0x1100 + 6: return wxT("TVM_GETINDENT");
6103         case 0x1100 + 7: return wxT("TVM_SETINDENT");
6104         case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6105         case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6106         case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6107         case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6108         case 0x1100 + 12: return wxT("TVM_GETITEMA");
6109         case 0x1100 + 62: return wxT("TVM_GETITEMW");
6110         case 0x1100 + 13: return wxT("TVM_SETITEMA");
6111         case 0x1100 + 63: return wxT("TVM_SETITEMW");
6112         case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6113         case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6114         case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6115         case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6116         case 0x1100 + 17: return wxT("TVM_HITTEST");
6117         case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6118         case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6119         case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6120         case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6121         case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6122         case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6123         case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6124         case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6125         case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6126
6127         // header
6128         case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6129         case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6130         case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6131         case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6132         case 0x1200 + 3: return wxT("HDM_GETITEMA");
6133         case 0x1200 + 11: return wxT("HDM_GETITEMW");
6134         case 0x1200 + 4: return wxT("HDM_SETITEMA");
6135         case 0x1200 + 12: return wxT("HDM_SETITEMW");
6136         case 0x1200 + 5: return wxT("HDM_LAYOUT");
6137         case 0x1200 + 6: return wxT("HDM_HITTEST");
6138         case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6139         case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6140         case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6141         case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6142         case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6143         case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6144         case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6145         case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6146
6147         // tab control
6148         case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6149         case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6150         case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6151         case 0x1300 + 5: return wxT("TCM_GETITEMA");
6152         case 0x1300 + 60: return wxT("TCM_GETITEMW");
6153         case 0x1300 + 6: return wxT("TCM_SETITEMA");
6154         case 0x1300 + 61: return wxT("TCM_SETITEMW");
6155         case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6156         case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6157         case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6158         case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6159         case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6160         case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6161         case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6162         case 0x1300 + 13: return wxT("TCM_HITTEST");
6163         case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6164         case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6165         case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6166         case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6167         case 0x1300 + 43: return wxT("TCM_SETPADDING");
6168         case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6169         case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6170         case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6171         case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6172         case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6173         case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6174         case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6175
6176         // toolbar
6177         case WM_USER+1: return wxT("TB_ENABLEBUTTON");
6178         case WM_USER+2: return wxT("TB_CHECKBUTTON");
6179         case WM_USER+3: return wxT("TB_PRESSBUTTON");
6180         case WM_USER+4: return wxT("TB_HIDEBUTTON");
6181         case WM_USER+5: return wxT("TB_INDETERMINATE");
6182         case WM_USER+9: return wxT("TB_ISBUTTONENABLED");
6183         case WM_USER+10: return wxT("TB_ISBUTTONCHECKED");
6184         case WM_USER+11: return wxT("TB_ISBUTTONPRESSED");
6185         case WM_USER+12: return wxT("TB_ISBUTTONHIDDEN");
6186         case WM_USER+13: return wxT("TB_ISBUTTONINDETERMINATE");
6187         case WM_USER+17: return wxT("TB_SETSTATE");
6188         case WM_USER+18: return wxT("TB_GETSTATE");
6189         case WM_USER+19: return wxT("TB_ADDBITMAP");
6190         case WM_USER+20: return wxT("TB_ADDBUTTONS");
6191         case WM_USER+21: return wxT("TB_INSERTBUTTON");
6192         case WM_USER+22: return wxT("TB_DELETEBUTTON");
6193         case WM_USER+23: return wxT("TB_GETBUTTON");
6194         case WM_USER+24: return wxT("TB_BUTTONCOUNT");
6195         case WM_USER+25: return wxT("TB_COMMANDTOINDEX");
6196         case WM_USER+26: return wxT("TB_SAVERESTOREA");
6197         case WM_USER+76: return wxT("TB_SAVERESTOREW");
6198         case WM_USER+27: return wxT("TB_CUSTOMIZE");
6199         case WM_USER+28: return wxT("TB_ADDSTRINGA");
6200         case WM_USER+77: return wxT("TB_ADDSTRINGW");
6201         case WM_USER+29: return wxT("TB_GETITEMRECT");
6202         case WM_USER+30: return wxT("TB_BUTTONSTRUCTSIZE");
6203         case WM_USER+31: return wxT("TB_SETBUTTONSIZE");
6204         case WM_USER+32: return wxT("TB_SETBITMAPSIZE");
6205         case WM_USER+33: return wxT("TB_AUTOSIZE");
6206         case WM_USER+35: return wxT("TB_GETTOOLTIPS");
6207         case WM_USER+36: return wxT("TB_SETTOOLTIPS");
6208         case WM_USER+37: return wxT("TB_SETPARENT");
6209         case WM_USER+39: return wxT("TB_SETROWS");
6210         case WM_USER+40: return wxT("TB_GETROWS");
6211         case WM_USER+42: return wxT("TB_SETCMDID");
6212         case WM_USER+43: return wxT("TB_CHANGEBITMAP");
6213         case WM_USER+44: return wxT("TB_GETBITMAP");
6214         case WM_USER+45: return wxT("TB_GETBUTTONTEXTA");
6215         case WM_USER+75: return wxT("TB_GETBUTTONTEXTW");
6216         case WM_USER+46: return wxT("TB_REPLACEBITMAP");
6217         case WM_USER+47: return wxT("TB_SETINDENT");
6218         case WM_USER+48: return wxT("TB_SETIMAGELIST");
6219         case WM_USER+49: return wxT("TB_GETIMAGELIST");
6220         case WM_USER+50: return wxT("TB_LOADIMAGES");
6221         case WM_USER+51: return wxT("TB_GETRECT");
6222         case WM_USER+52: return wxT("TB_SETHOTIMAGELIST");
6223         case WM_USER+53: return wxT("TB_GETHOTIMAGELIST");
6224         case WM_USER+54: return wxT("TB_SETDISABLEDIMAGELIST");
6225         case WM_USER+55: return wxT("TB_GETDISABLEDIMAGELIST");
6226         case WM_USER+56: return wxT("TB_SETSTYLE");
6227         case WM_USER+57: return wxT("TB_GETSTYLE");
6228         case WM_USER+58: return wxT("TB_GETBUTTONSIZE");
6229         case WM_USER+59: return wxT("TB_SETBUTTONWIDTH");
6230         case WM_USER+60: return wxT("TB_SETMAXTEXTROWS");
6231         case WM_USER+61: return wxT("TB_GETTEXTROWS");
6232         case WM_USER+41: return wxT("TB_GETBITMAPFLAGS");
6233
6234         default:
6235             static wxString s_szBuf;
6236             s_szBuf.Printf(wxT("<unknown message = %d>"), message);
6237             return s_szBuf.c_str();
6238     }
6239 }
6240 #endif //__WXDEBUG__
6241
6242 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
6243 {
6244     // prepare the DC
6245     TEXTMETRIC tm;
6246     HWND hwnd = GetHwndOf(win);
6247     HDC hdc = ::GetDC(hwnd);
6248
6249 #if !wxDIALOG_UNIT_COMPATIBILITY
6250     // and select the current font into it
6251     HFONT hfont = GetHfontOf(win->GetFont());
6252     if ( hfont )
6253     {
6254         hfont = (HFONT)::SelectObject(hdc, hfont);
6255     }
6256 #endif
6257
6258     // finally retrieve the text metrics from it
6259     GetTextMetrics(hdc, &tm);
6260
6261 #if !wxDIALOG_UNIT_COMPATIBILITY
6262     // and clean up
6263     if ( hfont )
6264     {
6265         (void)::SelectObject(hdc, hfont);
6266     }
6267 #endif
6268
6269     ::ReleaseDC(hwnd, hdc);
6270
6271     return tm;
6272 }
6273
6274 // Find the wxWindow at the current mouse position, returning the mouse
6275 // position.
6276 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
6277 {
6278     pt = wxGetMousePosition();
6279     return wxFindWindowAtPoint(pt);
6280 }
6281
6282 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
6283 {
6284     POINT pt2;
6285     pt2.x = pt.x;
6286     pt2.y = pt.y;
6287
6288     HWND hWnd = ::WindowFromPoint(pt2);
6289
6290     return wxGetWindowFromHWND((WXHWND)hWnd);
6291 }
6292
6293 // Get the current mouse position.
6294 wxPoint wxGetMousePosition()
6295 {
6296     POINT pt;
6297 #ifdef __WXWINCE__
6298     GetCursorPosWinCE(&pt);
6299 #else
6300     GetCursorPos( & pt );
6301 #endif
6302
6303     return wxPoint(pt.x, pt.y);
6304 }
6305
6306 #if wxUSE_HOTKEY
6307
6308 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6309 static void WinCEUnregisterHotKey(int modifiers, int id)
6310 {
6311     // Register hotkeys for the hardware buttons
6312     HINSTANCE hCoreDll;
6313     typedef BOOL (WINAPI *UnregisterFunc1Proc)(UINT, UINT);
6314
6315     UnregisterFunc1Proc procUnregisterFunc;
6316     hCoreDll = LoadLibrary(_T("coredll.dll"));
6317     if (hCoreDll)
6318     {
6319         procUnregisterFunc = (UnregisterFunc1Proc)GetProcAddress(hCoreDll, _T("UnregisterFunc1"));
6320         if (procUnregisterFunc)
6321             procUnregisterFunc(modifiers, id);
6322         FreeLibrary(hCoreDll);
6323     }
6324 }
6325 #endif
6326
6327 bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
6328 {
6329     UINT win_modifiers=0;
6330     if ( modifiers & wxMOD_ALT )
6331         win_modifiers |= MOD_ALT;
6332     if ( modifiers & wxMOD_SHIFT )
6333         win_modifiers |= MOD_SHIFT;
6334     if ( modifiers & wxMOD_CONTROL )
6335         win_modifiers |= MOD_CONTROL;
6336     if ( modifiers & wxMOD_WIN )
6337         win_modifiers |= MOD_WIN;
6338
6339 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6340     // Required for PPC and Smartphone hardware buttons
6341     if (keycode >= WXK_SPECIAL1 && keycode <= WXK_SPECIAL20)
6342         WinCEUnregisterHotKey(win_modifiers, hotkeyId);
6343 #endif
6344
6345     if ( !::RegisterHotKey(GetHwnd(), hotkeyId, win_modifiers, keycode) )
6346     {
6347         wxLogLastError(_T("RegisterHotKey"));
6348
6349         return false;
6350     }
6351
6352     return true;
6353 }
6354
6355 bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
6356 {
6357 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6358     WinCEUnregisterHotKey(MOD_WIN, hotkeyId);
6359 #endif
6360
6361     if ( !::UnregisterHotKey(GetHwnd(), hotkeyId) )
6362     {
6363         wxLogLastError(_T("UnregisterHotKey"));
6364
6365         return false;
6366     }
6367
6368     return true;
6369 }
6370
6371 #if wxUSE_ACCEL
6372
6373 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
6374 {
6375     int hotkeyId = wParam;
6376     int virtualKey = HIWORD(lParam);
6377     int win_modifiers = LOWORD(lParam);
6378
6379     wxKeyEvent event(CreateKeyEvent(wxEVT_HOTKEY, virtualKey, wParam, lParam));
6380     event.SetId(hotkeyId);
6381     event.m_shiftDown = (win_modifiers & MOD_SHIFT) != 0;
6382     event.m_controlDown = (win_modifiers & MOD_CONTROL) != 0;
6383     event.m_altDown = (win_modifiers & MOD_ALT) != 0;
6384     event.m_metaDown = (win_modifiers & MOD_WIN) != 0;
6385
6386     return GetEventHandler()->ProcessEvent(event);
6387 }
6388
6389 #endif // wxUSE_ACCEL
6390
6391 #endif // wxUSE_HOTKEY
6392
6393 // Not tested under WinCE
6394 #ifndef __WXWINCE__
6395
6396 // this class installs a message hook which really wakes up our idle processing
6397 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6398 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6399 // being dragged or even inside ::MessageBox()) and so don't control message
6400 // dispatching otherwise
6401 class wxIdleWakeUpModule : public wxModule
6402 {
6403 public:
6404     virtual bool OnInit()
6405     {
6406         ms_hMsgHookProc = ::SetWindowsHookEx
6407                             (
6408                              WH_GETMESSAGE,
6409                              &wxIdleWakeUpModule::MsgHookProc,
6410                              NULL,
6411                              GetCurrentThreadId()
6412                             );
6413
6414         if ( !ms_hMsgHookProc )
6415         {
6416             wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6417
6418             return false;
6419         }
6420
6421         return true;
6422     }
6423
6424     virtual void OnExit()
6425     {
6426         ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc);
6427     }
6428
6429     static LRESULT CALLBACK MsgHookProc(int nCode, WPARAM wParam, LPARAM lParam)
6430     {
6431         MSG *msg = (MSG*)lParam;
6432
6433         // only process the message if it is actually going to be removed from
6434         // the message queue, this prevents that the same event from being
6435         // processed multiple times if now someone just called PeekMessage()
6436         if ( msg->message == WM_NULL && wParam == PM_REMOVE )
6437         {
6438             wxTheApp->ProcessPendingEvents();
6439         }
6440
6441         return CallNextHookEx(ms_hMsgHookProc, nCode, wParam, lParam);
6442     };
6443
6444 private:
6445     static HHOOK ms_hMsgHookProc;
6446
6447     DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule)
6448 };
6449
6450 HHOOK wxIdleWakeUpModule::ms_hMsgHookProc = 0;
6451
6452 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule, wxModule)
6453
6454 #endif // __WXWINCE__
6455
6456 #ifdef __WXWINCE__
6457
6458 #if wxUSE_STATBOX
6459 static void wxAdjustZOrder(wxWindow* parent)
6460 {
6461     if (parent->IsKindOf(CLASSINFO(wxStaticBox)))
6462     {
6463         // Set the z-order correctly
6464         SetWindowPos((HWND) parent->GetHWND(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
6465     }
6466
6467     wxWindowList::compatibility_iterator current = parent->GetChildren().GetFirst();
6468     while (current)
6469     {
6470         wxWindow *childWin = current->GetData();
6471         wxAdjustZOrder(childWin);
6472         current = current->GetNext();
6473     }
6474 }
6475 #endif
6476
6477 // We need to adjust the z-order of static boxes in WinCE, to
6478 // make 'contained' controls visible
6479 void wxWindowMSW::OnInitDialog( wxInitDialogEvent& event )
6480 {
6481 #if wxUSE_STATBOX
6482     wxAdjustZOrder(this);
6483 #endif
6484
6485     event.Skip();
6486 }
6487 #endif