src/msw/window.cpp

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