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