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