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