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