src/msw/window.cpp

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