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