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