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