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