src/msw/window.cpp

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