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