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