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 #if wxUSE_OWNER_DRAWN
3428     wxWindow *item = FindItem(id);
3429     if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
3430         return ((wxControl *)item)->MSWOnDraw(itemStruct);
3431 #elif !defined(__WXUNIVERSAL__)
3432     // we may still have owner-drawn buttons internally because we have to make
3433     // them owner-drawn to support colour change
3434     wxWindow *item = FindItem(id);
3435     if ( item && item->IsKindOf(CLASSINFO(wxButton)) )
3436         return ((wxButton *)item)->MSWOnDraw(itemStruct);
3437 #endif // USE_OWNER_DRAWN
3438
3439 #endif // wxUSE_CONTROLS
3440
3441     return FALSE;
3442 }
3443
3444 bool wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
3445 {
3446 #if wxUSE_OWNER_DRAWN
3447     // is it a menu item?
3448     MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
3449     if ( id == 0 && pMeasureStruct->CtlType == ODT_MENU )
3450     {
3451         wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
3452
3453         wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3454
3455         return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
3456                                         &pMeasureStruct->itemHeight);
3457     }
3458
3459     wxWindow *item = FindItem(id);
3460     if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
3461     {
3462         return ((wxControl *)item)->MSWOnMeasure(itemStruct);
3463     }
3464 #endif  // owner-drawn menus
3465     return FALSE;
3466 }
3467
3468 // ---------------------------------------------------------------------------
3469 // colours and palettes
3470 // ---------------------------------------------------------------------------
3471
3472 bool wxWindowMSW::HandleSysColorChange()
3473 {
3474     wxSysColourChangedEvent event;
3475     event.SetEventObject(this);
3476
3477     (void)GetEventHandler()->ProcessEvent(event);
3478
3479     // always let the system carry on the default processing to allow the
3480     // native controls to react to the colours update
3481     return FALSE;
3482 }
3483
3484 bool wxWindowMSW::HandleDisplayChange()
3485 {
3486     wxDisplayChangedEvent event;
3487     event.SetEventObject(this);
3488
3489     return GetEventHandler()->ProcessEvent(event);
3490 }
3491
3492 bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
3493                               WXHDC pDC,
3494                               WXHWND pWnd,
3495                               WXUINT nCtlColor,
3496                               WXUINT message,
3497                               WXWPARAM wParam,
3498                               WXLPARAM lParam)
3499 {
3500 #ifndef __WXMICROWIN__
3501     WXHBRUSH hBrush = 0;
3502
3503     if ( nCtlColor == CTLCOLOR_DLG )
3504     {
3505         hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3506     }
3507 #if wxUSE_CONTROLS
3508     else
3509     {
3510         wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
3511         if ( item )
3512             hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3513     }
3514 #endif // wxUSE_CONTROLS
3515
3516     if ( hBrush )
3517         *brush = hBrush;
3518
3519     return hBrush != 0;
3520 #else // __WXMICROWIN__
3521     return FALSE;
3522 #endif
3523 }
3524
3525 // Define for each class of dialog and control
3526 WXHBRUSH wxWindowMSW::OnCtlColor(WXHDC WXUNUSED(hDC),
3527                                  WXHWND WXUNUSED(hWnd),
3528                                  WXUINT WXUNUSED(nCtlColor),
3529                                  WXUINT WXUNUSED(message),
3530                                  WXWPARAM WXUNUSED(wParam),
3531                                  WXLPARAM WXUNUSED(lParam))
3532 {
3533     return (WXHBRUSH)0;
3534 }
3535
3536 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
3537 {
3538 #if wxUSE_PALETTE
3539     // same as below except we don't respond to our own messages
3540     if ( hWndPalChange != GetHWND() )
3541     {
3542         // check to see if we our our parents have a custom palette
3543         wxWindowMSW *win = this;
3544         while ( win && !win->HasCustomPalette() )
3545         {
3546             win = win->GetParent();
3547         }
3548
3549         if ( win && win->HasCustomPalette() )
3550         {
3551             // realize the palette to see whether redrawing is needed
3552             HDC hdc = ::GetDC((HWND) hWndPalChange);
3553             win->m_palette.SetHPALETTE((WXHPALETTE)
3554                     ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3555
3556             int result = ::RealizePalette(hdc);
3557
3558             // restore the palette (before releasing the DC)
3559             win->m_palette.SetHPALETTE((WXHPALETTE)
3560                     ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3561             ::RealizePalette(hdc);
3562             ::ReleaseDC((HWND) hWndPalChange, hdc);
3563
3564             // now check for the need to redraw
3565             if (result > 0)
3566                 InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
3567         }
3568
3569     }
3570 #endif // wxUSE_PALETTE
3571
3572     wxPaletteChangedEvent event(GetId());
3573     event.SetEventObject(this);
3574     event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
3575
3576     return GetEventHandler()->ProcessEvent(event);
3577 }
3578
3579 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture)
3580 {
3581     wxMouseCaptureChangedEvent event(GetId(), wxFindWinFromHandle(hWndGainedCapture));
3582     event.SetEventObject(this);
3583
3584     return GetEventHandler()->ProcessEvent(event);
3585 }
3586
3587 bool wxWindowMSW::HandleQueryNewPalette()
3588 {
3589
3590 #if wxUSE_PALETTE
3591     // check to see if we our our parents have a custom palette
3592     wxWindowMSW *win = this;
3593     while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
3594     if (win->HasCustomPalette()) {
3595         /* realize the palette to see whether redrawing is needed */
3596         HDC hdc = GetDC((HWND) GetHWND());
3597         win->m_palette.SetHPALETTE( (WXHPALETTE)
3598              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
3599
3600         int result = ::RealizePalette(hdc);
3601         /* restore the palette (before releasing the DC) */
3602         win->m_palette.SetHPALETTE( (WXHPALETTE)
3603              ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), TRUE) );
3604         ::RealizePalette(hdc);
3605         ::ReleaseDC((HWND) GetHWND(), hdc);
3606         /* now check for the need to redraw */
3607         if (result > 0)
3608             ::InvalidateRect((HWND) GetHWND(), NULL, TRUE);
3609         }
3610 #endif // wxUSE_PALETTE
3611
3612     wxQueryNewPaletteEvent event(GetId());
3613     event.SetEventObject(this);
3614
3615     return GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
3616 }
3617
3618 // Responds to colour changes: passes event on to children.
3619 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
3620 {
3621     // the top level window also reset the standard colour map as it might have
3622     // changed (there is no need to do it for the non top level windows as we
3623     // only have to do it once)
3624     if ( IsTopLevel() )
3625     {
3626         // FIXME-MT
3627         gs_hasStdCmap = FALSE;
3628     }
3629     wxWindowList::Node *node = GetChildren().GetFirst();
3630     while ( node )
3631     {
3632         // Only propagate to non-top-level windows because Windows already
3633         // sends this event to all top-level ones
3634         wxWindow *win = node->GetData();
3635         if ( !win->IsTopLevel() )
3636         {
3637             // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3638             // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3639             // the standard controls
3640             ::SendMessage(GetHwndOf(win), WM_SYSCOLORCHANGE, 0, 0);
3641         }
3642
3643         node = node->GetNext();
3644     }
3645
3646     // update the colours we use if they were not set explicitly by the user:
3647     // this must be done or OnCtlColor() would continue to use the old colours
3648     if ( !m_hasFgCol )
3649     {
3650         m_foregroundColour = wxSystemSettings::
3651                                 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
3652     }
3653
3654     if ( !m_hasBgCol )
3655     {
3656         m_backgroundColour = wxSystemSettings::
3657                                 GetSystemColour(wxSYS_COLOUR_BTNFACE);
3658     }
3659 }
3660
3661 extern wxCOLORMAP *wxGetStdColourMap()
3662 {
3663     static COLORREF s_stdColours[wxSTD_COL_MAX];
3664     static wxCOLORMAP s_cmap[wxSTD_COL_MAX];
3665
3666     if ( !gs_hasStdCmap )
3667     {
3668         static bool s_coloursInit = FALSE;
3669
3670         if ( !s_coloursInit )
3671         {
3672             // When a bitmap is loaded, the RGB values can change (apparently
3673             // because Windows adjusts them to care for the old programs always
3674             // using 0xc0c0c0 while the transparent colour for the new Windows
3675             // versions is different). But we do this adjustment ourselves so
3676             // we want to avoid Windows' "help" and for this we need to have a
3677             // reference bitmap which can tell us what the RGB values change
3678             // to.
3679             wxBitmap stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3680             if ( stdColourBitmap.Ok() )
3681             {
3682                 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3683                 wxASSERT_MSG( stdColourBitmap.GetWidth() == wxSTD_COL_MAX,
3684                               _T("forgot to update wxBITMAP_STD_COLOURS!") );
3685
3686                 wxMemoryDC memDC;
3687                 memDC.SelectObject(stdColourBitmap);
3688
3689                 wxColour colour;
3690                 for ( size_t i = 0; i < WXSIZEOF(s_stdColours); i++ )
3691                 {
3692                     memDC.GetPixel(i, 0, &colour);
3693                     s_stdColours[i] = wxColourToRGB(colour);
3694                 }
3695             }
3696             else // wxBITMAP_STD_COLOURS couldn't be loaded
3697             {
3698                 s_stdColours[0] = RGB(000,000,000);     // black
3699                 s_stdColours[1] = RGB(128,128,128);     // dark grey
3700                 s_stdColours[2] = RGB(192,192,192);     // light grey
3701                 s_stdColours[3] = RGB(255,255,255);     // white
3702                 //s_stdColours[4] = RGB(000,000,255);     // blue
3703                 //s_stdColours[5] = RGB(255,000,255);     // magenta
3704             }
3705
3706             s_coloursInit = TRUE;
3707         }
3708
3709         gs_hasStdCmap = TRUE;
3710
3711         // create the colour map
3712 #define INIT_CMAP_ENTRY(col) \
3713             s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3714             s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3715
3716         INIT_CMAP_ENTRY(BTNTEXT);
3717         INIT_CMAP_ENTRY(BTNSHADOW);
3718         INIT_CMAP_ENTRY(BTNFACE);
3719         INIT_CMAP_ENTRY(BTNHIGHLIGHT);
3720
3721 #undef INIT_CMAP_ENTRY
3722     }
3723
3724     return s_cmap;
3725 }
3726
3727 // ---------------------------------------------------------------------------
3728 // painting
3729 // ---------------------------------------------------------------------------
3730
3731 bool wxWindowMSW::HandlePaint()
3732 {
3733 //    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3734 //        return FALSE;
3735
3736 #ifdef __WIN32__
3737     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3738     if ( !hRegion )
3739         wxLogLastError(wxT("CreateRectRgn"));
3740     if ( ::GetUpdateRgn(GetHwnd(), hRegion, FALSE) == ERROR )
3741         wxLogLastError(wxT("GetUpdateRgn"));
3742
3743     m_updateRegion = wxRegion((WXHRGN) hRegion);
3744 #else // Win16
3745     RECT updateRect;
3746     ::GetUpdateRect(GetHwnd(), &updateRect, FALSE);
3747
3748     m_updateRegion = wxRegion(updateRect.left, updateRect.top,
3749                               updateRect.right - updateRect.left,
3750                               updateRect.bottom - updateRect.top);
3751 #endif // Win32/16
3752
3753     wxPaintEvent event(m_windowId);
3754     event.SetEventObject(this);
3755
3756     bool processed = GetEventHandler()->ProcessEvent(event);
3757
3758     // note that we must generate NC event after the normal one as otherwise
3759     // BeginPaint() will happily overwrite our decorations with the background
3760     // colour
3761     wxNcPaintEvent eventNc(m_windowId);
3762     eventNc.SetEventObject(this);
3763     GetEventHandler()->ProcessEvent(eventNc);
3764
3765     return processed;
3766 }
3767
3768 // Can be called from an application's OnPaint handler
3769 void wxWindowMSW::OnPaint(wxPaintEvent& event)
3770 {
3771 #ifdef __WXUNIVERSAL__
3772     event.Skip();
3773 #else
3774     HDC hDC = (HDC) wxPaintDC::FindDCInCache((wxWindow*) event.GetEventObject());
3775     if (hDC != 0)
3776     {
3777         MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
3778     }
3779 #endif
3780 }
3781
3782 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
3783 {
3784     // Prevents flicker when dragging
3785     if ( ::IsIconic(GetHwnd()) )
3786         return TRUE;
3787
3788 #if 0
3789     if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3790     {
3791         return FALSE;
3792     }
3793
3794     if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3795     {
3796         if (wxUxThemeEngine::Get())
3797         {
3798             WXHTHEME hTheme = wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L"TAB");
3799             if (hTheme)
3800             {
3801                 WXURECT rect;
3802                 ::GetClientRect((HWND) GetHWND(), (RECT*) & rect);
3803                 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme, hdc, 10 /* TABP_BODY */, 0, &rect, &rect);
3804                 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme);
3805                 return TRUE;
3806             }
3807         }
3808     }
3809 #endif
3810
3811     wxDCTemp dc(hdc);
3812
3813     dc.SetHDC(hdc);
3814     dc.SetWindow((wxWindow *)this);
3815     dc.BeginDrawing();
3816
3817     wxEraseEvent event(m_windowId, &dc);
3818     event.SetEventObject(this);
3819     bool rc = GetEventHandler()->ProcessEvent(event);
3820
3821     dc.EndDrawing();
3822
3823     // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3824     dc.SelectOldObjects(hdc);
3825
3826     return rc;
3827 }
3828
3829 void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
3830 {
3831     RECT rect;
3832     ::GetClientRect(GetHwnd(), &rect);
3833
3834     COLORREF ref = PALETTERGB(m_backgroundColour.Red(),
3835                               m_backgroundColour.Green(),
3836                               m_backgroundColour.Blue());
3837     HBRUSH hBrush = ::CreateSolidBrush(ref);
3838     if ( !hBrush )
3839         wxLogLastError(wxT("CreateSolidBrush"));
3840
3841     HDC hdc = (HDC)event.GetDC()->GetHDC();
3842
3843     int mode = ::SetMapMode(hdc, MM_TEXT);
3844
3845     ::FillRect(hdc, &rect, hBrush);
3846     ::DeleteObject(hBrush);
3847     ::SetMapMode(hdc, mode);
3848 }
3849
3850 // ---------------------------------------------------------------------------
3851 // moving and resizing
3852 // ---------------------------------------------------------------------------
3853
3854 bool wxWindowMSW::HandleMinimize()
3855 {
3856     wxIconizeEvent event(m_windowId);
3857     event.SetEventObject(this);
3858
3859     return GetEventHandler()->ProcessEvent(event);
3860 }
3861
3862 bool wxWindowMSW::HandleMaximize()
3863 {
3864     wxMaximizeEvent event(m_windowId);
3865     event.SetEventObject(this);
3866
3867     return GetEventHandler()->ProcessEvent(event);
3868 }
3869
3870 bool wxWindowMSW::HandleMove(int x, int y)
3871 {
3872     wxMoveEvent event(wxPoint(x, y), m_windowId);
3873     event.SetEventObject(this);
3874
3875     return GetEventHandler()->ProcessEvent(event);
3876 }
3877
3878 bool wxWindowMSW::HandleMoving(wxRect& rect)
3879 {
3880     wxMoveEvent event(rect, m_windowId);
3881     event.SetEventObject(this);
3882
3883     bool rc = GetEventHandler()->ProcessEvent(event);
3884     if (rc)
3885         rect = event.GetRect();
3886     return rc;
3887 }
3888
3889 bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
3890                              WXUINT WXUNUSED(flag))
3891 {
3892     // don't use w and h parameters as they specify the client size while
3893     // according to the docs EVT_SIZE handler is supposed to receive the total
3894     // size
3895     wxSizeEvent event(GetSize(), m_windowId);
3896     event.SetEventObject(this);
3897
3898     return GetEventHandler()->ProcessEvent(event);
3899 }
3900
3901 bool wxWindowMSW::HandleSizing(wxRect& rect)
3902 {
3903     wxSizeEvent event(rect, m_windowId);
3904     event.SetEventObject(this);
3905
3906     bool rc = GetEventHandler()->ProcessEvent(event);
3907     if (rc)
3908         rect = event.GetRect();
3909     return rc;
3910 }
3911
3912 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
3913 {
3914     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
3915
3916     bool rc = FALSE;
3917
3918     int minWidth = GetMinWidth(),
3919         minHeight = GetMinHeight(),
3920         maxWidth = GetMaxWidth(),
3921         maxHeight = GetMaxHeight();
3922
3923     if ( minWidth != -1 )
3924     {
3925         info->ptMinTrackSize.x = minWidth;
3926         rc = TRUE;
3927     }
3928
3929     if ( minHeight != -1 )
3930     {
3931         info->ptMinTrackSize.y = minHeight;
3932         rc = TRUE;
3933     }
3934
3935     if ( maxWidth != -1 )
3936     {
3937         info->ptMaxTrackSize.x = maxWidth;
3938         rc = TRUE;
3939     }
3940
3941     if ( maxHeight != -1 )
3942     {
3943         info->ptMaxTrackSize.y = maxHeight;
3944         rc = TRUE;
3945     }
3946
3947     return rc;
3948 }
3949
3950 // ---------------------------------------------------------------------------
3951 // command messages
3952 // ---------------------------------------------------------------------------
3953
3954 bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
3955 {
3956 #if wxUSE_MENUS_NATIVE
3957     if ( !cmd && wxCurrentPopupMenu )
3958     {
3959         wxMenu *popupMenu = wxCurrentPopupMenu;
3960         wxCurrentPopupMenu = NULL;
3961
3962         return popupMenu->MSWCommand(cmd, id);
3963     }
3964 #endif // wxUSE_MENUS_NATIVE
3965
3966     wxWindow *win = NULL;
3967
3968     // first try to find it from HWND - this works even with the broken
3969     // programs using the same ids for different controls
3970     if ( control )
3971     {
3972         win = wxFindWinFromHandle(control);
3973     }
3974
3975     // try the id
3976     if ( !win )
3977     {
3978         // must cast to a signed type before comparing with other ids!
3979         win = FindItem((signed short)id);
3980     }
3981
3982     if ( win )
3983     {
3984         return win->MSWCommand(cmd, id);
3985     }
3986
3987     // the messages sent from the in-place edit control used by the treectrl
3988     // for label editing have id == 0, but they should _not_ be treated as menu
3989     // messages (they are EN_XXX ones, in fact) so don't translate anything
3990     // coming from a control to wxEVT_COMMAND_MENU_SELECTED
3991     if ( !control )
3992     {
3993         // If no child window, it may be an accelerator, e.g. for a popup menu
3994         // command
3995
3996         wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
3997         event.SetEventObject(this);
3998         event.SetId(id);
3999         event.SetInt(id);
4000
4001         return GetEventHandler()->ProcessEvent(event);
4002     }
4003 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4004     else
4005     {
4006         // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4007         // notifications to its parent which we want to reflect back to
4008         // wxSpinCtrl
4009         wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
4010         if ( spin && spin->ProcessTextCommand(cmd, id) )
4011             return TRUE;
4012     }
4013 #endif // wxUSE_SPINCTRL
4014
4015     return FALSE;
4016 }
4017
4018 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
4019 {
4020     // 4 bits are reserved
4021     switch ( wParam & 0xFFFFFFF0 )
4022     {
4023         case SC_MAXIMIZE:
4024             return HandleMaximize();
4025
4026         case SC_MINIMIZE:
4027             return HandleMinimize();
4028     }
4029
4030     return FALSE;
4031 }
4032
4033 // ---------------------------------------------------------------------------
4034 // mouse events
4035 // ---------------------------------------------------------------------------
4036
4037 void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
4038                                  int x, int y,
4039                                  WXUINT flags)
4040 {
4041     // our client coords are not quite the same as Windows ones
4042     wxPoint pt = GetClientAreaOrigin();
4043     event.m_x = x - pt.x;
4044     event.m_y = y - pt.y;
4045
4046     event.m_shiftDown = (flags & MK_SHIFT) != 0;
4047     event.m_controlDown = (flags & MK_CONTROL) != 0;
4048     event.m_leftDown = (flags & MK_LBUTTON) != 0;
4049     event.m_middleDown = (flags & MK_MBUTTON) != 0;
4050     event.m_rightDown = (flags & MK_RBUTTON) != 0;
4051  //   event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4052     // Returns different negative values on WinME and WinNT,
4053     // so simply test for negative value.
4054     event.m_altDown = ::GetKeyState(VK_MENU) < 0;
4055
4056     event.SetTimestamp(s_currentMsg.time);
4057     event.m_eventObject = this;
4058     event.SetId(GetId());
4059
4060 #if wxUSE_MOUSEEVENT_HACK
4061     m_lastMouseX = x;
4062     m_lastMouseY = y;
4063     m_lastMouseEvent = event.GetEventType();
4064 #endif // wxUSE_MOUSEEVENT_HACK
4065 }
4066
4067 // Windows doesn't send the mouse events to the static controls (which are
4068 // transparent in the sense that their WM_NCHITTEST handler returns
4069 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4070 // and so we manually check if we don't have a child window under mouse and if
4071 // we do, send the event to it instead of the window Windows had sent WM_XXX
4072 // to.
4073 //
4074 // Notice that this is not done for the mouse move events because this could
4075 // (would?) be too slow, but only for clicks which means that the static texts
4076 // still don't get move, enter nor leave events.
4077 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //TW:REQ:Univ
4078 {
4079     wxCHECK_MSG( x && y, win, _T("NULL pointer in FindWindowForMouseEvent") );
4080
4081     // first try to find a non transparent child: this allows us to send events
4082     // to a static text which is inside a static box, for example
4083     POINT pt = { *x, *y };
4084     HWND hwnd = GetHwndOf(win),
4085          hwndUnderMouse;
4086
4087 #ifdef __WIN32__
4088     hwndUnderMouse = ::ChildWindowFromPointEx
4089                        (
4090                         hwnd,
4091                         pt,
4092                         CWP_SKIPINVISIBLE   |
4093                         CWP_SKIPDISABLED    |
4094                         CWP_SKIPTRANSPARENT
4095                        );
4096
4097     if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
4098 #endif // __WIN32__
4099     {
4100         // now try any child window at all
4101         hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
4102     }
4103
4104     // check that we have a child window which is susceptible to receive mouse
4105     // events: for this it must be shown and enabled
4106     if ( hwndUnderMouse &&
4107             hwndUnderMouse != hwnd &&
4108                 ::IsWindowVisible(hwndUnderMouse) &&
4109                     ::IsWindowEnabled(hwndUnderMouse) )
4110     {
4111         wxWindow *winUnderMouse = wxFindWinFromHandle((WXHWND)hwndUnderMouse);
4112         if ( winUnderMouse )
4113         {
4114             // translate the mouse coords to the other window coords
4115             win->ClientToScreen(x, y);
4116             winUnderMouse->ScreenToClient(x, y);
4117
4118             win = winUnderMouse;
4119         }
4120     }
4121
4122     return win;
4123 }
4124
4125 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
4126 {
4127     // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4128     // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4129     // from the message id and take the value in the table to get wxWin event
4130     // id
4131     static const wxEventType eventsMouse[] =
4132     {
4133         wxEVT_MOTION,
4134         wxEVT_LEFT_DOWN,
4135         wxEVT_LEFT_UP,
4136         wxEVT_LEFT_DCLICK,
4137         wxEVT_RIGHT_DOWN,
4138         wxEVT_RIGHT_UP,
4139         wxEVT_RIGHT_DCLICK,
4140         wxEVT_MIDDLE_DOWN,
4141         wxEVT_MIDDLE_UP,
4142         wxEVT_MIDDLE_DCLICK
4143     };
4144
4145     wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
4146     InitMouseEvent(event, x, y, flags);
4147
4148     return GetEventHandler()->ProcessEvent(event);
4149 }
4150
4151 bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
4152 {
4153     if ( !m_mouseInWindow )
4154     {
4155         // it would be wrong to assume that just because we get a mouse move
4156         // event that the mouse is inside the window: although this is usually
4157         // true, it is not if we had captured the mouse, so we need to check
4158         // the mouse coordinates here
4159         if ( !HasCapture() || IsMouseInWindow() )
4160         {
4161             // Generate an ENTER event
4162             m_mouseInWindow = TRUE;
4163
4164             wxMouseEvent event(wxEVT_ENTER_WINDOW);
4165             InitMouseEvent(event, x, y, flags);
4166
4167             (void)GetEventHandler()->ProcessEvent(event);
4168         }
4169     }
4170
4171 #if wxUSE_MOUSEEVENT_HACK
4172     // Window gets a click down message followed by a mouse move message even
4173     // if position isn't changed!  We want to discard the trailing move event
4174     // if x and y are the same.
4175     if ( (m_lastMouseEvent == wxEVT_RIGHT_DOWN ||
4176           m_lastMouseEvent == wxEVT_LEFT_DOWN ||
4177           m_lastMouseEvent == wxEVT_MIDDLE_DOWN) &&
4178          (m_lastMouseX == x && m_lastMouseY == y) )
4179     {
4180         m_lastMouseEvent = wxEVT_MOTION;
4181
4182         return FALSE;
4183     }
4184 #endif // wxUSE_MOUSEEVENT_HACK
4185
4186     return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
4187 }
4188
4189
4190 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
4191 {
4192 #if wxUSE_MOUSEWHEEL
4193     wxMouseEvent event(wxEVT_MOUSEWHEEL);
4194     InitMouseEvent(event,
4195                    GET_X_LPARAM(lParam),
4196                    GET_Y_LPARAM(lParam),
4197                    LOWORD(wParam));
4198     event.m_wheelRotation = (short)HIWORD(wParam);
4199     event.m_wheelDelta = WHEEL_DELTA;
4200
4201 #ifdef __WIN32__
4202     static int s_linesPerRotation = -1;
4203     if ( s_linesPerRotation == -1 )
4204     {
4205         if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
4206                                      &s_linesPerRotation, 0))
4207         {
4208             // this is not supposed to happen
4209             wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4210
4211             // the default is 3, so use it if SystemParametersInfo() failed
4212             s_linesPerRotation = 3;
4213         }
4214     }
4215 #else // Win16
4216     // no SystemParametersInfo() under Win16
4217     static const int s_linesPerRotation = 3;
4218 #endif
4219
4220     event.m_linesPerAction = s_linesPerRotation;
4221     return GetEventHandler()->ProcessEvent(event);
4222
4223 #else
4224     (void) wParam;
4225     (void) lParam;
4226
4227     return FALSE;
4228 #endif
4229 }
4230
4231
4232 // ---------------------------------------------------------------------------
4233 // keyboard handling
4234 // ---------------------------------------------------------------------------
4235
4236 // create the key event of the given type for the given key - used by
4237 // HandleChar and HandleKeyDown/Up
4238 wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
4239                                        int id,
4240                                        WXLPARAM lParam,
4241                                        WXWPARAM wParam) const
4242 {
4243     wxKeyEvent event(evType);
4244     event.SetId(GetId());
4245     event.m_shiftDown = wxIsShiftDown();
4246     event.m_controlDown = wxIsCtrlDown();
4247     event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
4248
4249     event.m_eventObject = (wxWindow *)this; // const_cast
4250     event.m_keyCode = id;
4251     event.m_rawCode = (wxUint32) wParam;
4252     event.m_rawFlags = (wxUint32) lParam;
4253     event.SetTimestamp(s_currentMsg.time);
4254
4255     // translate the position to client coords
4256     POINT pt;
4257     GetCursorPos(&pt);
4258     RECT rect;
4259     GetWindowRect(GetHwnd(),&rect);
4260     pt.x -= rect.left;
4261     pt.y -= rect.top;
4262
4263     event.m_x = pt.x;
4264     event.m_y = pt.y;
4265
4266     return event;
4267 }
4268
4269 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4270 // WM_KEYDOWN one
4271 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
4272 {
4273     bool ctrlDown = FALSE;
4274
4275     int id;
4276     if ( isASCII )
4277     {
4278         // If 1 -> 26, translate to either special keycode or just set
4279         // ctrlDown.  IOW, Ctrl-C should result in keycode == 3 and
4280         // ControlDown() == TRUE.
4281         id = wParam;
4282         if ( (id > 0) && (id < 27) )
4283         {
4284             switch (id)
4285             {
4286                 case 13:
4287                     id = WXK_RETURN;
4288                     break;
4289
4290                 case 8:
4291                     id = WXK_BACK;
4292                     break;
4293
4294                 case 9:
4295                     id = WXK_TAB;
4296                     break;
4297
4298                 default:
4299                     ctrlDown = TRUE;
4300                     break;
4301             }
4302         }
4303     }
4304     else // we're called from WM_KEYDOWN
4305     {
4306         id = wxCharCodeMSWToWX(wParam);
4307         if ( id == 0 )
4308         {
4309             // it's ASCII and will be processed here only when called from
4310             // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4311             return FALSE;
4312         }
4313     }
4314
4315     wxKeyEvent event(CreateKeyEvent(wxEVT_CHAR, id, lParam, wParam));
4316
4317     // the alphanumeric keys produced by pressing AltGr+something on European
4318     // keyboards have both Ctrl and Alt modifiers which may confuse the user
4319     // code as, normally, keys with Ctrl and/or Alt don't result in anything
4320     // alphanumeric, so pretend that there are no modifiers at all (the
4321     // KEY_DOWN event would still have the correct modifiers if they're really
4322     // needed)
4323     if ( event.m_controlDown && event.m_altDown &&
4324             (id >= 32 && id < 256) )
4325     {
4326         event.m_controlDown =
4327         event.m_altDown = FALSE;
4328     }
4329
4330     return GetEventHandler()->ProcessEvent(event);
4331 }
4332
4333 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
4334 {
4335     int id = wxCharCodeMSWToWX(wParam);
4336
4337     if ( !id )
4338     {
4339         // normal ASCII char
4340         id = wParam;
4341     }
4342
4343     if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4344     {
4345         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
4346         if ( GetEventHandler()->ProcessEvent(event) )
4347         {
4348             return TRUE;
4349         }
4350     }
4351
4352     return FALSE;
4353 }
4354
4355 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
4356 {
4357     int id = wxCharCodeMSWToWX(wParam);
4358
4359     if ( !id )
4360     {
4361         // normal ASCII char
4362         id = wParam;
4363     }
4364
4365     if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4366     {
4367         wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
4368         if ( GetEventHandler()->ProcessEvent(event) )
4369             return TRUE;
4370     }
4371
4372     return FALSE;
4373 }
4374
4375 #ifdef __WIN32__
4376
4377 int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
4378 {
4379     const HMENU hmenu = (HMENU)lParam;
4380
4381     MENUITEMINFO mii;
4382     wxZeroMemory(mii);
4383     mii.cbSize = sizeof(MENUITEMINFO);
4384     mii.fMask = MIIM_TYPE | MIIM_DATA;
4385
4386     // find if we have this letter in any owner drawn item
4387     const int count = ::GetMenuItemCount(hmenu);
4388     for ( int i = 0; i < count; i++ )
4389     {
4390         if ( ::GetMenuItemInfo(hmenu, i, TRUE, &mii) )
4391         {
4392             if ( mii.fType == MFT_OWNERDRAW )
4393             {
4394                 //  dwItemData member of the MENUITEMINFO is a
4395                 //  pointer to the associated wxMenuItem -- see the
4396                 //  menu creation code
4397                 wxMenuItem *item = (wxMenuItem*)mii.dwItemData;
4398
4399                 const wxChar *p = wxStrchr(item->GetText(), _T('&'));
4400                 while ( p++ )
4401                 {
4402                     if ( *p == _T('&') )
4403                     {
4404                         // this is not the accel char, find the real one
4405                         p = wxStrchr(p + 1, _T('&'));
4406                     }
4407                     else // got the accel char
4408                     {
4409                         // FIXME-UNICODE: this comparison doesn't risk to work
4410                         // for non ASCII accelerator characters I'm afraid, but
4411                         // what can we do?
4412                         if ( wxToupper(*p) == chAccel )
4413                         {
4414                             return i;
4415                         }
4416                         else
4417                         {
4418                             // this one doesn't match
4419                             break;
4420                         }
4421                     }
4422                 }
4423             }
4424         }
4425         else // failed ot get the menu text?
4426         {
4427             // it's not fatal, so don't show error, but still log
4428             // it
4429             wxLogLastError(_T("GetMenuItemInfo"));
4430         }
4431     }
4432
4433     return wxNOT_FOUND;
4434 }
4435
4436 #endif // __WIN32__
4437
4438 // ---------------------------------------------------------------------------
4439 // joystick
4440 // ---------------------------------------------------------------------------
4441
4442 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
4443 {
4444 #ifdef JOY_BUTTON1
4445     int change = 0;
4446     if ( flags & JOY_BUTTON1CHG )
4447         change = wxJOY_BUTTON1;
4448     if ( flags & JOY_BUTTON2CHG )
4449         change = wxJOY_BUTTON2;
4450     if ( flags & JOY_BUTTON3CHG )
4451         change = wxJOY_BUTTON3;
4452     if ( flags & JOY_BUTTON4CHG )
4453         change = wxJOY_BUTTON4;
4454
4455     int buttons = 0;
4456     if ( flags & JOY_BUTTON1 )
4457         buttons |= wxJOY_BUTTON1;
4458     if ( flags & JOY_BUTTON2 )
4459         buttons |= wxJOY_BUTTON2;
4460     if ( flags & JOY_BUTTON3 )
4461         buttons |= wxJOY_BUTTON3;
4462     if ( flags & JOY_BUTTON4 )
4463         buttons |= wxJOY_BUTTON4;
4464
4465     // the event ids aren't consecutive so we can't use table based lookup
4466     int joystick;
4467     wxEventType eventType;
4468     switch ( msg )
4469     {
4470         case MM_JOY1MOVE:
4471             joystick = 1;
4472             eventType = wxEVT_JOY_MOVE;
4473             break;
4474
4475         case MM_JOY2MOVE:
4476             joystick = 2;
4477             eventType = wxEVT_JOY_MOVE;
4478             break;
4479
4480         case MM_JOY1ZMOVE:
4481             joystick = 1;
4482             eventType = wxEVT_JOY_ZMOVE;
4483             break;
4484
4485         case MM_JOY2ZMOVE:
4486             joystick = 2;
4487             eventType = wxEVT_JOY_ZMOVE;
4488             break;
4489
4490         case MM_JOY1BUTTONDOWN:
4491             joystick = 1;
4492             eventType = wxEVT_JOY_BUTTON_DOWN;
4493             break;
4494
4495         case MM_JOY2BUTTONDOWN:
4496             joystick = 2;
4497             eventType = wxEVT_JOY_BUTTON_DOWN;
4498             break;
4499
4500         case MM_JOY1BUTTONUP:
4501             joystick = 1;
4502             eventType = wxEVT_JOY_BUTTON_UP;
4503             break;
4504
4505         case MM_JOY2BUTTONUP:
4506             joystick = 2;
4507             eventType = wxEVT_JOY_BUTTON_UP;
4508             break;
4509
4510         default:
4511             wxFAIL_MSG(wxT("no such joystick event"));
4512
4513             return FALSE;
4514     }
4515
4516     wxJoystickEvent event(eventType, buttons, joystick, change);
4517     event.SetPosition(wxPoint(x, y));
4518     event.SetEventObject(this);
4519
4520     return GetEventHandler()->ProcessEvent(event);
4521 #else
4522     return FALSE;
4523 #endif
4524 }
4525
4526 // ---------------------------------------------------------------------------
4527 // scrolling
4528 // ---------------------------------------------------------------------------
4529
4530 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
4531                               WXWORD pos, WXHWND control)
4532 {
4533     if ( control )
4534     {
4535         wxWindow *child = wxFindWinFromHandle(control);
4536         if ( child )
4537             return child->MSWOnScroll(orientation, wParam, pos, control);
4538     }
4539
4540     wxScrollWinEvent event;
4541     event.SetPosition(pos);
4542     event.SetOrientation(orientation);
4543     event.m_eventObject = this;
4544
4545     switch ( wParam )
4546     {
4547     case SB_TOP:
4548         event.m_eventType = wxEVT_SCROLLWIN_TOP;
4549         break;
4550
4551     case SB_BOTTOM:
4552         event.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
4553         break;
4554
4555     case SB_LINEUP:
4556         event.m_eventType = wxEVT_SCROLLWIN_LINEUP;
4557         break;
4558
4559     case SB_LINEDOWN:
4560         event.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
4561         break;
4562
4563     case SB_PAGEUP:
4564         event.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
4565         break;
4566
4567     case SB_PAGEDOWN:
4568         event.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
4569         break;
4570
4571     case SB_THUMBPOSITION:
4572     case SB_THUMBTRACK:
4573 #ifdef __WIN32__
4574         // under Win32, the scrollbar range and position are 32 bit integers,
4575         // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4576         // explicitly query the scrollbar for the correct position (this must
4577         // be done only for these two SB_ events as they are the only one
4578         // carrying the scrollbar position)
4579         {
4580             WinStruct<SCROLLINFO> scrollInfo;
4581             scrollInfo.fMask = SIF_TRACKPOS;
4582
4583             if ( !::GetScrollInfo(GetHwnd(),
4584                                   orientation == wxHORIZONTAL ? SB_HORZ
4585                                                               : SB_VERT,
4586                                   &scrollInfo) )
4587             {
4588                 wxLogLastError(_T("GetScrollInfo"));
4589             }
4590
4591             event.SetPosition(scrollInfo.nTrackPos);
4592         }
4593 #endif // Win32
4594
4595         event.m_eventType = wParam == SB_THUMBPOSITION
4596                                 ? wxEVT_SCROLLWIN_THUMBRELEASE
4597                                 : wxEVT_SCROLLWIN_THUMBTRACK;
4598         break;
4599
4600     default:
4601         return FALSE;
4602     }
4603
4604     return GetEventHandler()->ProcessEvent(event);
4605 }
4606
4607 // ===========================================================================
4608 // global functions
4609 // ===========================================================================
4610
4611 void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
4612 {
4613     TEXTMETRIC tm;
4614     HDC dc = ::GetDC((HWND) wnd);
4615     HFONT fnt =0;
4616     HFONT was = 0;
4617     if ( the_font )
4618     {
4619         //    the_font->UseResource();
4620         //    the_font->RealizeResource();
4621         fnt = (HFONT)((wxFont *)the_font)->GetResourceHandle(); // const_cast
4622         if ( fnt )
4623             was = (HFONT) SelectObject(dc,fnt);
4624     }
4625     GetTextMetrics(dc, &tm);
4626     if ( the_font && fnt && was )
4627     {
4628         SelectObject(dc,was);
4629     }
4630     ReleaseDC((HWND)wnd, dc);
4631
4632     if ( x )
4633         *x = tm.tmAveCharWidth;
4634     if ( y )
4635         *y = tm.tmHeight + tm.tmExternalLeading;
4636
4637     //  if ( the_font )
4638     //    the_font->ReleaseResource();
4639 }
4640
4641 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4642 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4643 int wxCharCodeMSWToWX(int keySym)
4644 {
4645     int id;
4646     switch (keySym)
4647     {
4648         case VK_CANCEL:     id = WXK_CANCEL; break;
4649         case VK_BACK:       id = WXK_BACK; break;
4650         case VK_TAB:        id = WXK_TAB; break;
4651         case VK_CLEAR:      id = WXK_CLEAR; break;
4652         case VK_RETURN:     id = WXK_RETURN; break;
4653         case VK_SHIFT:      id = WXK_SHIFT; break;
4654         case VK_CONTROL:    id = WXK_CONTROL; break;
4655         case VK_MENU :      id = WXK_MENU; break;
4656         case VK_PAUSE:      id = WXK_PAUSE; break;
4657         case VK_CAPITAL:    id = WXK_CAPITAL; break;
4658         case VK_SPACE:      id = WXK_SPACE; break;
4659         case VK_ESCAPE:     id = WXK_ESCAPE; break;
4660         case VK_PRIOR:      id = WXK_PRIOR; break;
4661         case VK_NEXT :      id = WXK_NEXT; break;
4662         case VK_END:        id = WXK_END; break;
4663         case VK_HOME :      id = WXK_HOME; break;
4664         case VK_LEFT :      id = WXK_LEFT; break;
4665         case VK_UP:         id = WXK_UP; break;
4666         case VK_RIGHT:      id = WXK_RIGHT; break;
4667         case VK_DOWN :      id = WXK_DOWN; break;
4668         case VK_SELECT:     id = WXK_SELECT; break;
4669         case VK_PRINT:      id = WXK_PRINT; break;
4670         case VK_EXECUTE:    id = WXK_EXECUTE; break;
4671         case VK_INSERT:     id = WXK_INSERT; break;
4672         case VK_DELETE:     id = WXK_DELETE; break;
4673         case VK_HELP :      id = WXK_HELP; break;
4674         case VK_NUMPAD0:    id = WXK_NUMPAD0; break;
4675         case VK_NUMPAD1:    id = WXK_NUMPAD1; break;
4676         case VK_NUMPAD2:    id = WXK_NUMPAD2; break;
4677         case VK_NUMPAD3:    id = WXK_NUMPAD3; break;
4678         case VK_NUMPAD4:    id = WXK_NUMPAD4; break;
4679         case VK_NUMPAD5:    id = WXK_NUMPAD5; break;
4680         case VK_NUMPAD6:    id = WXK_NUMPAD6; break;
4681         case VK_NUMPAD7:    id = WXK_NUMPAD7; break;
4682         case VK_NUMPAD8:    id = WXK_NUMPAD8; break;
4683         case VK_NUMPAD9:    id = WXK_NUMPAD9; break;
4684         case VK_MULTIPLY:   id = WXK_NUMPAD_MULTIPLY; break;
4685         case VK_ADD:        id = WXK_NUMPAD_ADD; break;
4686         case VK_SUBTRACT:   id = WXK_NUMPAD_SUBTRACT; break;
4687         case VK_DECIMAL:    id = WXK_NUMPAD_DECIMAL; break;
4688         case VK_DIVIDE:     id = WXK_NUMPAD_DIVIDE; break;
4689         case VK_F1:         id = WXK_F1; break;
4690         case VK_F2:         id = WXK_F2; break;
4691         case VK_F3:         id = WXK_F3; break;
4692         case VK_F4:         id = WXK_F4; break;
4693         case VK_F5:         id = WXK_F5; break;
4694         case VK_F6:         id = WXK_F6; break;
4695         case VK_F7:         id = WXK_F7; break;
4696         case VK_F8:         id = WXK_F8; break;
4697         case VK_F9:         id = WXK_F9; break;
4698         case VK_F10:        id = WXK_F10; break;
4699         case VK_F11:        id = WXK_F11; break;
4700         case VK_F12:        id = WXK_F12; break;
4701         case VK_F13:        id = WXK_F13; break;
4702         case VK_F14:        id = WXK_F14; break;
4703         case VK_F15:        id = WXK_F15; break;
4704         case VK_F16:        id = WXK_F16; break;
4705         case VK_F17:        id = WXK_F17; break;
4706         case VK_F18:        id = WXK_F18; break;
4707         case VK_F19:        id = WXK_F19; break;
4708         case VK_F20:        id = WXK_F20; break;
4709         case VK_F21:        id = WXK_F21; break;
4710         case VK_F22:        id = WXK_F22; break;
4711         case VK_F23:        id = WXK_F23; break;
4712         case VK_F24:        id = WXK_F24; break;
4713         case VK_NUMLOCK:    id = WXK_NUMLOCK; break;
4714         case VK_SCROLL:     id = WXK_SCROLL; break;
4715
4716         case VK_OEM_1:      id = ';'; break;
4717         case VK_OEM_PLUS:   id = '+'; break;
4718         case VK_OEM_COMMA:  id = ','; break;
4719         case VK_OEM_MINUS:  id = '-'; break;
4720         case VK_OEM_PERIOD: id = '.'; break;
4721         case VK_OEM_2:      id = '/'; break;
4722         case VK_OEM_3:      id = '~'; break;
4723         case VK_OEM_4:      id = '['; break;
4724         case VK_OEM_5:      id = '\\'; break;
4725         case VK_OEM_6:      id = ']'; break;
4726         case VK_OEM_7:      id = '\''; break;
4727
4728 #ifdef VK_APPS
4729         case VK_LWIN:       id = WXK_WINDOWS_LEFT; break;
4730         case VK_RWIN:       id = WXK_WINDOWS_RIGHT; break;
4731         case VK_APPS:       id = WXK_WINDOWS_MENU; break;
4732 #endif // VK_APPS defined
4733
4734         default:
4735             id = 0;
4736     }
4737
4738     return id;
4739 }
4740
4741 int wxCharCodeWXToMSW(int id, bool *isVirtual)
4742 {
4743     *isVirtual = TRUE;
4744     int keySym = 0;
4745     switch (id)
4746     {
4747     case WXK_CANCEL:    keySym = VK_CANCEL; break;
4748     case WXK_CLEAR:     keySym = VK_CLEAR; break;
4749     case WXK_SHIFT:     keySym = VK_SHIFT; break;
4750     case WXK_CONTROL:   keySym = VK_CONTROL; break;
4751     case WXK_MENU :     keySym = VK_MENU; break;
4752     case WXK_PAUSE:     keySym = VK_PAUSE; break;
4753     case WXK_PRIOR:     keySym = VK_PRIOR; break;
4754     case WXK_NEXT :     keySym = VK_NEXT; break;
4755     case WXK_END:       keySym = VK_END; break;
4756     case WXK_HOME :     keySym = VK_HOME; break;
4757     case WXK_LEFT :     keySym = VK_LEFT; break;
4758     case WXK_UP:        keySym = VK_UP; break;
4759     case WXK_RIGHT:     keySym = VK_RIGHT; break;
4760     case WXK_DOWN :     keySym = VK_DOWN; break;
4761     case WXK_SELECT:    keySym = VK_SELECT; break;
4762     case WXK_PRINT:     keySym = VK_PRINT; break;
4763     case WXK_EXECUTE:   keySym = VK_EXECUTE; break;
4764     case WXK_INSERT:    keySym = VK_INSERT; break;
4765     case WXK_DELETE:    keySym = VK_DELETE; break;
4766     case WXK_HELP :     keySym = VK_HELP; break;
4767     case WXK_NUMPAD0:   keySym = VK_NUMPAD0; break;
4768     case WXK_NUMPAD1:   keySym = VK_NUMPAD1; break;
4769     case WXK_NUMPAD2:   keySym = VK_NUMPAD2; break;
4770     case WXK_NUMPAD3:   keySym = VK_NUMPAD3; break;
4771     case WXK_NUMPAD4:   keySym = VK_NUMPAD4; break;
4772     case WXK_NUMPAD5:   keySym = VK_NUMPAD5; break;
4773     case WXK_NUMPAD6:   keySym = VK_NUMPAD6; break;
4774     case WXK_NUMPAD7:   keySym = VK_NUMPAD7; break;
4775     case WXK_NUMPAD8:   keySym = VK_NUMPAD8; break;
4776     case WXK_NUMPAD9:   keySym = VK_NUMPAD9; break;
4777     case WXK_NUMPAD_MULTIPLY:  keySym = VK_MULTIPLY; break;
4778     case WXK_NUMPAD_ADD:       keySym = VK_ADD; break;
4779     case WXK_NUMPAD_SUBTRACT:  keySym = VK_SUBTRACT; break;
4780     case WXK_NUMPAD_DECIMAL:   keySym = VK_DECIMAL; break;
4781     case WXK_NUMPAD_DIVIDE:    keySym = VK_DIVIDE; break;
4782     case WXK_F1:        keySym = VK_F1; break;
4783     case WXK_F2:        keySym = VK_F2; break;
4784     case WXK_F3:        keySym = VK_F3; break;
4785     case WXK_F4:        keySym = VK_F4; break;
4786     case WXK_F5:        keySym = VK_F5; break;
4787     case WXK_F6:        keySym = VK_F6; break;
4788     case WXK_F7:        keySym = VK_F7; break;
4789     case WXK_F8:        keySym = VK_F8; break;
4790     case WXK_F9:        keySym = VK_F9; break;
4791     case WXK_F10:       keySym = VK_F10; break;
4792     case WXK_F11:       keySym = VK_F11; break;
4793     case WXK_F12:       keySym = VK_F12; break;
4794     case WXK_F13:       keySym = VK_F13; break;
4795     case WXK_F14:       keySym = VK_F14; break;
4796     case WXK_F15:       keySym = VK_F15; break;
4797     case WXK_F16:       keySym = VK_F16; break;
4798     case WXK_F17:       keySym = VK_F17; break;
4799     case WXK_F18:       keySym = VK_F18; break;
4800     case WXK_F19:       keySym = VK_F19; break;
4801     case WXK_F20:       keySym = VK_F20; break;
4802     case WXK_F21:       keySym = VK_F21; break;
4803     case WXK_F22:       keySym = VK_F22; break;
4804     case WXK_F23:       keySym = VK_F23; break;
4805     case WXK_F24:       keySym = VK_F24; break;
4806     case WXK_NUMLOCK:   keySym = VK_NUMLOCK; break;
4807     case WXK_SCROLL:    keySym = VK_SCROLL; break;
4808     default:
4809         {
4810             *isVirtual = FALSE;
4811             keySym = id;
4812             break;
4813         }
4814     }
4815     return keySym;
4816 }
4817
4818 wxWindow *wxGetActiveWindow()
4819 {
4820     HWND hWnd = GetActiveWindow();
4821     if ( hWnd != 0 )
4822     {
4823         return wxFindWinFromHandle((WXHWND) hWnd);
4824     }
4825     return NULL;
4826 }
4827
4828 extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
4829 {
4830     HWND hwnd = (HWND)hWnd;
4831
4832     // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4833     // by code in msw/radiobox.cpp), for all the others we just search up the
4834     // window hierarchy
4835     wxWindow *win = (wxWindow *)NULL;
4836     if ( hwnd )
4837     {
4838         win = wxFindWinFromHandle((WXHWND)hwnd);
4839         if ( !win )
4840         {
4841             // all these hacks only work under Win32 anyhow
4842 #ifdef __WIN32__
4843
4844 #if wxUSE_RADIOBOX
4845             // native radiobuttons return DLGC_RADIOBUTTON here and for any
4846             // wxWindow class which overrides WM_GETDLGCODE processing to
4847             // do it as well, win would be already non NULL
4848             if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
4849             {
4850                 win = (wxWindow *)::GetWindowLong(hwnd, GWL_USERDATA);
4851             }
4852             //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4853 #endif // wxUSE_RADIOBOX
4854
4855             // spin control text buddy window should be mapped to spin ctrl
4856             // itself so try it too
4857 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4858             if ( !win )
4859             {
4860                 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
4861             }
4862 #endif // wxUSE_SPINCTRL
4863
4864 #endif // Win32
4865         }
4866     }
4867
4868     while ( hwnd && !win )
4869     {
4870         // this is a really ugly hack needed to avoid mistakenly returning the
4871         // parent frame wxWindow for the find/replace modeless dialog HWND -
4872         // this, in turn, is needed to call IsDialogMessage() from
4873         // wxApp::ProcessMessage() as for this we must return NULL from here
4874         //
4875         // FIXME: this is clearly not the best way to do it but I think we'll
4876         //        need to change HWND <-> wxWindow code more heavily than I can
4877         //        do it now to fix it
4878 #ifndef __WXMICROWIN__
4879         if ( ::GetWindow(hwnd, GW_OWNER) )
4880         {
4881             // it's a dialog box, don't go upwards
4882             break;
4883         }
4884 #endif
4885
4886         hwnd = ::GetParent(hwnd);
4887         win = wxFindWinFromHandle((WXHWND)hwnd);
4888     }
4889
4890     return win;
4891 }
4892
4893 #ifndef __WXMICROWIN__
4894
4895 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4896 // in active frames and dialogs, regardless of where the focus is.
4897 static HHOOK wxTheKeyboardHook = 0;
4898 static FARPROC wxTheKeyboardHookProc = 0;
4899 int APIENTRY _EXPORT
4900 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
4901
4902 void wxSetKeyboardHook(bool doIt)
4903 {
4904     if ( doIt )
4905     {
4906         wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
4907         wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
4908
4909 #if defined(__WIN32__)
4910             GetCurrentThreadId()
4911         //      (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4912 #else
4913             GetCurrentTask()
4914 #endif
4915             );
4916     }
4917     else
4918     {
4919         UnhookWindowsHookEx(wxTheKeyboardHook);
4920
4921         // avoids warning about statement with no effect (FreeProcInstance
4922         // doesn't do anything under Win32)
4923 #if !defined(__WIN32__) && !defined(__NT__)
4924         FreeProcInstance(wxTheKeyboardHookProc);
4925 #endif
4926     }
4927 }
4928
4929 int APIENTRY _EXPORT
4930 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
4931 {
4932     DWORD hiWord = HIWORD(lParam);
4933     if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
4934     {
4935         int id = wxCharCodeMSWToWX(wParam);
4936         if ( id != 0 )
4937         {
4938             wxKeyEvent event(wxEVT_CHAR_HOOK);
4939             if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
4940                 event.m_altDown = TRUE;
4941
4942             event.m_eventObject = NULL;
4943             event.m_keyCode = id;
4944             event.m_shiftDown = wxIsShiftDown();
4945             event.m_controlDown = wxIsCtrlDown();
4946             event.SetTimestamp(s_currentMsg.time);
4947
4948             wxWindow *win = wxGetActiveWindow();
4949             wxEvtHandler *handler;
4950             if ( win )
4951             {
4952                 handler = win->GetEventHandler();
4953                 event.SetId(win->GetId());
4954             }
4955             else
4956             {
4957                 handler = wxTheApp;
4958                 event.SetId(-1);
4959             }
4960
4961             if ( handler && handler->ProcessEvent(event) )
4962             {
4963                 // processed
4964                 return 1;
4965             }
4966         }
4967     }
4968
4969     return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
4970 }
4971
4972 #endif // !__WXMICROWIN__
4973
4974 #ifdef __WXDEBUG__
4975 const char *wxGetMessageName(int message)
4976 {
4977     switch ( message )
4978     {
4979         case 0x0000: return "WM_NULL";
4980         case 0x0001: return "WM_CREATE";
4981         case 0x0002: return "WM_DESTROY";
4982         case 0x0003: return "WM_MOVE";
4983         case 0x0005: return "WM_SIZE";
4984         case 0x0006: return "WM_ACTIVATE";
4985         case 0x0007: return "WM_SETFOCUS";
4986         case 0x0008: return "WM_KILLFOCUS";
4987         case 0x000A: return "WM_ENABLE";
4988         case 0x000B: return "WM_SETREDRAW";
4989         case 0x000C: return "WM_SETTEXT";
4990         case 0x000D: return "WM_GETTEXT";
4991         case 0x000E: return "WM_GETTEXTLENGTH";
4992         case 0x000F: return "WM_PAINT";
4993         case 0x0010: return "WM_CLOSE";
4994         case 0x0011: return "WM_QUERYENDSESSION";
4995         case 0x0012: return "WM_QUIT";
4996         case 0x0013: return "WM_QUERYOPEN";
4997         case 0x0014: return "WM_ERASEBKGND";
4998         case 0x0015: return "WM_SYSCOLORCHANGE";
4999         case 0x0016: return "WM_ENDSESSION";
5000         case 0x0017: return "WM_SYSTEMERROR";
5001         case 0x0018: return "WM_SHOWWINDOW";
5002         case 0x0019: return "WM_CTLCOLOR";
5003         case 0x001A: return "WM_WININICHANGE";
5004         case 0x001B: return "WM_DEVMODECHANGE";
5005         case 0x001C: return "WM_ACTIVATEAPP";
5006         case 0x001D: return "WM_FONTCHANGE";
5007         case 0x001E: return "WM_TIMECHANGE";
5008         case 0x001F: return "WM_CANCELMODE";
5009         case 0x0020: return "WM_SETCURSOR";
5010         case 0x0021: return "WM_MOUSEACTIVATE";
5011         case 0x0022: return "WM_CHILDACTIVATE";
5012         case 0x0023: return "WM_QUEUESYNC";
5013         case 0x0024: return "WM_GETMINMAXINFO";
5014         case 0x0026: return "WM_PAINTICON";
5015         case 0x0027: return "WM_ICONERASEBKGND";
5016         case 0x0028: return "WM_NEXTDLGCTL";
5017         case 0x002A: return "WM_SPOOLERSTATUS";
5018         case 0x002B: return "WM_DRAWITEM";
5019         case 0x002C: return "WM_MEASUREITEM";
5020         case 0x002D: return "WM_DELETEITEM";
5021         case 0x002E: return "WM_VKEYTOITEM";
5022         case 0x002F: return "WM_CHARTOITEM";
5023         case 0x0030: return "WM_SETFONT";
5024         case 0x0031: return "WM_GETFONT";
5025         case 0x0037: return "WM_QUERYDRAGICON";
5026         case 0x0039: return "WM_COMPAREITEM";
5027         case 0x0041: return "WM_COMPACTING";
5028         case 0x0044: return "WM_COMMNOTIFY";
5029         case 0x0046: return "WM_WINDOWPOSCHANGING";
5030         case 0x0047: return "WM_WINDOWPOSCHANGED";
5031         case 0x0048: return "WM_POWER";
5032
5033 #ifdef  __WIN32__
5034         case 0x004A: return "WM_COPYDATA";
5035         case 0x004B: return "WM_CANCELJOURNAL";
5036         case 0x004E: return "WM_NOTIFY";
5037         case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5038         case 0x0051: return "WM_INPUTLANGCHANGE";
5039         case 0x0052: return "WM_TCARD";
5040         case 0x0053: return "WM_HELP";
5041         case 0x0054: return "WM_USERCHANGED";
5042         case 0x0055: return "WM_NOTIFYFORMAT";
5043         case 0x007B: return "WM_CONTEXTMENU";
5044         case 0x007C: return "WM_STYLECHANGING";
5045         case 0x007D: return "WM_STYLECHANGED";
5046         case 0x007E: return "WM_DISPLAYCHANGE";
5047         case 0x007F: return "WM_GETICON";
5048         case 0x0080: return "WM_SETICON";
5049 #endif  //WIN32
5050
5051         case 0x0081: return "WM_NCCREATE";
5052         case 0x0082: return "WM_NCDESTROY";
5053         case 0x0083: return "WM_NCCALCSIZE";
5054         case 0x0084: return "WM_NCHITTEST";
5055         case 0x0085: return "WM_NCPAINT";
5056         case 0x0086: return "WM_NCACTIVATE";
5057         case 0x0087: return "WM_GETDLGCODE";
5058         case 0x00A0: return "WM_NCMOUSEMOVE";
5059         case 0x00A1: return "WM_NCLBUTTONDOWN";
5060         case 0x00A2: return "WM_NCLBUTTONUP";
5061         case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5062         case 0x00A4: return "WM_NCRBUTTONDOWN";
5063         case 0x00A5: return "WM_NCRBUTTONUP";
5064         case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5065         case 0x00A7: return "WM_NCMBUTTONDOWN";
5066         case 0x00A8: return "WM_NCMBUTTONUP";
5067         case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5068         case 0x0100: return "WM_KEYDOWN";
5069         case 0x0101: return "WM_KEYUP";
5070         case 0x0102: return "WM_CHAR";
5071         case 0x0103: return "WM_DEADCHAR";
5072         case 0x0104: return "WM_SYSKEYDOWN";
5073         case 0x0105: return "WM_SYSKEYUP";
5074         case 0x0106: return "WM_SYSCHAR";
5075         case 0x0107: return "WM_SYSDEADCHAR";
5076         case 0x0108: return "WM_KEYLAST";
5077
5078 #ifdef  __WIN32__
5079         case 0x010D: return "WM_IME_STARTCOMPOSITION";
5080         case 0x010E: return "WM_IME_ENDCOMPOSITION";
5081         case 0x010F: return "WM_IME_COMPOSITION";
5082 #endif  //WIN32
5083
5084         case 0x0110: return "WM_INITDIALOG";
5085         case 0x0111: return "WM_COMMAND";
5086         case 0x0112: return "WM_SYSCOMMAND";
5087         case 0x0113: return "WM_TIMER";
5088         case 0x0114: return "WM_HSCROLL";
5089         case 0x0115: return "WM_VSCROLL";
5090         case 0x0116: return "WM_INITMENU";
5091         case 0x0117: return "WM_INITMENUPOPUP";
5092         case 0x011F: return "WM_MENUSELECT";
5093         case 0x0120: return "WM_MENUCHAR";
5094         case 0x0121: return "WM_ENTERIDLE";
5095         case 0x0200: return "WM_MOUSEMOVE";
5096         case 0x0201: return "WM_LBUTTONDOWN";
5097         case 0x0202: return "WM_LBUTTONUP";
5098         case 0x0203: return "WM_LBUTTONDBLCLK";
5099         case 0x0204: return "WM_RBUTTONDOWN";
5100         case 0x0205: return "WM_RBUTTONUP";
5101         case 0x0206: return "WM_RBUTTONDBLCLK";
5102         case 0x0207: return "WM_MBUTTONDOWN";
5103         case 0x0208: return "WM_MBUTTONUP";
5104         case 0x0209: return "WM_MBUTTONDBLCLK";
5105         case 0x020A: return "WM_MOUSEWHEEL";
5106         case 0x0210: return "WM_PARENTNOTIFY";
5107         case 0x0211: return "WM_ENTERMENULOOP";
5108         case 0x0212: return "WM_EXITMENULOOP";
5109
5110 #ifdef  __WIN32__
5111         case 0x0213: return "WM_NEXTMENU";
5112         case 0x0214: return "WM_SIZING";
5113         case 0x0215: return "WM_CAPTURECHANGED";
5114         case 0x0216: return "WM_MOVING";
5115         case 0x0218: return "WM_POWERBROADCAST";
5116         case 0x0219: return "WM_DEVICECHANGE";
5117 #endif  //WIN32
5118
5119         case 0x0220: return "WM_MDICREATE";
5120         case 0x0221: return "WM_MDIDESTROY";
5121         case 0x0222: return "WM_MDIACTIVATE";
5122         case 0x0223: return "WM_MDIRESTORE";
5123         case 0x0224: return "WM_MDINEXT";
5124         case 0x0225: return "WM_MDIMAXIMIZE";
5125         case 0x0226: return "WM_MDITILE";
5126         case 0x0227: return "WM_MDICASCADE";
5127         case 0x0228: return "WM_MDIICONARRANGE";
5128         case 0x0229: return "WM_MDIGETACTIVE";
5129         case 0x0230: return "WM_MDISETMENU";
5130         case 0x0233: return "WM_DROPFILES";
5131
5132 #ifdef  __WIN32__
5133         case 0x0281: return "WM_IME_SETCONTEXT";
5134         case 0x0282: return "WM_IME_NOTIFY";
5135         case 0x0283: return "WM_IME_CONTROL";
5136         case 0x0284: return "WM_IME_COMPOSITIONFULL";
5137         case 0x0285: return "WM_IME_SELECT";
5138         case 0x0286: return "WM_IME_CHAR";
5139         case 0x0290: return "WM_IME_KEYDOWN";
5140         case 0x0291: return "WM_IME_KEYUP";
5141 #endif  //WIN32
5142
5143         case 0x0300: return "WM_CUT";
5144         case 0x0301: return "WM_COPY";
5145         case 0x0302: return "WM_PASTE";
5146         case 0x0303: return "WM_CLEAR";
5147         case 0x0304: return "WM_UNDO";
5148         case 0x0305: return "WM_RENDERFORMAT";
5149         case 0x0306: return "WM_RENDERALLFORMATS";
5150         case 0x0307: return "WM_DESTROYCLIPBOARD";
5151         case 0x0308: return "WM_DRAWCLIPBOARD";
5152         case 0x0309: return "WM_PAINTCLIPBOARD";
5153         case 0x030A: return "WM_VSCROLLCLIPBOARD";
5154         case 0x030B: return "WM_SIZECLIPBOARD";
5155         case 0x030C: return "WM_ASKCBFORMATNAME";
5156         case 0x030D: return "WM_CHANGECBCHAIN";
5157         case 0x030E: return "WM_HSCROLLCLIPBOARD";
5158         case 0x030F: return "WM_QUERYNEWPALETTE";
5159         case 0x0310: return "WM_PALETTEISCHANGING";
5160         case 0x0311: return "WM_PALETTECHANGED";
5161
5162 #ifdef __WIN32__
5163         // common controls messages - although they're not strictly speaking
5164         // standard, it's nice to decode them nevertheless
5165
5166         // listview
5167         case 0x1000 + 0: return "LVM_GETBKCOLOR";
5168         case 0x1000 + 1: return "LVM_SETBKCOLOR";
5169         case 0x1000 + 2: return "LVM_GETIMAGELIST";
5170         case 0x1000 + 3: return "LVM_SETIMAGELIST";
5171         case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5172         case 0x1000 + 5: return "LVM_GETITEMA";
5173         case 0x1000 + 75: return "LVM_GETITEMW";
5174         case 0x1000 + 6: return "LVM_SETITEMA";
5175         case 0x1000 + 76: return "LVM_SETITEMW";
5176         case 0x1000 + 7: return "LVM_INSERTITEMA";
5177         case 0x1000 + 77: return "LVM_INSERTITEMW";
5178         case 0x1000 + 8: return "LVM_DELETEITEM";
5179         case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5180         case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5181         case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5182         case 0x1000 + 12: return "LVM_GETNEXTITEM";
5183         case 0x1000 + 13: return "LVM_FINDITEMA";
5184         case 0x1000 + 83: return "LVM_FINDITEMW";
5185         case 0x1000 + 14: return "LVM_GETITEMRECT";
5186         case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5187         case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5188         case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5189         case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5190         case 0x1000 + 18: return "LVM_HITTEST";
5191         case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5192         case 0x1000 + 20: return "LVM_SCROLL";
5193         case 0x1000 + 21: return "LVM_REDRAWITEMS";
5194         case 0x1000 + 22: return "LVM_ARRANGE";
5195         case 0x1000 + 23: return "LVM_EDITLABELA";
5196         case 0x1000 + 118: return "LVM_EDITLABELW";
5197         case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5198         case 0x1000 + 25: return "LVM_GETCOLUMNA";
5199         case 0x1000 + 95: return "LVM_GETCOLUMNW";
5200         case 0x1000 + 26: return "LVM_SETCOLUMNA";
5201         case 0x1000 + 96: return "LVM_SETCOLUMNW";
5202         case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5203         case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5204         case 0x1000 + 28: return "LVM_DELETECOLUMN";
5205         case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5206         case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5207         case 0x1000 + 31: return "LVM_GETHEADER";
5208         case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5209         case 0x1000 + 34: return "LVM_GETVIEWRECT";
5210         case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5211         case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5212         case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5213         case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5214         case 0x1000 + 39: return "LVM_GETTOPINDEX";
5215         case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5216         case 0x1000 + 41: return "LVM_GETORIGIN";
5217         case 0x1000 + 42: return "LVM_UPDATE";
5218         case 0x1000 + 43: return "LVM_SETITEMSTATE";
5219         case 0x1000 + 44: return "LVM_GETITEMSTATE";
5220         case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5221         case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5222         case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5223         case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5224         case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5225         case 0x1000 + 48: return "LVM_SORTITEMS";
5226         case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5227         case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5228         case 0x1000 + 51: return "LVM_GETITEMSPACING";
5229         case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5230         case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5231         case 0x1000 + 53: return "LVM_SETICONSPACING";
5232         case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5233         case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5234         case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5235         case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5236         case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5237         case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5238         case 0x1000 + 60: return "LVM_SETHOTITEM";
5239         case 0x1000 + 61: return "LVM_GETHOTITEM";
5240         case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5241         case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5242         case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5243         case 0x1000 + 65: return "LVM_SETWORKAREA";
5244
5245         // tree view
5246         case 0x1100 + 0: return "TVM_INSERTITEMA";
5247         case 0x1100 + 50: return "TVM_INSERTITEMW";
5248         case 0x1100 + 1: return "TVM_DELETEITEM";
5249         case 0x1100 + 2: return "TVM_EXPAND";
5250         case 0x1100 + 4: return "TVM_GETITEMRECT";
5251         case 0x1100 + 5: return "TVM_GETCOUNT";
5252         case 0x1100 + 6: return "TVM_GETINDENT";
5253         case 0x1100 + 7: return "TVM_SETINDENT";
5254         case 0x1100 + 8: return "TVM_GETIMAGELIST";
5255         case 0x1100 + 9: return "TVM_SETIMAGELIST";
5256         case 0x1100 + 10: return "TVM_GETNEXTITEM";
5257         case 0x1100 + 11: return "TVM_SELECTITEM";
5258         case 0x1100 + 12: return "TVM_GETITEMA";
5259         case 0x1100 + 62: return "TVM_GETITEMW";
5260         case 0x1100 + 13: return "TVM_SETITEMA";
5261         case 0x1100 + 63: return "TVM_SETITEMW";
5262         case 0x1100 + 14: return "TVM_EDITLABELA";
5263         case 0x1100 + 65: return "TVM_EDITLABELW";
5264         case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5265         case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5266         case 0x1100 + 17: return "TVM_HITTEST";
5267         case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5268         case 0x1100 + 19: return "TVM_SORTCHILDREN";
5269         case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5270         case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5271         case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5272         case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5273         case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5274         case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5275         case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5276
5277         // header
5278         case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5279         case 0x1200 + 1: return "HDM_INSERTITEMA";
5280         case 0x1200 + 10: return "HDM_INSERTITEMW";
5281         case 0x1200 + 2: return "HDM_DELETEITEM";
5282         case 0x1200 + 3: return "HDM_GETITEMA";
5283         case 0x1200 + 11: return "HDM_GETITEMW";
5284         case 0x1200 + 4: return "HDM_SETITEMA";
5285         case 0x1200 + 12: return "HDM_SETITEMW";
5286         case 0x1200 + 5: return "HDM_LAYOUT";
5287         case 0x1200 + 6: return "HDM_HITTEST";
5288         case 0x1200 + 7: return "HDM_GETITEMRECT";
5289         case 0x1200 + 8: return "HDM_SETIMAGELIST";
5290         case 0x1200 + 9: return "HDM_GETIMAGELIST";
5291         case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5292         case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5293         case 0x1200 + 17: return "HDM_GETORDERARRAY";
5294         case 0x1200 + 18: return "HDM_SETORDERARRAY";
5295         case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5296
5297         // tab control
5298         case 0x1300 + 2: return "TCM_GETIMAGELIST";
5299         case 0x1300 + 3: return "TCM_SETIMAGELIST";
5300         case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5301         case 0x1300 + 5: return "TCM_GETITEMA";
5302         case 0x1300 + 60: return "TCM_GETITEMW";
5303         case 0x1300 + 6: return "TCM_SETITEMA";
5304         case 0x1300 + 61: return "TCM_SETITEMW";
5305         case 0x1300 + 7: return "TCM_INSERTITEMA";
5306         case 0x1300 + 62: return "TCM_INSERTITEMW";
5307         case 0x1300 + 8: return "TCM_DELETEITEM";
5308         case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5309         case 0x1300 + 10: return "TCM_GETITEMRECT";
5310         case 0x1300 + 11: return "TCM_GETCURSEL";
5311         case 0x1300 + 12: return "TCM_SETCURSEL";
5312         case 0x1300 + 13: return "TCM_HITTEST";
5313         case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5314         case 0x1300 + 40: return "TCM_ADJUSTRECT";
5315         case 0x1300 + 41: return "TCM_SETITEMSIZE";
5316         case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5317         case 0x1300 + 43: return "TCM_SETPADDING";
5318         case 0x1300 + 44: return "TCM_GETROWCOUNT";
5319         case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5320         case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5321         case 0x1300 + 47: return "TCM_GETCURFOCUS";
5322         case 0x1300 + 48: return "TCM_SETCURFOCUS";
5323         case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5324         case 0x1300 + 50: return "TCM_DESELECTALL";
5325
5326         // toolbar
5327         case WM_USER+1: return "TB_ENABLEBUTTON";
5328         case WM_USER+2: return "TB_CHECKBUTTON";
5329         case WM_USER+3: return "TB_PRESSBUTTON";
5330         case WM_USER+4: return "TB_HIDEBUTTON";
5331         case WM_USER+5: return "TB_INDETERMINATE";
5332         case WM_USER+9: return "TB_ISBUTTONENABLED";
5333         case WM_USER+10: return "TB_ISBUTTONCHECKED";
5334         case WM_USER+11: return "TB_ISBUTTONPRESSED";
5335         case WM_USER+12: return "TB_ISBUTTONHIDDEN";
5336         case WM_USER+13: return "TB_ISBUTTONINDETERMINATE";
5337         case WM_USER+17: return "TB_SETSTATE";
5338         case WM_USER+18: return "TB_GETSTATE";
5339         case WM_USER+19: return "TB_ADDBITMAP";
5340         case WM_USER+20: return "TB_ADDBUTTONS";
5341         case WM_USER+21: return "TB_INSERTBUTTON";
5342         case WM_USER+22: return "TB_DELETEBUTTON";
5343         case WM_USER+23: return "TB_GETBUTTON";
5344         case WM_USER+24: return "TB_BUTTONCOUNT";
5345         case WM_USER+25: return "TB_COMMANDTOINDEX";
5346         case WM_USER+26: return "TB_SAVERESTOREA";
5347         case WM_USER+76: return "TB_SAVERESTOREW";
5348         case WM_USER+27: return "TB_CUSTOMIZE";
5349         case WM_USER+28: return "TB_ADDSTRINGA";
5350         case WM_USER+77: return "TB_ADDSTRINGW";
5351         case WM_USER+29: return "TB_GETITEMRECT";
5352         case WM_USER+30: return "TB_BUTTONSTRUCTSIZE";
5353         case WM_USER+31: return "TB_SETBUTTONSIZE";
5354         case WM_USER+32: return "TB_SETBITMAPSIZE";
5355         case WM_USER+33: return "TB_AUTOSIZE";
5356         case WM_USER+35: return "TB_GETTOOLTIPS";
5357         case WM_USER+36: return "TB_SETTOOLTIPS";
5358         case WM_USER+37: return "TB_SETPARENT";
5359         case WM_USER+39: return "TB_SETROWS";
5360         case WM_USER+40: return "TB_GETROWS";
5361         case WM_USER+42: return "TB_SETCMDID";
5362         case WM_USER+43: return "TB_CHANGEBITMAP";
5363         case WM_USER+44: return "TB_GETBITMAP";
5364         case WM_USER+45: return "TB_GETBUTTONTEXTA";
5365         case WM_USER+75: return "TB_GETBUTTONTEXTW";
5366         case WM_USER+46: return "TB_REPLACEBITMAP";
5367         case WM_USER+47: return "TB_SETINDENT";
5368         case WM_USER+48: return "TB_SETIMAGELIST";
5369         case WM_USER+49: return "TB_GETIMAGELIST";
5370         case WM_USER+50: return "TB_LOADIMAGES";
5371         case WM_USER+51: return "TB_GETRECT";
5372         case WM_USER+52: return "TB_SETHOTIMAGELIST";
5373         case WM_USER+53: return "TB_GETHOTIMAGELIST";
5374         case WM_USER+54: return "TB_SETDISABLEDIMAGELIST";
5375         case WM_USER+55: return "TB_GETDISABLEDIMAGELIST";
5376         case WM_USER+56: return "TB_SETSTYLE";
5377         case WM_USER+57: return "TB_GETSTYLE";
5378         case WM_USER+58: return "TB_GETBUTTONSIZE";
5379         case WM_USER+59: return "TB_SETBUTTONWIDTH";
5380         case WM_USER+60: return "TB_SETMAXTEXTROWS";
5381         case WM_USER+61: return "TB_GETTEXTROWS";
5382         case WM_USER+41: return "TB_GETBITMAPFLAGS";
5383
5384 #endif //WIN32
5385
5386         default:
5387             static char s_szBuf[128];
5388             sprintf(s_szBuf, "<unknown message = %d>", message);
5389             return s_szBuf;
5390     }
5391 }
5392 #endif //__WXDEBUG__
5393
5394 static void TranslateKbdEventToMouse(wxWindowMSW *win,
5395                                      int *x, int *y, WPARAM *flags)
5396 {
5397     // construct the key mask
5398     WPARAM& fwKeys = *flags;
5399
5400     fwKeys = MK_RBUTTON;
5401     if ( wxIsCtrlDown() )
5402         fwKeys |= MK_CONTROL;
5403     if ( wxIsShiftDown() )
5404         fwKeys |= MK_SHIFT;
5405
5406     // simulate right mouse button click
5407     DWORD dwPos = ::GetMessagePos();
5408     *x = GET_X_LPARAM(dwPos);
5409     *y = GET_Y_LPARAM(dwPos);
5410
5411     win->ScreenToClient(x, y);
5412 }
5413
5414 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
5415 {
5416     // prepare the DC
5417     TEXTMETRIC tm;
5418     HWND hwnd = GetHwndOf(win);
5419     HDC hdc = ::GetDC(hwnd);
5420
5421 #if !wxDIALOG_UNIT_COMPATIBILITY
5422     // and select the current font into it
5423     HFONT hfont = GetHfontOf(win->GetFont());
5424     if ( hfont )
5425     {
5426         hfont = (HFONT)::SelectObject(hdc, hfont);
5427     }
5428 #endif
5429
5430     // finally retrieve the text metrics from it
5431     GetTextMetrics(hdc, &tm);
5432
5433 #if !wxDIALOG_UNIT_COMPATIBILITY
5434     // and clean up
5435     if ( hfont )
5436     {
5437         (void)::SelectObject(hdc, hfont);
5438     }
5439 #endif
5440
5441     ::ReleaseDC(hwnd, hdc);
5442
5443     return tm;
5444 }
5445
5446 // Find the wxWindow at the current mouse position, returning the mouse
5447 // position.
5448 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
5449 {
5450     pt = wxGetMousePosition();
5451     return wxFindWindowAtPoint(pt);
5452 }
5453
5454 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
5455 {
5456     POINT pt2;
5457     pt2.x = pt.x;
5458     pt2.y = pt.y;
5459     HWND hWndHit = ::WindowFromPoint(pt2);
5460
5461     wxWindow* win = wxFindWinFromHandle((WXHWND) hWndHit) ;
5462     HWND hWnd = hWndHit;
5463
5464     // Try to find a window with a wxWindow associated with it
5465     while (!win && (hWnd != 0))
5466     {
5467         hWnd = ::GetParent(hWnd);
5468         win = wxFindWinFromHandle((WXHWND) hWnd) ;
5469     }
5470     return win;
5471 }
5472
5473 // Get the current mouse position.
5474 wxPoint wxGetMousePosition()
5475 {
5476     POINT pt;
5477     GetCursorPos( & pt );
5478
5479     return wxPoint(pt.x, pt.y);
5480 }
5481