src/msw/window.cpp

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