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