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