src/msw/window.cpp

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