src/msw/window.cpp

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