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