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