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