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