src/msw/window.cpp

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