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