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