src/msw/window.cpp

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