src/msw/window.cpp

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