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