src/os2/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        windows.cpp
   3 // Purpose:     wxWindow
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     10/12/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 //
  13 // For compilers that support precompilation, includes "wx.h".
  14 //
  15 #include "wx/wxprec.h"
  16
  17 #ifndef WX_PRECOMP
  18     #define INCL_DOS
  19     #define INCL_PM
  20     #include <os2.h>
  21     #include "wx/window.h"
  22     #include "wx/accel.h"
  23     #include "wx/setup.h"
  24     #include "wx/menu.h"
  25     #include "wx/dc.h"
  26     #include "wx/dcclient.h"
  27     #include "wx/utils.h"
  28     #include "wx/app.h"
  29     #include "wx/panel.h"
  30     #include "wx/layout.h"
  31     #include "wx/dialog.h"
  32     #include "wx/frame.h"
  33     #include "wx/listbox.h"
  34     #include "wx/button.h"
  35     #include "wx/msgdlg.h"
  36
  37     #include <stdio.h>
  38 #endif
  39
  40 #if     wxUSE_OWNER_DRAWN
  41     #include "wx/ownerdrw.h"
  42 #endif
  43
  44 #if     wxUSE_DRAG_AND_DROP
  45     #include "wx/dnd.h"
  46 #endif
  47
  48 #include "wx/menuitem.h"
  49 #include "wx/log.h"
  50
  51 #include "wx/os2/private.h"
  52
  53 #if wxUSE_TOOLTIPS
  54     #include "wx/tooltip.h"
  55 #endif
  56
  57 #if wxUSE_CARET
  58     #include "wx/caret.h"
  59 #endif // wxUSE_CARET
  60
  61 #include "wx/intl.h"
  62 #include "wx/log.h"
  63
  64
  65 #include "wx/textctrl.h"
  66
  67 #include <string.h>
  68
  69 //
  70 // Place compiler, OS specific includes here
  71 //
  72
  73 //
  74 // Standard macros -- these are for OS/2 PM, but most GUI's have something similar
  75 //
  76 #ifndef GET_X_LPARAM
  77 //
  78 //  SHORT1FROMMP -- LOWORD
  79 //
  80     #define GET_X_LPARAM(mp) ((unsigned short)(unsigned long)(mp))
  81 //
  82 //  SHORT2FROMMP -- HIWORD
  83 //
  84     #define GET_Y_LPARAM(mp) ((unsigned short)(unsigned long)(mp >> 16))
  85 #endif // GET_X_LPARAM
  86
  87 #ifndef CW_USEDEFAULT
  88 #  define CW_USEDEFAULT    ((int)0x80000000)
  89 #endif
  90
  91 // ---------------------------------------------------------------------------
  92 // global variables
  93 // ---------------------------------------------------------------------------
  94
  95 //
  96 // The last Windows message we got (MT-UNSAFE)
  97 //
  98 QMSG                      s_currentMsg;
  99
 100 wxMenu*                   wxCurrentPopupMenu = NULL;
 101 extern wxList WXDLLEXPORT wxPendingDelete;
 102 #if !defined(__VISAGECPP__) || (__IBMCPP__ < 400)
 103 extern wxChar             wxCanvasClassName[];
 104 #endif
 105 wxList*                   wxWinHandleList = NULL;
 106
 107 // ---------------------------------------------------------------------------
 108 // private functions
 109 // ---------------------------------------------------------------------------
 110
 111 //
 112 // the window proc for all our windows; most gui's have something similar
 113 //
 114 MRESULT EXPENTRY wxWndProc( HWND hWnd
 115                            ,ULONG message
 116                            ,MPARAM mp1
 117                            ,MPARAM mp2
 118                           );
 119
 120 #ifdef  __WXDEBUG__
 121     const char *wxGetMessageName(int message);
 122 #endif  //__WXDEBUG__
 123
 124 void      wxRemoveHandleAssociation(wxWindow* pWin);
 125 void      wxAssociateWinWithHandle( HWND      hWnd
 126                                    ,wxWindow* pWin
 127                                   );
 128 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 129
 130 //
 131 // This magical function is used to translate VK_APPS key presses to right
 132 // mouse clicks
 133 //
 134 static void TranslateKbdEventToMouse( wxWindow* pWin
 135                                      ,int*      pX
 136                                      ,int*      pY
 137                                      ,MPARAM*   pFlags
 138                                     );
 139
 140 //
 141 // get the current state of SHIFT/CTRL keys
 142 //
 143 static inline bool IsShiftDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000) != 0; }
 144 static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000) != 0; }
 145 // ---------------------------------------------------------------------------
 146 // event tables
 147 // ---------------------------------------------------------------------------
 148
 149     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 150
 151 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
 152     EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
 153     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
 154     EVT_INIT_DIALOG(wxWindow::OnInitDialog)
 155     EVT_IDLE(wxWindow::OnIdle)
 156     EVT_SET_FOCUS(wxWindow::OnSetFocus)
 157 END_EVENT_TABLE()
 158
 159 // ===========================================================================
 160 // implementation
 161 // ===========================================================================
 162
 163 //
 164 // Find an item given the PM Window id
 165 //
 166 wxWindow* wxWindow::FindItem(
 167   long                              lId
 168 ) const
 169 {
 170     wxControl*                      pItem = wxDynamicCast( this
 171                                                           ,wxControl
 172                                                          );
 173
 174     if (pItem)
 175     {
 176         //
 177         // I it we or one of our "internal" children?
 178         //
 179         if (pItem->GetId() == lId ||
 180              (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND))
 181         {
 182             return pItem;
 183         }
 184     }
 185
 186     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
 187
 188     while (pCurrent)
 189     {
 190         wxWindow*                   pChildWin = pCurrent->GetData();
 191         wxWindow*                   pWnd = pChildWin->FindItem(lId);
 192
 193         if (pWnd)
 194             return pWnd;
 195
 196         pCurrent = pCurrent->GetNext();
 197     }
 198     return(NULL);
 199 } // end of wxWindow::FindItem
 200
 201 //
 202 // Find an item given the PM Window handle
 203 //
 204 wxWindow* wxWindow::FindItemByHWND(
 205   WXHWND                            hWnd
 206 , bool                              bControlOnly
 207 ) const
 208 {
 209     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
 210
 211     while (pCurrent)
 212     {
 213         wxWindow*                   pParent = pCurrent->GetData();
 214
 215         //
 216         // Do a recursive search.
 217         //
 218         wxWindow*                   pWnd = pParent->FindItemByHWND(hWnd);
 219
 220         if (pWnd)
 221             return(pWnd);
 222
 223         if (!bControlOnly || pParent->IsKindOf(CLASSINFO(wxControl)))
 224         {
 225             wxWindow*               pItem = pCurrent->GetData();
 226
 227             if (pItem->GetHWND() == hWnd)
 228                 return(pItem);
 229             else
 230             {
 231                 if (pItem->ContainsHWND(hWnd))
 232                     return(pItem);
 233             }
 234         }
 235         pCurrent = pCurrent->GetNext();
 236     }
 237     return(NULL);
 238 } // end of wxWindow::FindItemByHWND
 239
 240 //
 241 // Default command handler
 242 //
 243 bool wxWindow::OS2Command(
 244   WXUINT                            WXUNUSED(uParam)
 245 , WXWORD                            WXUNUSED(uId)
 246 )
 247 {
 248     return(FALSE);
 249 }
 250
 251 // ----------------------------------------------------------------------------
 252 // constructors and such
 253 // ----------------------------------------------------------------------------
 254
 255 void wxWindow::Init()
 256 {
 257     //
 258     // Generic
 259     //
 260     InitBase();
 261
 262     //
 263     // PM specific
 264     //
 265     m_bDoubleClickAllowed = 0;
 266     m_bWinCaptured = FALSE;
 267
 268     m_isBeingDeleted = FALSE;
 269     m_fnOldWndProc = 0;
 270     m_bUseCtl3D = FALSE;
 271     m_bMouseInWindow = FALSE;
 272
 273     //
 274     // wxWnd
 275     //
 276     m_hMenu = 0;
 277     m_hWnd = 0;
 278
 279     //
 280     // Pass WM_GETDLGCODE to DefWindowProc()
 281     m_lDlgCode = 0;
 282
 283     m_nXThumbSize = 0;
 284     m_nYThumbSize = 0;
 285     m_bBackgroundTransparent = FALSE;
 286
 287     //
 288     // As all windows are created with WS_VISIBLE style...
 289     //
 290     m_isShown = TRUE;
 291
 292 #if wxUSE_MOUSEEVENT_HACK
 293     m_lLastMouseX =
 294     m_lLastMouseY = -1;
 295     m_nLastMouseEvent = -1;
 296 #endif // wxUSE_MOUSEEVENT_HACK
 297 } // wxWindow::Init
 298
 299 //
 300 // Destructor
 301 //
 302 wxWindow::~wxWindow()
 303 {
 304     m_isBeingDeleted = TRUE;
 305
 306     OS2DetachWindowMenu();
 307     if (m_parent)
 308         m_parent->RemoveChild(this);
 309     DestroyChildren();
 310
 311     if (m_hWnd)
 312     {
 313         if(!::WinDestroyWindow(GetHWND()))
 314             wxLogLastError(wxT("DestroyWindow"));
 315         //
 316         // remove hWnd <-> wxWindow association
 317         //
 318         wxRemoveHandleAssociation(this);
 319     }
 320 } // end of wxWindow::~wxWindow
 321
 322 bool wxWindow::Create(
 323   wxWindow*                         pParent
 324 , wxWindowID                        vId
 325 , const wxPoint&                    rPos
 326 , const wxSize&                     rSize
 327 , long                              lStyle
 328 , const wxString&                   rName
 329 )
 330 {
 331     HWND                            hParent = NULLHANDLE;
 332
 333     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 334
 335     if ( !CreateBase( pParent
 336                      ,vId
 337                      ,rPos
 338                      ,rSize
 339                      ,lStyle
 340                      ,wxDefaultValidator
 341                      ,rName
 342                     ))
 343         return(FALSE);
 344
 345     if (pParent)
 346     {
 347         pParent->AddChild(this);
 348         hParent = GetWinHwnd(pParent);
 349     }
 350     else
 351        hParent = HWND_DESKTOP;
 352
 353     ULONG                           ulCreateFlags = 0L;
 354
 355
 356     //
 357     // Most wxSTYLES are really PM Class specific styles and will be
 358     // set in those class create procs.  PM's basic windows styles are
 359     // very limited.
 360     //
 361     ulCreateFlags |=  WS_VISIBLE;
 362
 363
 364     if ( lStyle & wxCLIP_SIBLINGS )
 365         ulCreateFlags |= WS_CLIPSIBLINGS;
 366
 367     if (lStyle & wxCLIP_CHILDREN )
 368         ulCreateFlags |= WS_CLIPCHILDREN;
 369
 370     //
 371     // Empty stuff for now since PM has no custome 3D effects
 372     // Doesn't mean someone cannot make some up though
 373     //
 374     bool                            bWant3D;
 375     WXDWORD                         dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
 376
 377     //
 378     // Generic OS/2 Windows are created with no owner, no Z Order, no Control data,
 379     // and no presentation parameters
 380     //
 381     OS2Create( hParent
 382               ,(PSZ)wxCanvasClassName
 383               ,rName.c_str()
 384               ,ulCreateFlags
 385               ,rPos.x
 386               ,rPos.y
 387               ,WidthDefault(rSize.x)
 388               ,HeightDefault(rSize.y)
 389               ,NULLHANDLE
 390               ,NULLHANDLE
 391               ,m_windowId
 392              );
 393
 394     return(TRUE);
 395 } // end of wxWindow::Create
 396
 397 // ---------------------------------------------------------------------------
 398 // basic operations
 399 // ---------------------------------------------------------------------------
 400
 401 void wxWindow::SetFocus()
 402 {
 403     HWND                            hWnd = GetHwnd();
 404
 405     if (hWnd)
 406         ::WinSetFocus(HWND_DESKTOP, hWnd);
 407 } // end of wxWindow::SetFocus
 408
 409 wxWindow* wxWindowBase::FindFocus()
 410 {
 411     HWND                            hWnd = ::WinQueryFocus(HWND_DESKTOP);
 412
 413     if (hWnd)
 414     {
 415         return wxFindWinFromHandle((WXHWND)hWnd);
 416     }
 417     return NULL;
 418 } // wxWindowBase::FindFocus
 419
 420 bool wxWindow::Enable(
 421   bool                              bEnable
 422 )
 423 {
 424     if (!wxWindowBase::Enable(bEnable))
 425         return(FALSE);
 426
 427     HWND                            hWnd = GetHwnd();
 428
 429     if ( hWnd )
 430         ::WinEnableWindow(hWnd, (BOOL)bEnable);
 431
 432     wxWindowList::Node*             pNode = GetChildren().GetFirst();
 433
 434     while (pNode)
 435     {
 436         wxWindow*                   pChild = pNode->GetData();
 437
 438         pChild->Enable(bEnable);
 439         pNode = pNode->GetNext();
 440     }
 441     return(TRUE);
 442 } // end of wxWindow::Enable
 443
 444 bool wxWindow::Show(
 445   bool                              bShow
 446 )
 447 {
 448     if (!wxWindowBase::Show(bShow))
 449         return(FALSE);
 450
 451     HWND                            hWnd = GetHwnd();
 452
 453     ::WinShowWindow(hWnd, bShow);
 454
 455     if (bShow)
 456     {
 457         ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
 458     }
 459     return(TRUE);
 460 } // end of wxWindow::Show
 461
 462 void wxWindow::Raise()
 463 {
 464     ::WinSetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | SWP_ACTIVATE);
 465 } // end of wxWindow::Raise
 466
 467 void wxWindow::Lower()
 468 {
 469     ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER | SWP_DEACTIVATE);
 470 } // end of wxWindow::Lower
 471
 472 void wxWindow::SetTitle(
 473   const wxString&                   rTitle
 474 )
 475 {
 476     ::WinSetWindowText(GetHwnd(), rTitle.c_str());
 477 } // end of wxWindow::SetTitle
 478
 479 wxString wxWindow::GetTitle() const
 480 {
 481     return wxGetWindowText(GetHWND());
 482 } // end of wxWindow::GetTitle
 483
 484 void wxWindow::CaptureMouse()
 485 {
 486     HWND                            hWnd = GetHwnd();
 487
 488     if (hWnd && !m_bWinCaptured)
 489     {
 490         ::WinSetCapture(HWND_DESKTOP, hWnd);
 491         m_bWinCaptured = TRUE;
 492     }
 493 } // end of wxWindow::GetTitle
 494
 495 void wxWindow::ReleaseMouse()
 496 {
 497     if (m_bWinCaptured)
 498     {
 499         ::WinSetCapture(HWND_DESKTOP, NULLHANDLE);
 500         m_bWinCaptured = FALSE;
 501     }
 502 } // end of wxWindow::ReleaseMouse
 503
 504 bool wxWindow::SetFont(
 505   const wxFont&                     rFont
 506 )
 507 {
 508     if (!wxWindowBase::SetFont(rFont))
 509     {
 510         // nothing to do
 511         return(FALSE);
 512     }
 513
 514     HWND                            hWnd = GetHwnd();
 515
 516     if (hWnd != 0)
 517     {
 518         wxChar                      zFont[128];
 519
 520         sprintf(zFont, "%d.%s", rFont.GetPointSize(), rFont.GetFaceName().c_str());
 521         return(::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont), (PVOID)zFont));
 522     }
 523     return(TRUE);
 524 }
 525
 526 bool wxWindow::SetCursor(
 527   const wxCursor&                   rCursor
 528 ) // check if base implementation is OK
 529 {
 530     if ( !wxWindowBase::SetCursor(rCursor))
 531     {
 532         // no change
 533         return FALSE;
 534     }
 535
 536     wxASSERT_MSG( m_cursor.Ok(),
 537                   wxT("cursor must be valid after call to the base version"));
 538
 539     HWND                            hWnd = GetHwnd();
 540     POINTL                          vPoint;
 541     RECTL                           vRect;
 542     HPS                             hPS;
 543     HRGN                            hRGN;
 544
 545     hPS = ::WinGetPS(hWnd);
 546
 547     ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
 548     ::WinQueryWindowRect(hWnd, &vRect);
 549
 550     hRGN = ::GpiCreateRegion(hPS, 1L, &vRect);
 551
 552     if ((::GpiPtInRegion(hPS, hRGN, &vPoint) == PRGN_INSIDE) && !wxIsBusy())
 553     {
 554         ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
 555     }
 556     return TRUE;
 557 } // end of wxWindow::SetCursor
 558
 559 void wxWindow::WarpPointer(
 560   int                               nXPos
 561 , int                               nYPos
 562 )
 563 {
 564     int                             nX = nXPos;
 565     int                             nY = nYPos;
 566     RECTL                           vRect;
 567
 568     ::WinQueryWindowRect(GetHwnd(), &vRect);
 569     nX += vRect.xLeft;
 570     nY += vRect.yBottom;
 571
 572     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
 573 } // end of wxWindow::WarpPointer
 574
 575 #if WXWIN_COMPATIBILITY
 576 void wxWindow::OS2DeviceToLogical (float *x, float *y) const
 577 {
 578 }
 579 #endif // WXWIN_COMPATIBILITY
 580
 581 // ---------------------------------------------------------------------------
 582 // scrolling stuff
 583 // ---------------------------------------------------------------------------
 584
 585 #if WXWIN_COMPATIBILITY
 586 void wxWindow::SetScrollRange(
 587   int                               nOrient
 588 , int                               nRange
 589 , bool                              bRefresh
 590 )
 591 {
 592     ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, nRange));
 593 } // end of wxWindow::SetScrollRange
 594
 595 void wxWindow::SetScrollPage(
 596   int                               nOrient
 597 , int                               nPage
 598 , bool                              bRefresh
 599 )
 600 {
 601     if ( orient == wxHORIZONTAL )
 602         m_xThumbSize = page;
 603     else
 604         m_yThumbSize = page;
 605 }
 606
 607 int wxWindow::OldGetScrollRange(
 608   int                               nOrient
 609 ) const
 610 {
 611     MRESULT                         mRc;
 612     HWND                            hWnd = GetHwnd();
 613
 614     if (hWnd)
 615     {
 616         mRc = WinSendMsg(hWnd, SBM_QUERYRANGE, (MPARAM)0L, (MPARAM)0L);
 617         return(SHORT2FROMMR(mRc));
 618      }
 619      return 0;
 620 } // end of wxWindow::OldGetScrollRange
 621
 622 int  wxWindow::GetScrollPage(
 623   int                               nOrient
 624 ) const
 625 {
 626     if (nOrient == wxHORIZONTAL)
 627         return m_nXThumbSize;
 628     else
 629         return m_nYThumbSize;
 630 } // end of wxWindow::GetScrollPage
 631 #endif // WXWIN_COMPATIBILITY
 632
 633 int  wxWindow::GetScrollPos(
 634   int                               nOrient
 635 ) const
 636 {
 637     return((int)::WinSendMsg(GetHwnd(), SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
 638 } // end of wxWindow::GetScrollPos
 639
 640 int wxWindow::GetScrollRange(
 641   int                               nOrient
 642 ) const
 643 {
 644     MRESULT                         mr;
 645
 646     mr = ::WinSendMsg(GetHwnd(), SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
 647     return((int)SHORT2FROMMR(mr));
 648 } // end of wxWindow::GetScrollRange
 649
 650 int wxWindow::GetScrollThumb(
 651   int                               nOrient
 652 ) const
 653 {
 654     WNDPARAMS                       vWndParams;
 655     PSBCDATA                        pSbcd;
 656
 657     ::WinSendMsg(GetHwnd(), WM_QUERYWINDOWPARAMS, (MPARAM)&vWndParams, (MPARAM)NULL);
 658     pSbcd = (PSBCDATA)vWndParams.pCtlData;
 659     return((int)pSbcd->posThumb);
 660 } // end of wxWindow::GetScrollThumb
 661
 662 void wxWindow::SetScrollPos(
 663   int                               nOrient
 664 , int                               nPos
 665 , bool                              bRefresh
 666 )
 667 {
 668     ::WinSendMsg(GetHwnd(), SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
 669 } // end of wxWindow::SetScrollPos(
 670
 671 void wxWindow::SetScrollbar(
 672   int                               nOrient
 673 , int                               nPos
 674 , int                               nThumbVisible
 675 , int                               nRange
 676 , bool                              bRefresh
 677 )
 678 {
 679     ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, nRange));
 680     if (nOrient == wxHORIZONTAL)
 681     {
 682         m_nXThumbSize = nThumbVisible;
 683     }
 684     else
 685     {
 686         m_nYThumbSize = nThumbVisible;
 687     }
 688 } // end of wxWindow::SetScrollbar
 689
 690 void wxWindow::ScrollWindow(
 691   int                               nDx
 692 , int                               nDy
 693 , const wxRect*                     pRect
 694 )
 695 {
 696     RECTL                           vRect2;
 697
 698     if (pRect)
 699     {
 700         vRect2.xLeft   = pRect->x;
 701         vRect2.yTop    = pRect->y;
 702         vRect2.xRight  = pRect->x + pRect->width;
 703         vRect2.yBottom = pRect->y + pRect->height;
 704     }
 705
 706     if (pRect)
 707         ::WinScrollWindow(GetHwnd(), (LONG)nDx, (LONG)nDy, &vRect2, NULL, NULLHANDLE, NULL, 0L);
 708     else
 709         ::WinScrollWindow(GetHwnd(), nDx, nDy, NULL, NULL, NULLHANDLE, NULL, 0L);
 710 } // end of wxWindow::ScrollWindow
 711
 712 // ---------------------------------------------------------------------------
 713 // subclassing
 714 // ---------------------------------------------------------------------------
 715
 716 void wxWindow::SubclassWin(
 717   WXHWND                            hWnd
 718 )
 719 {
 720     HWND                            hwnd = (HWND)hWnd;
 721
 722     wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
 723     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
 724     m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
 725 } // end of wxWindow::SubclassWin
 726
 727 void wxWindow::UnsubclassWin()
 728 {
 729     //
 730     // Restore old Window proc
 731     //
 732     HWND                            hwnd = GetHWND();
 733
 734     if (m_hWnd)
 735     {
 736         wxCHECK_RET( ::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in UnsubclassWin") );
 737
 738         PFNWP                       fnProc = (PFNWP)::WinQueryWindowPtr(hwnd, QWP_PFNWP);
 739
 740         if ( (m_fnOldWndProc != 0) && (fnProc != (PFNWP) m_fnOldWndProc))
 741         {
 742             WinSubclassWindow(hwnd, (PFNWP)m_fnOldWndProc);
 743             m_fnOldWndProc = 0;
 744         }
 745     }
 746 } // end of wxWindow::UnsubclassWin
 747
 748 //
 749 // Make a Windows extended style from the given wxWindows window style
 750 //
 751 WXDWORD wxWindow::MakeExtendedStyle(
 752   long                              lStyle
 753 , bool                              bEliminateBorders
 754 )
 755 {
 756    //
 757    // PM does not support extended style
 758    //
 759     WXDWORD                         exStyle = 0;
 760     return exStyle;
 761 } // end of wxWindow::MakeExtendedStyle
 762
 763 //
 764 // Determines whether native 3D effects or CTL3D should be used,
 765 // applying a default border style if required, and returning an extended
 766 // style to pass to CreateWindowEx.
 767 //
 768 WXDWORD wxWindow::Determine3DEffects(
 769   WXDWORD                           dwDefaultBorderStyle
 770 , bool*                             pbWant3D
 771 ) const
 772 {
 773     WXDWORD                         dwStyle = 0L;
 774
 775     //
 776     // Native PM does not have any specialize 3D effects like WIN32 does
 777     //
 778     *pbWant3D = FALSE;
 779     return dwStyle;
 780 } // end of wxWindow::Determine3DEffects
 781
 782 #if WXWIN_COMPATIBILITY
 783 void wxWindow::OnCommand(
 784   wxWindow&                         rWin
 785 , wxCommandEvent&                   rEvent
 786 )
 787 {
 788     if (GetEventHandler()->ProcessEvent(rEvent))
 789         return;
 790     if (m_parent)
 791         m_parent->GetEventHandler()->OnCommand( rWin
 792                                                ,rEvent
 793                                               );
 794 } // end of wxWindow::OnCommand
 795
 796 wxObject* wxWindow::GetChild(
 797   int                               nNumber
 798 ) const
 799 {
 800     //
 801     // Return a pointer to the Nth object in the Panel
 802     //
 803     wxNode*                         pNode = GetChildren().First();
 804     int                             n = nNumber;
 805
 806     while (pNode && n--)
 807         pNode = pNode->Next();
 808     if (pNode)
 809     {
 810         wxObject*                   pObj = (wxObject*)pNode->Data();
 811         return(pObj);
 812     }
 813     else
 814         return NULL;
 815 } // end of wxWindow::GetChild
 816
 817 #endif // WXWIN_COMPATIBILITY
 818
 819 //
 820 // Setup background and foreground colours correctly
 821 //
 822 void wxWindow::SetupColours()
 823 {
 824     if ( GetParent() )
 825         SetBackgroundColour(GetParent()->GetBackgroundColour());
 826 } // end of wxWindow::SetupColours
 827
 828 void wxWindow::OnIdle(
 829   wxIdleEvent&                      rEvent
 830 )
 831 {
 832     //
 833     // Check if we need to send a LEAVE event
 834     //
 835     if (m_bMouseInWindow)
 836     {
 837         POINTL                      vPoint;
 838
 839         ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
 840         if (::WinWindowFromPoint(HWND_DESKTOP, &vPoint, FALSE) != (HWND)GetHwnd())
 841         {
 842             //
 843             // Generate a LEAVE event
 844             //
 845             m_bMouseInWindow = FALSE;
 846
 847             //
 848             // Unfortunately the mouse button and keyboard state may have changed
 849             // by the time the OnIdle function is called, so 'state' may be
 850             // meaningless.
 851             //
 852             int                     nState = 0;
 853
 854             if (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) != 0)
 855                 nState |= VK_SHIFT;
 856             if (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) != 0);
 857                 nState |= VK_CTRL;
 858
 859             wxMouseEvent            rEvent(wxEVT_LEAVE_WINDOW);
 860
 861             InitMouseEvent( rEvent
 862                            ,vPoint.x
 863                            ,vPoint.y
 864                            ,nState
 865                           );
 866             (void)GetEventHandler()->ProcessEvent(rEvent);
 867         }
 868     }
 869     UpdateWindowUI();
 870 } // end of wxWindow::OnIdle
 871
 872 //
 873 // Set this window to be the child of 'parent'.
 874 //
 875 bool wxWindow::Reparent(
 876   wxWindow*                         pParent
 877 )
 878 {
 879     if (!wxWindowBase::Reparent(pParent))
 880         return FALSE;
 881
 882     HWND                            hWndChild = GetHwnd();
 883     HWND                            hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
 884
 885     ::WinSetParent(hWndChild, hWndParent, TRUE);
 886     return TRUE;
 887 } // end of wxWindow::Reparent
 888
 889 void wxWindow::Clear()
 890 {
 891     wxClientDC                      vDc(this);
 892     wxBrush                         vBrush( GetBackgroundColour()
 893                                            ,wxSOLID
 894                                           );
 895
 896     vDc.SetBackground(vBrush);
 897     vDc.Clear();
 898 } // end of wxWindow::Clear
 899
 900 void wxWindow::Refresh(
 901   bool                              bEraseBack
 902 , const wxRect*                     pRect
 903 )
 904 {
 905     HWND                            hWnd = GetHwnd();
 906
 907     if (hWnd)
 908     {
 909         if (pRect)
 910         {
 911             RECTL                   vOs2Rect;
 912
 913             vOs2Rect.xLeft   = pRect->x;
 914             vOs2Rect.yTop    = pRect->y;
 915             vOs2Rect.xRight  = pRect->x + pRect->width;
 916             vOs2Rect.yBottom = pRect->y + pRect->height;
 917
 918             ::WinInvalidateRect(hWnd, &vOs2Rect, bEraseBack);
 919         }
 920         else
 921             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
 922     }
 923 } // end of wxWindow::Refresh
 924
 925 // ---------------------------------------------------------------------------
 926 // drag and drop
 927 // ---------------------------------------------------------------------------
 928
 929 #if wxUSE_DRAG_AND_DROP
 930 void wxWindow::SetDropTarget(
 931   wxDropTarget*                     pDropTarget
 932 )
 933 {
 934     if (m_dropTarget != 0)
 935     {
 936         m_dropTarget->Revoke(m_hWnd);
 937         delete m_dropTarget;
 938     }
 939     m_dropTarget = pDropTarget;
 940     if (m_dropTarget != 0)
 941         m_dropTarget->Register(m_hWnd);
 942 } // end of wxWindow::SetDropTarget
 943 #endif
 944
 945 //
 946 // old style file-manager drag&drop support: we retain the old-style
 947 // DragAcceptFiles in parallel with SetDropTarget.
 948 //
 949 void wxWindow::DragAcceptFiles(
 950   bool                              bAccept
 951 )
 952 {
 953     HWND                            hWnd = GetHwnd();
 954
 955     if (hWnd && bAccept)
 956         ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);
 957 } // end of wxWindow::DragAcceptFiles
 958
 959 // ----------------------------------------------------------------------------
 960 // tooltips
 961 // ----------------------------------------------------------------------------
 962
 963 #if wxUSE_TOOLTIPS
 964
 965 void wxWindow::DoSetToolTip(
 966   wxToolTip*                        pTooltip
 967 )
 968 {
 969     wxWindowBase::DoSetToolTip(pTooltip);
 970
 971     if (m_tooltip)
 972         m_tooltip->SetWindow(this);
 973 } // end of wxWindow::DoSetToolTip
 974
 975 #endif // wxUSE_TOOLTIPS
 976
 977 // ---------------------------------------------------------------------------
 978 // moving and resizing
 979 // ---------------------------------------------------------------------------
 980
 981 // Get total size
 982 void wxWindow::DoGetSize(
 983   int*                              pWidth
 984 , int*                              pHeight
 985 ) const
 986 {
 987     HWND                            hWnd = GetHwnd();
 988     RECTL                           vRect;
 989
 990     ::WinQueryWindowRect(hWnd, &vRect);
 991
 992     if (pWidth)
 993         *pWidth = vRect.xRight - vRect.xLeft;
 994     if (pHeight )
 995         // OS/2 PM is backwards from windows
 996         *pHeight = vRect.yTop - vRect.yBottom;
 997 } // end of wxWindow::DoGetSize
 998
 999 void wxWindow::DoGetPosition(
1000   int*                              pX
1001 , int*                              pY
1002 ) const
1003 {
1004     HWND                            hWnd = GetHwnd();
1005     RECT                            vRect;
1006     POINTL                          vPoint;
1007
1008     ::WinQueryWindowRect(hWnd, &vRect);
1009
1010     vPoint.x = vRect.xLeft;
1011     vPoint.y = vRect.yBottom;
1012
1013     //
1014     // We do the adjustments with respect to the parent only for the "real"
1015     // children, not for the dialogs/frames
1016     //
1017     if (!IsTopLevel())
1018     {
1019         HWND                        hParentWnd = 0;
1020         wxWindow*                   pParent = GetParent();
1021
1022         if (pParent)
1023             hParentWnd = GetWinHwnd(pParent);
1024
1025         //
1026         // Since we now have the absolute screen coords, if there's a parent we
1027         // must subtract its bottom left corner
1028         //
1029         if (hParentWnd)
1030         {
1031             RECTL                   vRect2;
1032
1033             ::WinQueryWindowRect(hParentWnd, &vRect2);
1034             vPoint.x -= vRect.xLeft;
1035             vPoint.y -= vRect.yBottom;
1036         }
1037
1038         //
1039         // We may be faking the client origin. So a window that's really at (0,
1040         // 30) may appear (to wxWin apps) to be at (0, 0).
1041         //
1042         wxPoint                     vPt(pParent->GetClientAreaOrigin());
1043
1044         vPoint.x -= vPt.x;
1045         vPoint.y -= vPt.y;
1046     }
1047
1048     if (pX)
1049         *pX = vPoint.x;
1050     if  (pY)
1051         *pY = vPoint.y;
1052 } // end of wxWindow::DoGetPosition
1053
1054 void wxWindow::DoScreenToClient(
1055   int*                              pX
1056 , int*                              pY
1057 ) const
1058 {
1059     HWND                            hWnd = GetHwnd();
1060     SWP                             vSwp;
1061
1062     ::WinQueryWindowPos(hWnd, &vSwp);
1063
1064     if (pX)
1065         *pX -= vSwp.x;
1066     if (pY)
1067         *pY -= vSwp.y;
1068 } // end of wxWindow::DoScreenToClient
1069
1070 void wxWindow::DoClientToScreen(
1071   int*                              pX
1072 , int*                              pY
1073 ) const
1074 {
1075     HWND                            hWnd = GetHwnd();
1076     SWP                             vSwp;
1077
1078     ::WinQueryWindowPos(hWnd, &vSwp);
1079
1080     if (pX)
1081         *pX += vSwp.x;
1082     if (pY)
1083         *pY += vSwp.y;
1084 } // end of wxWindow::DoClientToScreen
1085
1086 //
1087 // Get size *available for subwindows* i.e. excluding menu bar etc.
1088 // Must be a frame type window
1089 //
1090 void wxWindow::DoGetClientSize(
1091   int*                              pWidth
1092 , int*                              pHeight
1093 ) const
1094 {
1095     HWND                            hWnd = GetHwnd();
1096     HWND                            hWndClient;
1097     RECTL                           vRect;
1098
1099     hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
1100     if( hWndClient == NULLHANDLE)
1101        ::WinQueryWindowRect(GetHwnd(), &vRect);
1102     else
1103        ::WinQueryWindowRect(hWndClient, &vRect);
1104
1105     if (pWidth)
1106         *pWidth  = vRect.xRight;
1107     if (pHeight)
1108         *pHeight = vRect.yTop;
1109 } // end of wxWindow::DoGetClientSize
1110
1111 void wxWindow::DoMoveWindow(
1112   int                               nX
1113 , int                               nY
1114 , int                               nWidth
1115 , int                               nHeight
1116 )
1117 {
1118     if ( !::WinSetWindowPos( GetHwnd()
1119                             ,HWND_TOP
1120                             ,(LONG)nX
1121                             ,(LONG)nY
1122                             ,(LONG)nWidth
1123                             ,(LONG)nHeight
1124                             ,SWP_SIZE | SWP_MOVE
1125                            ))
1126     {
1127         wxLogLastError("MoveWindow");
1128     }
1129 } // end of wxWindow::DoMoveWindow
1130
1131 //
1132 // Set the size of the window: if the dimensions are positive, just use them,
1133 // but if any of them is equal to -1, it means that we must find the value for
1134 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1135 // which case -1 is a valid value for x and y)
1136 //
1137 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1138 // the width/height to best suit our contents, otherwise we reuse the current
1139 // width/height
1140 //
1141 void wxWindow::DoSetSize(
1142   int                               nX
1143 , int                               nY
1144 , int                               nWidth
1145 , int                               nHeight
1146 , int                               nSizeFlags
1147 )
1148 {
1149     //
1150     // Get the current size and position...
1151     //
1152     int                             nCurrentX;
1153     int                             nCurrentY;
1154     int                             nCurrentWidth;
1155     int                             nCurrentHeight;
1156     wxSize                          vSize(-1, -1);
1157
1158     GetPosition( &nCurrentX
1159                 ,&nCurrentY
1160                );
1161     GetSize( &nCurrentWidth
1162             ,&nCurrentHeight
1163            );
1164
1165     //
1166     // ... and don't do anything (avoiding flicker) if it's already ok
1167     //
1168     if ( nX == nCurrentX &&
1169          nY == nCurrentY &&
1170          nWidth == nCurrentWidth &&
1171          nHeight == nCurrentHeight
1172        )
1173     {
1174         return;
1175     }
1176
1177     if (nX == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE))
1178         nX = nCurrentX;
1179     if (nY == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE))
1180         nY = nCurrentY;
1181
1182     AdjustForParentClientOrigin( nX
1183                                 ,nY
1184                                 ,nSizeFlags
1185                                );
1186
1187     if (nWidth == -1)
1188     {
1189         if (nSizeFlags & wxSIZE_AUTO_WIDTH)
1190         {
1191             vSize  = DoGetBestSize();
1192             nWidth = vSize.x;
1193         }
1194         else
1195         {
1196             //
1197             // Just take the current one
1198             //
1199             nWidth = nCurrentWidth;
1200         }
1201     }
1202
1203     if (nHeight == -1)
1204     {
1205         if (nSizeFlags & wxSIZE_AUTO_HEIGHT)
1206         {
1207             if (vSize.x == -1)
1208             {
1209                 vSize = DoGetBestSize();
1210             }
1211             nHeight = vSize.y;
1212         }
1213         else
1214         {
1215             // just take the current one
1216             nHeight = nCurrentHeight;
1217         }
1218     }
1219
1220     DoMoveWindow( nX
1221                  ,nY
1222                  ,nWidth
1223                  ,nHeight
1224                 );
1225 } // end of wxWindow::DoSetSize
1226
1227 void wxWindow::DoSetClientSize(
1228   int                               nWidth
1229 , int                               nHeight
1230 )
1231 {
1232     wxWindow*                       pParent = GetParent();
1233     HWND                            hWnd = GetHwnd();
1234     HWND                            hParentWnd = (HWND)0;
1235     HWND                            hClientWnd = (HWND)0;
1236     RECTL                           vRect;
1237     RECT                            vRect2;
1238     RECT                            vRect3;
1239
1240     hClientWnd = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
1241     ::WinQueryWindowRect(hClientWnd, &vRect2);
1242
1243     if (pParent)
1244         hParentWnd = (HWND) pParent->GetHWND();
1245
1246     ::WinQueryWindowRect(hWnd, &vRect);
1247     ::WinQueryWindowRect(hParentWnd, &vRect3);
1248     //
1249     // Find the difference between the entire window (title bar and all)
1250     // and the client area; add this to the new client size to move the
1251     // window. OS/2 is backward from windows on height
1252     //
1253     int                             nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
1254     int                             nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight;
1255
1256     //
1257     // If there's a parent, must subtract the parent's bottom left corner
1258     // since MoveWindow moves relative to the parent
1259     //
1260     POINTL                          vPoint;
1261
1262     vPoint.x = vRect2.xLeft;
1263     vPoint.y = vRect2.yBottom;
1264     if (pParent)
1265     {
1266         vPoint.x -= vRect3.xLeft;
1267         vPoint.y -= vRect3.yBottom;
1268     }
1269
1270     DoMoveWindow( vPoint.x
1271                  ,vPoint.y
1272                  ,nActualWidth
1273                  ,nActualHeight
1274                 );
1275
1276     wxSizeEvent                     vEvent( wxSize( nWidth
1277                                                   ,nHeight
1278                                                  )
1279                                            ,m_windowId
1280                                           );
1281
1282     vEvent.SetEventObject(this);
1283     GetEventHandler()->ProcessEvent(vEvent);
1284 } // end of wxWindow::DoSetClientSize
1285
1286 wxPoint wxWindow::GetClientAreaOrigin() const
1287 {
1288     return wxPoint(0, 0);
1289 } // end of wxWindow::GetClientAreaOrigin
1290
1291 void wxWindow::AdjustForParentClientOrigin(
1292   int&                              rX
1293 , int&                              rY
1294 , int                               nSizeFlags
1295 )
1296 {
1297     //
1298     // Don't do it for the dialogs/frames - they float independently of their
1299     // parent
1300     //
1301     if (!IsTopLevel())
1302     {
1303         wxWindow*                   pParent = GetParent();
1304
1305         if (!(nSizeFlags & wxSIZE_NO_ADJUSTMENTS) && pParent)
1306         {
1307             wxPoint                 vPoint(pParent->GetClientAreaOrigin());
1308             rX += vPoint.x;
1309             rY += vPoint.y;
1310         }
1311     }
1312 } // end of wxWindow::AdjustForParentClientOrigin
1313
1314 // ---------------------------------------------------------------------------
1315 // text metrics
1316 // ---------------------------------------------------------------------------
1317
1318 int wxWindow::GetCharHeight() const
1319 {
1320     HPS                             hPs;
1321     FONTMETRICS                     vFontMetrics;
1322     BOOL                            bRc;
1323
1324     hPs = ::WinGetPS(GetHwnd());
1325
1326     if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
1327     {
1328         ::WinReleasePS(hPs);
1329         return (0);
1330     }
1331     ::WinReleasePS(hPs);
1332     return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
1333 } // end of wxWindow::GetCharHeight
1334
1335 int wxWindow::GetCharWidth() const
1336 {
1337     HPS                             hPs;
1338     FONTMETRICS                     vFontMetrics;
1339
1340     hPs = ::WinGetPS(GetHwnd());
1341
1342     if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
1343     {
1344         ::WinReleasePS(hPs);
1345         return (0);
1346     }
1347     ::WinReleasePS(hPs);
1348     return(vFontMetrics.lAveCharWidth);
1349 } // end of wxWindow::GetCharWidth
1350
1351 void wxWindow::GetTextExtent(
1352   const wxString&                   rString
1353 , int*                              pX
1354 , int*                              pY
1355 , int*                              pDescent
1356 , int*                              pExternalLeading
1357 , const wxFont*                     pTheFont
1358 ) const
1359 {
1360     const wxFont*                   pFontToUse = pTheFont;
1361     HPS                             hPs;
1362
1363     hPs = ::WinGetPS(GetHwnd());
1364 /*
1365 // TODO: Will have to play with fonts later
1366
1367     if (!pFontToUse)
1368         pFontToUse = &m_font;
1369
1370     HFONT                           hFnt = 0;
1371     HFONT                           hFfontOld = 0;
1372
1373     if (pFontToUse && pFontToUse->Ok())
1374     {
1375         ::GpiCreateLog
1376         hFnt = (HFONT)((wxFont *)pFontToUse)->GetResourceHandle(); // const_cast
1377         if (hFnt)
1378             hFontOld = (HFONT)SelectObject(dc,fnt);
1379     }
1380
1381     SIZE sizeRect;
1382     TEXTMETRIC tm;
1383     GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
1384     GetTextMetrics(dc, &tm);
1385
1386     if ( fontToUse && fnt && hfontOld )
1387         SelectObject(dc, hfontOld);
1388
1389     ReleaseDC(hWnd, dc);
1390
1391     if ( x )
1392         *x = sizeRect.cx;
1393     if ( y )
1394         *y = sizeRect.cy;
1395     if ( descent )
1396         *descent = tm.tmDescent;
1397     if ( externalLeading )
1398         *externalLeading = tm.tmExternalLeading;
1399 */
1400     ::WinReleasePS(hPs);
1401 }
1402
1403 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1404 // ---------------------------------------------------------------------------
1405 // Caret manipulation
1406 // ---------------------------------------------------------------------------
1407
1408 void wxWindow::CreateCaret(
1409   int                               nWidth
1410 , int                               nHeight
1411 )
1412 {
1413     SetCaret(new wxCaret( this
1414                          ,nWidth
1415                          ,nHeight
1416                         ));
1417 } // end of wxWindow::CreateCaret
1418
1419 void wxWindow::CreateCaret(
1420   const wxBitmap*                   pBitmap
1421 )
1422 {
1423     wxFAIL_MSG("not implemented");
1424 } // end of wxWindow::CreateCaret
1425
1426 void wxWindow::ShowCaret(
1427   bool                              bShow
1428 )
1429 {
1430     wxCHECK_RET( m_caret, "no caret to show" );
1431
1432     m_caret->Show(bShow);
1433 } // end of wxWindow::ShowCaret
1434
1435 void wxWindow::DestroyCaret()
1436 {
1437     SetCaret(NULL);
1438 } // end of wxWindow::DestroyCaret
1439
1440 void wxWindow::SetCaretPos(
1441   int                               nX
1442 , int                               nY)
1443 {
1444     wxCHECK_RET( m_caret, "no caret to move" );
1445
1446     m_caret->Move( nX
1447                   ,nY
1448                  );
1449 } // end of wxWindow::SetCaretPos
1450
1451 void wxWindow::GetCaretPos(
1452   int*                              pX
1453 , int*                              pY
1454 ) const
1455 {
1456     wxCHECK_RET( m_caret, "no caret to get position of" );
1457
1458     m_caret->GetPosition( pX
1459                          ,pY
1460                         );
1461 } // end of wxWindow::GetCaretPos
1462
1463 #endif //wxUSE_CARET
1464
1465 // ---------------------------------------------------------------------------
1466 // popup menu
1467 // ---------------------------------------------------------------------------
1468
1469 bool wxWindow::DoPopupMenu(
1470   wxMenu*                           pMenu
1471 , int                               nX
1472 , int                               nY
1473 )
1474 {
1475     HWND                            hWnd = GetHwnd();
1476     HWND                            hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
1477     HWND                            hMenu = GetHmenuOf(pMenu);
1478
1479     pMenu->SetInvokingWindow(this);
1480     pMenu->UpdateUI();
1481
1482     DoClientToScreen( &nX
1483                      ,&nY
1484                     );
1485     wxCurrentPopupMenu = pMenu;
1486
1487     ::WinPopupMenu( hWndParent
1488                    ,hWnd
1489                    ,hMenu
1490                    ,nX
1491                    ,nY
1492                    ,0L
1493                    ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD
1494                   );
1495     wxYield();
1496     wxCurrentPopupMenu = NULL;
1497
1498     pMenu->SetInvokingWindow(NULL);
1499     return TRUE;
1500 } // end of wxWindow::DoPopupMenu
1501
1502 // ===========================================================================
1503 // pre/post message processing
1504 // ===========================================================================
1505
1506 MRESULT wxWindow::OS2DefWindowProc(
1507   WXUINT                            uMsg
1508 , WXWPARAM                          wParam
1509 , WXLPARAM                          lParam
1510 )
1511 {
1512     if (m_fnOldWndProc)
1513         return (MRESULT)m_fnOldWndProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
1514     else
1515         return ::WinDefWindowProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
1516 } // end of wxWindow::OS2DefWindowProc
1517
1518 bool wxWindow::OS2ProcessMessage(
1519   WXMSG*                            pMsg
1520 )
1521 {
1522     QMSG*                           pQMsg = (QMSG*)pMsg;
1523
1524     if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL))
1525     {
1526         //
1527         // Intercept dialog navigation keys
1528         //
1529         bool                        bProcess = TRUE;
1530         USHORT                      uKeyFlags = SHORT1FROMMP(pQMsg->mp1);
1531
1532         if (uKeyFlags & KC_KEYUP)
1533             bProcess = FALSE;
1534
1535         if (uKeyFlags & KC_ALT)
1536             bProcess = FALSE;
1537
1538         if (!(uKeyFlags & KC_VIRTUALKEY))
1539             bProcess = FALSE;
1540
1541         if (bProcess)
1542         {
1543             bool                    bCtrlDown = IsCtrlDown();
1544             bool                    bShiftDown = IsShiftDown();
1545
1546             //
1547             // WM_QUERYDLGCODE: ask the control if it wants the key for itself,
1548             // don't process it if it's the case (except for Ctrl-Tab/Enter
1549             // combinations which are always processed)
1550             //
1551             ULONG                   ulDlgCode = 0;
1552
1553             if (!bCtrlDown)
1554             {
1555                 ulDlgCode = (ULONG)::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0);
1556             }
1557
1558             bool                    bForward = TRUE;
1559             bool                    bWindowChange = FALSE;
1560
1561             switch (SHORT2FROMMP(pQMsg->mp2))
1562             {
1563                 //
1564                 // Going to make certain assumptions about specific types of controls
1565                 // here, so we may have to alter some things later if they prove invalid
1566                 //
1567                 case VK_TAB:
1568                     //
1569                     // Shift tabl will always be a nav-key but tabs may be wanted
1570                     //
1571                     if (!bShiftDown)
1572                     {
1573                         bProcess = FALSE;
1574                     }
1575                     else
1576                     {
1577                         //
1578                         // Entry Fields want tabs for themselve usually
1579                         //
1580                         switch (ulDlgCode)
1581                         {
1582                             case DLGC_ENTRYFIELD:
1583                             case DLGC_MLE:
1584                                 bProcess = TRUE;
1585                                 break;
1586
1587                             default:
1588                                 bProcess = FALSE;
1589                         }
1590
1591                         //
1592                         // Ctrl-Tab cycles thru notebook pages
1593                         //
1594                         bWindowChange = bCtrlDown;
1595                         bForward = !bShiftDown;
1596                     }
1597                     break;
1598
1599                 case VK_UP:
1600                 case VK_LEFT:
1601                     if (bCtrlDown)
1602                         bProcess = FALSE;
1603                     else
1604                         bForward = FALSE;
1605                     break;
1606
1607                 case VK_DOWN:
1608                 case VK_RIGHT:
1609                     if (bCtrlDown)
1610                         bProcess = FALSE;
1611                     break;
1612
1613                 case VK_ENTER:
1614                     {
1615                         if (bCtrlDown)
1616                         {
1617                             //
1618                             // ctrl-enter is not processed
1619                             //
1620                             return FALSE;
1621                         }
1622                         else if (ulDlgCode & DLGC_BUTTON)
1623                         {
1624                             //
1625                             // buttons want process Enter themselevs
1626                             //
1627                             bProcess = FALSE;
1628                         }
1629                         else
1630                         {
1631                             wxPanel*    pPanel = wxDynamicCast(this, wxPanel);
1632                             wxButton*   pBtn = NULL;
1633
1634                             if (pPanel)
1635                             {
1636                                 //
1637                                 // Panel may have a default button which should
1638                                 // be activated by Enter
1639                                 //
1640                                 pBtn = pPanel->GetDefaultItem();
1641                             }
1642
1643                             if (pBtn && pBtn->IsEnabled())
1644                             {
1645                                 //
1646                                 // If we do have a default button, do press it
1647                                 //
1648                                 pBtn->OS2Command(BN_CLICKED, 0 /* unused */);
1649                                 return TRUE;
1650                             }
1651                             // else: but if it does not it makes sense to make
1652                             //       it work like a TAB - and that's what we do.
1653                             //       Note that Ctrl-Enter always works this way.
1654                         }
1655                     }
1656                     break;
1657
1658                 default:
1659                     bProcess = FALSE;
1660             }
1661
1662             if (bProcess)
1663             {
1664                 wxNavigationKeyEvent    vEvent;
1665
1666                 vEvent.SetDirection(bForward);
1667                 vEvent.SetWindowChange(bWindowChange);
1668                 vEvent.SetEventObject(this);
1669
1670                 if (GetEventHandler()->ProcessEvent(vEvent))
1671                 {
1672                     wxButton*       pBtn = wxDynamicCast(FindFocus(), wxButton);
1673
1674                     if (pBtn)
1675                     {
1676                         //
1677                         // The button which has focus should be default
1678                         //
1679                         pBtn->SetDefault();
1680                     }
1681                     return TRUE;
1682                 }
1683             }
1684         }
1685         //
1686         // Let Dialogs process
1687         //
1688         if (::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0));
1689             return TRUE;
1690     }
1691
1692 #if wxUSE_TOOLTIPS
1693     if ( m_tooltip )
1694     {
1695         // relay mouse move events to the tooltip control
1696         QMSG*                       pQMsg = (QMSG*)pMsg;
1697
1698         if (pQMsg->msg == WM_MOUSEMOVE )
1699             m_tooltip->RelayEvent(pMsg);
1700     }
1701 #endif // wxUSE_TOOLTIPS
1702
1703     return FALSE;
1704 } // end of wxWindow::OS2ProcessMessage
1705
1706 bool wxWindow::OS2TranslateMessage(
1707   WXMSG*                            pMsg
1708 )
1709 {
1710 #if wxUSE_ACCEL
1711   return m_acceleratorTable.Translate(m_hWnd, pMsg);
1712 #else
1713   return FALSE;
1714 #endif //wxUSE_ACCEL
1715 } // end of wxWindow::OS2TranslateMessage
1716
1717 // ---------------------------------------------------------------------------
1718 // message params unpackers
1719 // ---------------------------------------------------------------------------
1720
1721 void wxWindow::UnpackCommand(
1722   WXWPARAM                          wParam
1723 , WXLPARAM                          lParam
1724 , WORD*                             pId
1725 , WXHWND*                           phWnd
1726 , WORD*                             pCmd
1727 )
1728 {
1729     *pId = LOWORD(wParam);
1730     *phWnd = NULL;  // or may be GetHWND() ?
1731     *pCmd = LOWORD(lParam);
1732 } // end of wxWindow::UnpackCommand
1733
1734 void wxWindow::UnpackActivate(
1735   WXWPARAM                          wParam
1736 , WXLPARAM                          lParam
1737 , WXWORD*                           pState
1738 , WXHWND*                           phWnd
1739 )
1740 {
1741     *pState     = LOWORD(wParam);
1742     *phWnd      = (WXHWND)lParam;
1743 } // end of wxWindow::UnpackActivate
1744
1745 void wxWindow::UnpackScroll(
1746   WXWPARAM                          wParam
1747 , WXLPARAM                          lParam
1748 , WXWORD*                           pCode
1749 , WXWORD*                           pPos
1750 , WXHWND*                           phWnd
1751 )
1752 {
1753     *pCode = LOWORD(wParam);
1754     *pPos  = HIWORD(wParam);
1755     *phWnd = (WXHWND)lParam;
1756 } // end of wxWindow::UnpackScroll
1757
1758 void wxWindow::UnpackMenuSelect(
1759   WXWPARAM                          wParam
1760 , WXLPARAM                          lParam
1761 , WXWORD*                           pItem
1762 , WXWORD*                           pFlags
1763 , WXHMENU*                          phMenu
1764 )
1765 {
1766     *pItem = (WXWORD)LOWORD(wParam);
1767     *pFlags = HIWORD(wParam);
1768     *phMenu = (WXHMENU)lParam;
1769 } // end of wxWindow::UnpackMenuSelect
1770
1771 // ---------------------------------------------------------------------------
1772 // Main wxWindows window proc and the window proc for wxWindow
1773 // ---------------------------------------------------------------------------
1774
1775 //
1776 // Hook for new window just as it's being created, when the window isn't yet
1777 // associated with the handle
1778 //
1779 wxWindow*                           wxWndHook = NULL;
1780
1781 //
1782 // Main window proc
1783 //
1784 MRESULT EXPENTRY wxWndProc(
1785   HWND                              hWnd
1786 , ULONG                             ulMsg
1787 , MPARAM                            wParam
1788 , MPARAM                            lParam
1789 )
1790 {
1791     //
1792     // Trace all ulMsgs - useful for the debugging
1793     //
1794 #ifdef __WXDEBUG__
1795     wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
1796                wxGetMessageName(ulMsg), wParam, lParam);
1797 #endif // __WXDEBUG__
1798
1799     wxWindow*                       pWnd = wxFindWinFromHandle((WXHWND)hWnd);
1800
1801     //
1802     // When we get the first message for the HWND we just created, we associate
1803     // it with wxWindow stored in wxWndHook
1804     //
1805     if (!pWnd && wxWndHook)
1806     {
1807         wxAssociateWinWithHandle(hWnd, wxWndHook);
1808         pWnd = wxWndHook;
1809         wxWndHook = NULL;
1810         pWnd->SetHWND((WXHWND)hWnd);
1811     }
1812
1813     MRESULT                         rc = (MRESULT)0;
1814
1815
1816     //
1817     // Stop right here if we don't have a valid handle in our wxWindow object.
1818     //
1819     if (pWnd && !pWnd->GetHWND())
1820     {
1821         pWnd->SetHWND((WXHWND) hWnd);
1822         rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
1823         pWnd->SetHWND(0);
1824     }
1825     else
1826     {
1827         if (pWnd)
1828             rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
1829         else
1830             rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1831     }
1832
1833     return rc;
1834 } // end of wxWndProc
1835
1836 //
1837 // We will add (or delete) messages we need to handle at this default
1838 // level as we go
1839 //
1840 MRESULT wxWindow::OS2WindowProc(
1841   WXUINT                            uMsg
1842 , WXWPARAM                          wParam
1843 , WXLPARAM                          lParam
1844 )
1845 {
1846     //
1847     // Did we process the uMsg?
1848     //
1849     bool                            bProcessed = FALSE;
1850     bool                            bAllow;
1851     MRESULT                         mResult;
1852     WXHICON                         hIcon;
1853     WXHBRUSH                        hBrush;
1854
1855     //
1856     // For most messages we should return 0 when we do process the message
1857     //
1858     mResult = (MRESULT)0;
1859
1860     switch (uMsg)
1861     {
1862         case WM_CREATE:
1863             {
1864                 bool                bMayCreate;
1865
1866                 bProcessed = HandleCreate( (WXLPCREATESTRUCT)lParam
1867                                           ,&bMayCreate
1868                                          );
1869                 if (bProcessed)
1870                 {
1871                     //
1872                     // Return 0 to bAllow window creation
1873                     //
1874                     mResult = (MRESULT)(bMayCreate ? 0 : -1);
1875                 }
1876             }
1877             break;
1878
1879         case WM_DESTROY:
1880              HandleDestroy();
1881              bProcessed = TRUE;
1882              break;
1883
1884         case WM_MOVE:
1885             bProcessed = HandleMove( LOWORD(lParam)
1886                                     ,HIWORD(lParam)
1887                                    );
1888             break;
1889
1890         case WM_SIZE:
1891             bProcessed = HandleSize( LOWORD(lParam)
1892                                     ,HIWORD(lParam)
1893                                     ,(WXUINT)wParam
1894                                    );
1895             break;
1896
1897         case WM_ACTIVATE:
1898             {
1899                 WXWORD              wState;
1900                 WXHWND              hWnd;
1901
1902                 UnpackActivate( wParam
1903                                ,lParam
1904                                ,&wState
1905                                ,&hWnd
1906                               );
1907
1908                 bProcessed = HandleActivate( wState
1909                                             ,(WXHWND)hWnd
1910                                            );
1911                 bProcessed = FALSE;
1912             }
1913             break;
1914
1915         case WM_SETFOCUS:
1916             if (SHORT1FROMMP((MPARAM)lParam) == TRUE)
1917                 bProcessed = HandleSetFocus((WXHWND)(HWND)wParam);
1918             else
1919                 bProcessed = HandleKillFocus((WXHWND)(HWND)wParam);
1920             break;
1921
1922         case WM_PAINT:
1923             bProcessed = HandlePaint();
1924             break;
1925
1926         case WM_CLOSE:
1927             //
1928             // Don't let the DefWindowProc() destroy our window - we'll do it
1929             // ourselves in ~wxWindow
1930             //
1931             bProcessed = TRUE;
1932             mResult = (MRESULT)TRUE;
1933             break;
1934
1935         case WM_SHOW:
1936             bProcessed = HandleShow(wParam != 0, (int)lParam);
1937             break;
1938
1939         //
1940         // Under OS2 PM Joysticks are treated just like mouse events
1941         // The "Motion" events will be prevelent in joysticks
1942         //
1943         case WM_MOUSEMOVE:
1944         case WM_BUTTON1DOWN:
1945         case WM_BUTTON1UP:
1946         case WM_BUTTON1DBLCLK:
1947         case WM_BUTTON1MOTIONEND:
1948         case WM_BUTTON1MOTIONSTART:
1949         case WM_BUTTON2DOWN:
1950         case WM_BUTTON2UP:
1951         case WM_BUTTON2DBLCLK:
1952         case WM_BUTTON2MOTIONEND:
1953         case WM_BUTTON2MOTIONSTART:
1954         case WM_BUTTON3DOWN:
1955         case WM_BUTTON3UP:
1956         case WM_BUTTON3DBLCLK:
1957         case WM_BUTTON3MOTIONEND:
1958         case WM_BUTTON3MOTIONSTART:
1959             {
1960                 short x = LOWORD(lParam);
1961                 short y = HIWORD(lParam);
1962
1963                 bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam);
1964             }
1965             break;
1966         case WM_SYSCOMMAND:
1967             bProcessed = HandleSysCommand(wParam, lParam);
1968             break;
1969
1970         case WM_COMMAND:
1971             {
1972                 WORD id, cmd;
1973                 WXHWND hwnd;
1974                 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
1975
1976                 bProcessed = HandleCommand(id, cmd, hwnd);
1977             }
1978             break;
1979
1980             //
1981             // For these messages we must return TRUE if process the message
1982             //
1983         case WM_DRAWITEM:
1984         case WM_MEASUREITEM:
1985             {
1986                 int idCtrl = (UINT)wParam;
1987                 if ( uMsg == WM_DRAWITEM )
1988                 {
1989                     bProcessed = OS2OnDrawItem(idCtrl,
1990                                               (WXDRAWITEMSTRUCT *)lParam);
1991                 }
1992                 else
1993                 {
1994                     bProcessed = OS2OnMeasureItem(idCtrl,
1995                                                  (WXMEASUREITEMSTRUCT *)lParam);
1996                 }
1997
1998                 if ( bProcessed )
1999                     mResult = (MRESULT)TRUE;
2000             }
2001             break;
2002
2003         case WM_QUERYDLGCODE:
2004             if ( m_lDlgCode )
2005             {
2006                 mResult = (MRESULT)m_lDlgCode;
2007                 bProcessed = TRUE;
2008             }
2009             //
2010             //else: get the dlg code from the DefWindowProc()
2011             //
2012             break;
2013
2014         //
2015         // In OS/2 PM all keyboard events are of the WM_CHAR type.  Virtual key and key-up
2016         // and key-down events are obtained from the WM_CHAR params.
2017         //
2018         case WM_CHAR:
2019             {
2020                 USHORT                  uKeyFlags = SHORT1FROMMP((MPARAM)wParam);
2021
2022                 if (uKeyFlags & KC_KEYUP)
2023                 {
2024                     bProcessed = HandleKeyUp((WXDWORD)wParam, lParam);
2025                     break;
2026                 }
2027                 else // keydown event
2028                 {
2029                     //
2030                     // If this has been processed by an event handler,
2031                     // return 0 now (we've handled it). DON't RETURN
2032                     // we still need to process further
2033                     //
2034                     HandleKeyDown((WXDWORD)wParam, lParam);
2035                     if (uKeyFlags & KC_VIRTUALKEY)
2036                     {
2037                         USHORT          uVk = SHORT2FROMMP((MPARAM)lParam);
2038
2039                         //
2040                         // We consider these message "not interesting" to OnChar
2041                         //
2042                         if (uVk == VK_SHIFT || uVk == VK_CTRL )
2043                         {
2044                             bProcessed = TRUE;
2045                             break;
2046                         }
2047                         switch(uVk)
2048                         {
2049                             //
2050                             // Avoid duplicate messages to OnChar for these ASCII keys: they
2051                             // will be translated by TranslateMessage() and received in WM_CHAR
2052                             case VK_ESC:
2053                             case VK_SPACE:
2054                             case VK_ENTER:
2055                             case VK_BACKSPACE:
2056                             case VK_TAB:
2057                                 // But set processed to FALSE, not TRUE to still pass them to
2058                                 // the control's default window proc - otherwise built-in
2059                                 // keyboard handling won't work
2060                                 bProcessed = FALSE;
2061                                 break;
2062
2063                             case VK_LEFT:
2064                             case VK_RIGHT:
2065                             case VK_DOWN:
2066                             case VK_UP:
2067                             default:
2068                                 bProcessed = HandleChar((WXDWORD)wParam, lParam);
2069                          }
2070                          break;
2071                     }
2072                     else // WM_CHAR -- Always an ASCII character
2073                     {
2074                         bProcessed = HandleChar((WXDWORD)wParam, lParam, TRUE);
2075                         break;
2076                     }
2077                 }
2078             }
2079
2080         case WM_HSCROLL:
2081         case WM_VSCROLL:
2082             {
2083                 WXWORD              wCode;
2084                 WXWORD              wPos;
2085                 WXHWND              hWnd;
2086                 UnpackScroll( wParam
2087                              ,lParam
2088                              ,&wCode
2089                              ,&wPos
2090                              ,&hWnd
2091                             );
2092
2093                 bProcessed = OS2OnScroll( uMsg == WM_HSCROLL ? wxHORIZONTAL
2094                                                              : wxVERTICAL
2095                                          ,wCode
2096                                          ,wPos
2097                                          ,hWnd
2098                                         );
2099             }
2100             break;
2101
2102 #if defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
2103         case WM_CTLCOLORCHANGE:
2104             {
2105                 bProcessed = HandleCtlColor(&hBrush);
2106             }
2107             break;
2108 #endif
2109         case WM_ERASEBACKGROUND:
2110             //
2111             // Returning TRUE to requestw PM to paint the window background
2112             // in SYSCLR_WINDOW. We don't really want that
2113             //
2114             bProcessed = HandleEraseBkgnd((WXHDC)(HPS)wParam);
2115             mResult = (MRESULT)(FALSE);
2116             break;
2117
2118         //
2119         // Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to
2120         // things such as colors and fonts and such
2121         //
2122         case WM_QUERYWINDOWPARAMS:
2123             {
2124                 PWNDPARAMS          pWndParams = (PWNDPARAMS)wParam;
2125
2126                 bProcessed = HandleWindowParams( pWndParams
2127                                                 ,lParam
2128                                                );
2129             }
2130             break;
2131
2132             // the return value for this message is ignored
2133         case WM_SYSCOLORCHANGE:
2134             bProcessed = HandleSysColorChange();
2135             break;
2136
2137         case WM_REALIZEPALETTE:
2138             bProcessed = HandlePaletteChanged();
2139             break;
2140
2141         case WM_PRESPARAMCHANGED:
2142             bProcessed = HandlePresParamChanged(wParam);
2143             break;
2144
2145
2146         // move all drag and drops to wxDrg
2147         case WM_ENDDRAG:
2148             bProcessed = HandleEndDrag(wParam);
2149             break;
2150
2151         case WM_INITDLG:
2152             bProcessed = HandleInitDialog((WXHWND)(HWND)wParam);
2153
2154             if ( bProcessed )
2155             {
2156                 // we never set focus from here
2157                 mResult = FALSE;
2158             }
2159             break;
2160
2161         // wxFrame specific message
2162         case WM_MINMAXFRAME:
2163             bProcessed = HandleGetMinMaxInfo((PSWP)wParam);
2164             break;
2165
2166         case WM_SYSVALUECHANGED:
2167             // TODO: do something
2168             mResult = (MRESULT)TRUE;
2169             break;
2170
2171         //
2172         // Comparable to WM_SETPOINTER for windows, only for just controls
2173         //
2174         case WM_CONTROLPOINTER:
2175             bProcessed = HandleSetCursor( SHORT1FROMMP(wParam) // Control ID
2176                                          ,(HWND)lParam         // Cursor Handle
2177                                         );
2178             if (bProcessed )
2179             {
2180                 //
2181                 // Returning TRUE stops the DefWindowProc() from further
2182                 // processing this message - exactly what we need because we've
2183                 // just set the cursor.
2184                 //
2185                 mResult = (MRESULT)TRUE;
2186             }
2187             break;
2188     }
2189     if (!bProcessed)
2190     {
2191 #ifdef __WXDEBUG__
2192         wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
2193                    wxGetMessageName(uMsg));
2194 #endif // __WXDEBUG__
2195         if (IsKindOf(CLASSINFO(wxFrame)))
2196             mResult = ::WinDefWindowProc(m_hWnd, uMsg, wParam, lParam);
2197         else
2198             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
2199     }
2200     return mResult;
2201 } // end of wxWindow::OS2WindowProc
2202
2203 //
2204 // Dialog window proc
2205 //
2206 MRESULT wxDlgProc(
2207   HWND                              hWnd
2208 , UINT                              uMsg
2209 , MPARAM                            wParam
2210 , MPARAM                            lParam)
2211 {
2212     if (uMsg == WM_INITDLG)
2213     {
2214         //
2215         // For this message, returning TRUE tells system to set focus to the
2216         // first control in the dialog box
2217         //
2218         return (MRESULT)TRUE;
2219     }
2220     else
2221     {
2222         //
2223         // For all the other ones, FALSE means that we didn't process the
2224         // message
2225         //
2226         return (MRESULT)0;
2227     }
2228 } // end of wxDlgProc
2229
2230 wxWindow* wxFindWinFromHandle(
2231   WXHWND                            hWnd
2232 )
2233 {
2234     wxNode*                         pNode = wxWinHandleList->Find((long)hWnd);
2235
2236     if (!pNode)
2237         return NULL;
2238     return (wxWindow *)pNode->Data();
2239 } // end of wxFindWinFromHandle
2240
2241 void wxAssociateWinWithHandle(
2242   HWND                              hWnd
2243 , wxWindow*                         pWin
2244 )
2245 {
2246     //
2247     // Adding NULL hWnd is (first) surely a result of an error and
2248     // (secondly) breaks menu command processing
2249     //
2250     wxCHECK_RET( hWnd != (HWND)NULL,
2251                  wxT("attempt to add a NULL hWnd to window list ignored") );
2252
2253
2254     wxWindow*                       pOldWin = wxFindWinFromHandle((WXHWND) hWnd);
2255
2256     if (pOldWin && (pOldWin != pWin))
2257     {
2258         wxString                    str(pWin->GetClassInfo()->GetClassName());
2259         wxLogError( "Bug! Found existing HWND %X for new window of class %s"
2260                    ,(int)hWnd
2261                    ,(const char*)str
2262                   );
2263     }
2264     else if (!pOldWin)
2265     {
2266         wxWinHandleList->Append( (long)hWnd
2267                                 ,pWin
2268                                );
2269     }
2270 } // end of wxAssociateWinWithHandle
2271
2272 void wxRemoveHandleAssociation(
2273   wxWindow*                         pWin
2274 )
2275 {
2276     wxWinHandleList->DeleteObject(pWin);
2277 } // end of wxRemoveHandleAssociation
2278
2279 //
2280 // Default destroyer - override if you destroy it in some other way
2281 // (e.g. with MDI child windows)
2282 //
2283 void wxWindow::OS2DestroyWindow()
2284 {
2285 }
2286
2287 void wxWindow::OS2DetachWindowMenu()
2288 {
2289     if (m_hMenu)
2290     {
2291         HMENU                       hMenu = (HMENU)m_hMenu;
2292
2293         int                         nN = (int)::WinSendMsg(hMenu, MM_QUERYITEMCOUNT, 0, 0);
2294         int                         i;
2295
2296         for (i = 0; i < nN; i++)
2297         {
2298             wxChar                   zBuf[100];
2299             int                      nChars = (int)::WinSendMsg( hMenu
2300                                                                 ,MM_QUERYITEMTEXT
2301                                                                 ,MPFROM2SHORT(i, nN)
2302                                                                 ,zBuf
2303                                                                );
2304             if (!nChars)
2305             {
2306                 wxLogLastError(wxT("GetMenuString"));
2307                 continue;
2308             }
2309
2310             if (wxStrcmp(zBuf, wxT("&Window")) == 0)
2311             {
2312                 ::WinSendMsg(hMenu, MM_DELETEITEM, MPFROM2SHORT(i, TRUE), 0);
2313                 break;
2314             }
2315         }
2316     }
2317 } // end of wxWindow::OS2DetachWindowMenu
2318
2319 bool wxWindow::OS2Create(
2320   WXHWND                            hParent
2321 , PSZ                               zClass
2322 , const wxChar*                     zTitle
2323 , WXDWORD                           dwStyle
2324 , long                              lX
2325 , long                              lY
2326 , long                              lWidth
2327 , long                              lHeight
2328 , WXHWND                            hOwner
2329 , WXHWND                            hZOrder
2330 , unsigned long                     ulId
2331 , void*                             pCtlData
2332 , void*                             pPresParams
2333 )
2334 {
2335     ERRORID                         vError;
2336     wxString                        sError;
2337     long                            lX1      = 0L;
2338     long                            lY1      = 0L;
2339     long                            lWidth1  = 20L;
2340     long                            lHeight1 = 20L;
2341     int                             nControlId = 0;
2342     int                             nNeedsubclass = 0;
2343     PCSZ                            pszClass = zClass;
2344
2345     //
2346     // Find parent's size, if it exists, to set up a possible default
2347     // panel size the size of the parent window
2348     //
2349     RECTL                           vParentRect;
2350     HWND                            hWndClient;
2351
2352     if (lX > -1L)
2353         lX1 = lX;
2354     if (lY > -1L)
2355         lY1 = lY;
2356     if (lWidth > -1L)
2357         lWidth1 = lWidth;
2358     if (lHeight > -1L)
2359         lHeight1 = lHeight;
2360
2361     wxWndHook = this;
2362
2363     //
2364     // check to see if the new window is a standard control
2365     //
2366     if ((ULONG)zClass == (ULONG)WC_BUTTON ||
2367         (ULONG)zClass == (ULONG)WC_COMBOBOX ||
2368         (ULONG)zClass == (ULONG)WC_CONTAINER ||
2369         (ULONG)zClass == (ULONG)WC_ENTRYFIELD ||
2370         (ULONG)zClass == (ULONG)WC_FRAME ||
2371         (ULONG)zClass == (ULONG)WC_LISTBOX ||
2372         (ULONG)zClass == (ULONG)WC_MENU ||
2373         (ULONG)zClass == (ULONG)WC_NOTEBOOK ||
2374         (ULONG)zClass == (ULONG)WC_SCROLLBAR ||
2375         (ULONG)zClass == (ULONG)WC_SPINBUTTON ||
2376         (ULONG)zClass == (ULONG)WC_STATIC ||
2377         (ULONG)zClass == (ULONG)WC_TITLEBAR ||
2378         (ULONG)zClass == (ULONG)WC_VALUESET
2379        )
2380     {
2381             nControlId = ulId;
2382     }
2383     else
2384     {
2385         // no standard controls
2386         if(wxString (wxT("wxFrameClass")) == wxString(zClass) )
2387         {
2388             pszClass =  WC_FRAME;
2389             nNeedsubclass = 1;
2390         }
2391         else
2392         {
2393             nControlId = ulId;
2394             if(nControlId < 0)
2395                 nControlId = FID_CLIENT;
2396         }
2397     }
2398
2399     //
2400     // We will either have a registered class via string name or a standard PM Class via a long
2401     //
2402     m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
2403                                        ,zClass
2404                                        ,(PSZ)zTitle ? zTitle : wxT("")
2405                                        ,(ULONG)dwStyle
2406                                        ,(LONG)lX1
2407                                        ,(LONG)lY1
2408                                        ,(LONG)lWidth
2409                                        ,(LONG)lHeight
2410                                        ,hOwner
2411                                        ,HWND_TOP
2412                                        ,(ULONG)nControlId
2413                                        ,pCtlData
2414                                        ,pPresParams
2415                                       );
2416     if (!m_hWnd)
2417     {
2418         vError = ::WinGetLastError(vHabmain);
2419         sError = wxPMErrorToStr(vError);
2420         wxLogError("Can't create window of class %s!. Error: %s\n", zClass, sError);
2421         return FALSE;
2422     }
2423     ::WinSetWindowULong(m_hWnd, QWL_USER, (ULONG) this);
2424     wxWndHook = NULL;
2425
2426 #ifdef __WXDEBUG__
2427     wxNode*                         pNode = wxWinHandleList->Member(this);
2428
2429     if (pNode)
2430     {
2431         HWND                        hWnd = (HWND)pNode->GetKeyInteger();
2432
2433         if (hWnd != (HWND)m_hWnd)
2434
2435         {
2436             wxLogError("A second HWND association is being added for the same window!");
2437         }
2438     }
2439 #endif
2440     wxAssociateWinWithHandle((HWND)m_hWnd
2441                              ,this
2442                             );
2443     //
2444     // Now need to subclass window.
2445     //
2446     if(!nNeedsubclass)
2447     {
2448          wxAssociateWinWithHandle((HWND)m_hWnd,this);
2449     }
2450     else
2451     {
2452         SubclassWin(GetHWND());
2453     }
2454     return TRUE;
2455 } // end of wxWindow::OS2Create
2456
2457 // ===========================================================================
2458 // OS2 PM message handlers
2459 // ===========================================================================
2460
2461 // ---------------------------------------------------------------------------
2462 // window creation/destruction
2463 // ---------------------------------------------------------------------------
2464
2465 bool wxWindow::HandleCreate(
2466   WXLPCREATESTRUCT                  vCs
2467 , bool*                             pbMayCreate
2468 )
2469 {
2470     wxWindowCreateEvent             vEvent(this);
2471
2472     (void)GetEventHandler()->ProcessEvent(vEvent);
2473     *pbMayCreate = TRUE;
2474     return TRUE;
2475 } // end of wxWindow::HandleCreate
2476
2477 bool wxWindow::HandleDestroy()
2478 {
2479     wxWindowDestroyEvent            vEvent(this);
2480
2481     (void)GetEventHandler()->ProcessEvent(vEvent);
2482
2483     //
2484     // Delete our drop target if we've got one
2485     //
2486 #if wxUSE_DRAG_AND_DROP
2487     if (m_dropTarget != NULL)
2488     {
2489         m_dropTarget->Revoke(m_hWnd);
2490         delete m_dropTarget;
2491         m_dropTarget = NULL;
2492     }
2493 #endif // wxUSE_DRAG_AND_DROP
2494
2495     //
2496     // WM_DESTROY handled
2497     //
2498     return TRUE;
2499 } // end of wxWindow::HandleDestroy
2500
2501 // ---------------------------------------------------------------------------
2502 // activation/focus
2503 // ---------------------------------------------------------------------------
2504 void wxWindow::OnSetFocus(
2505   wxFocusEvent&                     rEvent
2506 )
2507 {
2508     //
2509     // Panel wants to track the window which was the last to have focus in it,
2510     // so we want to set ourselves as the window which last had focus
2511     //
2512     // Notice that it's also important to do it upwards the tree becaus
2513     // otherwise when the top level panel gets focus, it won't set it back to
2514     // us, but to some other sibling
2515     //
2516     wxWindow*                       pWin = this;
2517
2518     while (pWin)
2519     {
2520         wxWindow*                   pParent = pWin->GetParent();
2521         wxPanel*                    pPanel = wxDynamicCast( pParent
2522                                                            ,wxPanel
2523                                                           );
2524         if (pPanel)
2525         {
2526             pPanel->SetLastFocus(pWin);
2527         }
2528         pWin = pParent;
2529     }
2530
2531     wxLogTrace(_T("focus"), _T("%s (0x%08x) gets focus"),
2532                GetClassInfo()->GetClassName(), GetHandle());
2533
2534     rEvent.Skip();
2535 } // end of wxWindow::OnSetFocus
2536
2537 bool wxWindow::HandleActivate(
2538   int                               nState
2539 , WXHWND                            WXUNUSED(hActivate)
2540 )
2541 {
2542     wxActivateEvent                 vEvent( wxEVT_ACTIVATE
2543                                            ,(bool)nState
2544                                            ,m_windowId
2545                                           );
2546     vEvent.SetEventObject(this);
2547     return GetEventHandler()->ProcessEvent(vEvent);
2548 } // end of wxWindow::HandleActivate
2549
2550 bool wxWindow::HandleSetFocus(
2551   WXHWND                            WXUNUSED(hWnd)
2552 )
2553 {
2554 #if wxUSE_CARET
2555     //
2556     // Deal with caret
2557     //
2558     if (m_caret)
2559     {
2560         m_caret->OnSetFocus();
2561     }
2562 #endif // wxUSE_CARET
2563
2564     //
2565     // Panel wants to track the window which was the last to have focus in it
2566     //
2567     wxPanel*                        pPanel = wxDynamicCast( GetParent()
2568                                                            ,wxPanel
2569                                                           );
2570     if (pPanel)
2571     {
2572         pPanel->SetLastFocus(this);
2573     }
2574
2575     wxFocusEvent                    vEvent(wxEVT_SET_FOCUS, m_windowId);
2576
2577     vEvent.SetEventObject(this);
2578     return GetEventHandler()->ProcessEvent(vEvent);
2579 } // end of wxWindow::HandleSetFocus
2580
2581 bool wxWindow::HandleKillFocus(
2582   WXHWND                            WXUNUSED(hWnd)
2583 )
2584 {
2585 #if wxUSE_CARET
2586     //
2587     // Deal with caret
2588     //
2589     if (m_caret)
2590     {
2591         m_caret->OnKillFocus();
2592     }
2593 #endif // wxUSE_CARET
2594
2595     wxFocusEvent                    vEvent( wxEVT_KILL_FOCUS
2596                                            ,m_windowId
2597                                           );
2598
2599     vEvent.SetEventObject(this);
2600     return GetEventHandler()->ProcessEvent(vEvent);
2601 } // end of wxWindow::HandleKillFocus
2602
2603 // ---------------------------------------------------------------------------
2604 // miscellaneous
2605 // ---------------------------------------------------------------------------
2606
2607 bool wxWindow::HandleShow(
2608   bool                              bShow
2609 , int                               nStatus
2610 )
2611 {
2612     wxShowEvent                     vEvent( GetId()
2613                                            ,bShow
2614                                           );
2615
2616     vEvent.m_eventObject = this;
2617     return GetEventHandler()->ProcessEvent(vEvent);
2618 } // end of wxWindow::HandleShow
2619
2620 bool wxWindow::HandleInitDialog(
2621   WXHWND                            WXUNUSED(hWndFocus)
2622 )
2623 {
2624     wxInitDialogEvent               vEvent(GetId());
2625
2626     vEvent.m_eventObject = this;
2627     return GetEventHandler()->ProcessEvent(vEvent);
2628 } // end of wxWindow::HandleInitDialog
2629
2630 bool wxWindow::HandleEndDrag(WXWPARAM wParam)
2631 {
2632    // TODO: We'll handle drag and drop later
2633     return FALSE;
2634 }
2635
2636 bool wxWindow::HandleSetCursor(
2637   USHORT                            vId
2638 , WXHWND                            hPointer
2639 )
2640 {
2641     //
2642     // Under OS/2 PM this allows the pointer to be changed
2643     // as it passes over a control
2644     //
2645     ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer);
2646     return TRUE;
2647 } // end of wxWindow::HandleSetCursor
2648
2649 // ---------------------------------------------------------------------------
2650 // owner drawn stuff
2651 // ---------------------------------------------------------------------------
2652 bool wxWindow::OS2OnDrawItem(
2653   int                               vId
2654 , WXDRAWITEMSTRUCT*                 pItemStruct
2655 )
2656 {
2657     //
2658     // I'll get to owner drawn stuff later
2659     //
2660
2661     //
2662     // is it a menu item or control?
2663     //
2664     wxWindow*                       pItem = FindItem(vId);
2665
2666 #if wxUSE_OWNER_DRAWN
2667     if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
2668     {
2669         return ((wxControl *)pItem)->OS2OnDraw(pItemStruct);
2670     }
2671     else if (pItem && pItem->IsKindOf(CLASSINFO(wxMenu)))
2672     {
2673         /*
2674         // TODO: draw a menu item
2675         //
2676         POWNERITEM                  pDrawStruct = (OWNERITEM *)pItemStruct;
2677         wxMenuItem*                 pMenuItem = (wxMenuItem *)(pDrawStruct->pItemData);
2678
2679         wxCHECK(pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE);
2680
2681         //
2682         // Prepare to call OnDrawItem()
2683         //
2684         HPSdc;
2685         dc.SetHDC((WXHDC)pDrawStruct->hDC, FALSE);
2686         wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
2687                     pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
2688                     pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
2689
2690         return pMenuItem->OnDrawItem
2691                           (
2692                             dc, rect,
2693                             (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
2694                             (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
2695                           );
2696         */
2697     }
2698
2699     else
2700         return FALSE;
2701 #endif
2702     return TRUE;
2703 } // end of wxWindow::OS2OnDrawItem
2704
2705 bool wxWindow::OS2OnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
2706 {
2707    // TODO: more owner drawn menu related stuff, get to it later
2708 /*
2709 #if wxUSE_OWNER_DRAWN
2710     // is it a menu item?
2711     if ( id == 0 )
2712     {
2713         MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
2714         wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
2715
2716         wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
2717
2718         return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
2719                                         &pMeasureStruct->itemHeight);
2720     }
2721
2722     wxWindow *item = FindItem(id);
2723     if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
2724     {
2725         return ((wxControl *)item)->MSWOnMeasure(itemStruct);
2726     }
2727 #endif  // owner-drawn menus
2728 */
2729     return FALSE;
2730 }
2731
2732 // ---------------------------------------------------------------------------
2733 // colours and palettes
2734 // ---------------------------------------------------------------------------
2735
2736 bool wxWindow::HandleSysColorChange()
2737 {
2738     wxSysColourChangedEvent         vEvent;
2739
2740     vEvent.SetEventObject(this);
2741     return GetEventHandler()->ProcessEvent(vEvent);
2742 } // end of wxWindow::HandleSysColorChange
2743
2744 bool wxWindow::HandleCtlColor(
2745   WXHBRUSH*                         phBrush
2746 )
2747 {
2748     //
2749     // Not much provided with message. So not sure I can do anything with it
2750     //
2751     return TRUE;
2752 } // end of wxWindow::HandleCtlColor
2753
2754 bool wxWindow::HandleWindowParams(
2755   PWNDPARAMS                        pWndParams
2756 , WXLPARAM                          lParam
2757 )
2758 {
2759 // TODO: I'll do something here, just not sure what yet
2760     return TRUE;
2761 }
2762
2763 // Define for each class of dialog and control
2764 WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC,
2765                               WXHWND hWnd,
2766                               WXUINT nCtlColor,
2767                               WXUINT message,
2768                               WXWPARAM wParam,
2769                               WXLPARAM lParam)
2770 {
2771     return (WXHBRUSH)0;
2772 }
2773
2774 bool wxWindow::HandlePaletteChanged()
2775 {
2776     // need to set this to something first
2777     WXHWND                          hWndPalChange = NULLHANDLE;
2778
2779     wxPaletteChangedEvent           vEvent(GetId());
2780
2781     vEvent.SetEventObject(this);
2782     vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
2783
2784     return GetEventHandler()->ProcessEvent(vEvent);
2785 } // end of wxWindow::HandlePaletteChanged
2786
2787 bool wxWindow::HandlePresParamChanged(
2788   WXWPARAM                          wParam
2789 )
2790 {
2791     //
2792     // TODO:  Once again I'll do something here when I need it
2793     //
2794     //wxQueryNewPaletteEvent event(GetId());
2795     //event.SetEventObject(this);
2796     // if the background is erased
2797 //            bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
2798
2799     return FALSE; //GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
2800 }
2801
2802 //
2803 // Responds to colour changes: passes event on to children.
2804 //
2805 void wxWindow::OnSysColourChanged(
2806   wxSysColourChangedEvent&          rEvent
2807 )
2808 {
2809     wxNode*                         pNode = GetChildren().First();
2810
2811     while (pNode)
2812     {
2813         //
2814         // Only propagate to non-top-level windows
2815         //
2816         wxWindow*                   pWin = (wxWindow *)pNode->Data();
2817
2818         if (pWin->GetParent())
2819         {
2820             wxSysColourChangedEvent vEvent;
2821
2822             rEvent.m_eventObject = pWin;
2823             pWin->GetEventHandler()->ProcessEvent(vEvent);
2824         }
2825         pNode = pNode->Next();
2826     }
2827 } // end of wxWindow::OnSysColourChanged
2828
2829 // ---------------------------------------------------------------------------
2830 // painting
2831 // ---------------------------------------------------------------------------
2832
2833 bool wxWindow::HandlePaint()
2834 {
2835     HRGN                            hRgn = NULLHANDLE;
2836     wxPaintEvent                    vEvent;
2837     HPS                             hPS;
2838     RECTL                           vRect;
2839
2840     if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_NULL)
2841     {
2842          wxLogLastError("CreateRectRgn");
2843          return FALSE;
2844     }
2845
2846     m_updateRegion = wxRegion(hRgn);
2847     vEvent.SetEventObject(this);
2848     if (!GetEventHandler()->ProcessEvent(vEvent))
2849     {
2850         HPS                         hPS;
2851
2852         hPS = ::WinBeginPaint( GetHwnd()
2853                               ,NULLHANDLE
2854                               ,&vRect
2855                              );
2856         if(hPS)
2857         {
2858             ::GpiCreateLogColorTable( hPS
2859                                      ,0L
2860                                      ,LCOLF_CONSECRGB
2861                                      ,0L
2862                                      ,(LONG)wxTheColourDatabase->m_nSize
2863                                      ,(PLONG)wxTheColourDatabase->m_palTable
2864                                     );
2865             ::GpiCreateLogColorTable( hPS
2866                                      ,0L
2867                                      ,LCOLF_RGB
2868                                      ,0L
2869                                      ,0L
2870                                      ,NULL
2871                                     );
2872
2873             ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
2874             ::WinEndPaint(hPS);
2875         }
2876     }
2877     return (GetEventHandler()->ProcessEvent(vEvent));
2878 } // end of wxWindow::HandlePaint
2879
2880 bool wxWindow::HandleEraseBkgnd(
2881   WXHDC                             hDC
2882 )
2883 {
2884     SWP                             vSwp;
2885
2886     ::WinQueryWindowPos(GetHwnd(), &vSwp);
2887     if (vSwp.fl & SWP_MINIMIZE)
2888         return TRUE;
2889
2890     wxDC                            vDC;
2891
2892     vDC.m_hPS = (HPS)hDC; // this is really a PS
2893     vDC.SetWindow(this);
2894     vDC.BeginDrawing();
2895
2896     wxEraseEvent                    vEvent(m_windowId, &vDC);
2897
2898     vEvent.SetEventObject(this);
2899
2900     bool                            rc = GetEventHandler()->ProcessEvent(vEvent);
2901
2902     vDC.EndDrawing();
2903     vDC.m_hPS = NULLHANDLE;
2904     return TRUE;
2905 } // end of wxWindow::HandleEraseBkgnd
2906
2907 void wxWindow::OnEraseBackground(
2908   wxEraseEvent&                     rEvent
2909 )
2910 {
2911     RECTL                           vRect;
2912     HPS                             hPS = rEvent.m_dc->m_hPS;
2913
2914     ::WinQueryWindowRect(GetHwnd(), &vRect);
2915     ::WinFillRect(hPS, &vRect,  m_backgroundColour.GetPixel());
2916 }  // end of wxWindow::OnEraseBackground
2917
2918 // ---------------------------------------------------------------------------
2919 // moving and resizing
2920 // ---------------------------------------------------------------------------
2921
2922 bool wxWindow::HandleMinimize()
2923 {
2924     wxIconizeEvent                  vEvent(m_windowId);
2925
2926     vEvent.SetEventObject(this);
2927     return GetEventHandler()->ProcessEvent(vEvent);
2928 } // end of wxWindow::HandleMinimize
2929
2930 bool wxWindow::HandleMaximize()
2931 {
2932     wxMaximizeEvent                 vEvent(m_windowId);
2933
2934     vEvent.SetEventObject(this);
2935     return GetEventHandler()->ProcessEvent(vEvent);
2936 } // end of wxWindow::HandleMaximize
2937
2938 bool wxWindow::HandleMove(
2939   int                               nX
2940 , int                               nY
2941 )
2942 {
2943     wxMoveEvent                     vEvent( wxPoint( nX
2944                                                     ,nY
2945                                                    )
2946                                            ,m_windowId
2947                                           );
2948
2949     vEvent.SetEventObject(this);
2950     return GetEventHandler()->ProcessEvent(vEvent);
2951 }  // end of wxWindow::HandleMove
2952
2953 bool wxWindow::HandleSize(
2954   int                               nWidth
2955 , int                               nHeight
2956 , WXUINT                            WXUNUSED(nFlag)
2957 )
2958 {
2959     wxSizeEvent                     vEvent( wxSize( nWidth
2960                                                    ,nHeight
2961                                                   )
2962                                            ,m_windowId
2963                                           );
2964
2965     vEvent.SetEventObject(this);
2966     return GetEventHandler()->ProcessEvent(vEvent);
2967 } // end of wxWindow::HandleSize
2968
2969 bool wxWindow::HandleGetMinMaxInfo(
2970   PSWP                              pSwp
2971 )
2972 {
2973     bool                            bRc = FALSE;
2974     POINTL                          vPoint;
2975
2976     switch(pSwp->fl)
2977     {
2978         case SWP_MAXIMIZE:
2979             ::WinGetMaxPosition(GetHwnd(), pSwp);
2980             m_maxWidth = pSwp->cx;
2981             m_maxHeight = pSwp->cy;
2982             break;
2983
2984         case SWP_MINIMIZE:
2985             ::WinGetMinPosition(GetHwnd(), pSwp, &vPoint);
2986             m_minWidth = pSwp->cx;
2987             m_minHeight = pSwp->cy;
2988             break;
2989
2990         default:
2991             return FALSE;
2992     }
2993     return TRUE;
2994 } // end of wxWindow::HandleGetMinMaxInfo
2995
2996 // ---------------------------------------------------------------------------
2997 // command messages
2998 // ---------------------------------------------------------------------------
2999 bool wxWindow::HandleCommand(
3000   WXWORD                            wId
3001 , WXWORD                            wCmd
3002 , WXHWND                            hControl
3003 )
3004 {
3005     if (wxCurrentPopupMenu)
3006     {
3007         wxMenu*                     pPopupMenu = wxCurrentPopupMenu;
3008
3009         wxCurrentPopupMenu = NULL;
3010         return pPopupMenu->OS2Command(wCmd, wId);
3011     }
3012
3013     wxWindow*                       pWin = FindItem(wId);
3014
3015     if (!pWin)
3016     {
3017         pWin = wxFindWinFromHandle(hControl);
3018     }
3019
3020     if (pWin)
3021         return pWin->OS2Command( wCmd
3022                                 ,wId
3023                                );
3024     return FALSE;
3025 } // end of wxWindow::HandleCommand
3026
3027 bool wxWindow::HandleSysCommand(
3028   WXWPARAM                          wParam
3029 , WXLPARAM                          lParam
3030 )
3031 {
3032     //
3033     // 4 bits are reserved
3034     //
3035     switch (SHORT1FROMMP(wParam))
3036     {
3037         case SC_MAXIMIZE:
3038             return HandleMaximize();
3039
3040         case SC_MINIMIZE:
3041             return HandleMinimize();
3042     }
3043     return FALSE;
3044 } // end of wxWindow::HandleSysCommand
3045
3046 // ---------------------------------------------------------------------------
3047 // mouse events
3048 // ---------------------------------------------------------------------------
3049
3050 void wxWindow::InitMouseEvent(
3051   wxMouseEvent&                     rEvent
3052 , int                               nX
3053 , int                               nY
3054 , WXUINT                            uFlags
3055 )
3056 {
3057     rEvent.m_x           = nX;
3058     rEvent.m_y           = nY;
3059     rEvent.m_shiftDown   = ((uFlags & VK_SHIFT) != 0);
3060     rEvent.m_controlDown = ((uFlags & VK_CTRL) != 0);
3061     rEvent.m_leftDown    = ((uFlags & VK_BUTTON1) != 0);
3062     rEvent.m_middleDown  = ((uFlags & VK_BUTTON3) != 0);
3063     rEvent.m_rightDown   = ((uFlags & VK_BUTTON2) != 0);
3064     rEvent.SetTimestamp(s_currentMsg.time);
3065     rEvent.m_eventObject = this;
3066
3067 #if wxUSE_MOUSEEVENT_HACK
3068     m_lastMouseX = nX;
3069     m_lastMouseY = nY;
3070     m_lastMouseEvent = rEvent.GetEventType();
3071 #endif // wxUSE_MOUSEEVENT_HACK
3072 } // end of wxWindow::InitMouseEvent
3073
3074 bool wxWindow::HandleMouseEvent(
3075   WXUINT                            uMsg
3076 , int                               nX
3077 , int                               nY
3078 , WXUINT                            uFlags
3079 )
3080 {
3081     //
3082     // The mouse events take consecutive IDs from WM_MOUSEFIRST to
3083     // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
3084     // from the message id and take the value in the table to get wxWin event
3085     // id
3086     //
3087     static const wxEventType eventsMouse[] =
3088     {
3089         wxEVT_MOTION,
3090         wxEVT_LEFT_DOWN,
3091         wxEVT_LEFT_UP,
3092         wxEVT_LEFT_DCLICK,
3093         wxEVT_RIGHT_DOWN,
3094         wxEVT_RIGHT_UP,
3095         wxEVT_RIGHT_DCLICK,
3096         wxEVT_MIDDLE_DOWN,
3097         wxEVT_MIDDLE_UP,
3098         wxEVT_MIDDLE_DCLICK
3099     };
3100
3101     wxMouseEvent                    vEvent(eventsMouse[uMsg - WM_MOUSEMOVE]);
3102
3103     InitMouseEvent( vEvent
3104                    ,nX
3105                    ,nY
3106                    ,uFlags
3107                   );
3108
3109     return GetEventHandler()->ProcessEvent(vEvent);
3110 } // end of wxWindow::HandleMouseEvent
3111
3112 bool wxWindow::HandleMouseMove(
3113   int                               nX
3114 , int                               nY
3115 , WXUINT                            uFlags
3116 )
3117 {
3118     if (!m_bMouseInWindow)
3119     {
3120         //
3121         // Generate an ENTER event
3122         //
3123         m_bMouseInWindow = TRUE;
3124
3125         wxMouseEvent                vEvent(wxEVT_ENTER_WINDOW);
3126
3127         InitMouseEvent( vEvent
3128                        ,nX
3129                        ,nY
3130                        ,uFlags
3131                       );
3132
3133         (void)GetEventHandler()->ProcessEvent(vEvent);
3134     }
3135     return HandleMouseEvent( WM_MOUSEMOVE
3136                             ,nX
3137                             ,nY
3138                             ,uFlags
3139                            );
3140 } // end of wxWindow::HandleMouseMove
3141
3142 // ---------------------------------------------------------------------------
3143 // keyboard handling
3144 // ---------------------------------------------------------------------------
3145
3146 //
3147 // Create the key event of the given type for the given key - used by
3148 // HandleChar and HandleKeyDown/Up
3149 //
3150 wxKeyEvent wxWindow::CreateKeyEvent(
3151   wxEventType                       eType
3152 , int                               nId
3153 , WXLPARAM                          lParam
3154 ) const
3155 {
3156     wxKeyEvent                      vEvent(eType);
3157
3158     vEvent.SetId(GetId());
3159     vEvent.m_shiftDown   = IsShiftDown();
3160     vEvent.m_controlDown = IsCtrlDown();
3161     vEvent.m_altDown     = (HIWORD(lParam) & KC_ALT) == KC_ALT;
3162
3163     vEvent.m_eventObject = (wxWindow *)this; // const_cast
3164     vEvent.m_keyCode     = nId;
3165     vEvent.SetTimestamp(s_currentMsg.time);
3166
3167     //
3168     // Translate the position to client coords
3169     //
3170     POINTL                          vPoint;
3171     RECTL                           vRect;
3172
3173     ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
3174     ::WinQueryWindowRect( GetHwnd()
3175                          ,&vRect
3176                         );
3177
3178     vPoint.x -= vRect.xLeft;
3179     vPoint.y -= vRect.yBottom;
3180
3181     vEvent.m_x = vPoint.x;
3182     vEvent.m_y = vPoint.y;
3183
3184     return vEvent;
3185 } // end of wxWindow::CreateKeyEvent
3186
3187 //
3188 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
3189 // WM_KEYDOWN one
3190 //
3191 bool wxWindow::HandleChar(
3192   WXWORD                            wParam
3193 , WXLPARAM                          lParam
3194 , bool                              isASCII
3195 )
3196 {
3197     bool                            bCtrlDown = FALSE;
3198     int                             vId;
3199
3200     if (isASCII)
3201     {
3202         //
3203         // If 1 -> 26, translate to CTRL plus a letter.
3204         //
3205         vId = wParam;
3206         if ((vId > 0) && (vId < 27))
3207         {
3208             switch (vId)
3209             {
3210                 case 13:
3211                     vId = WXK_RETURN;
3212                     break;
3213
3214                 case 8:
3215                     vId = WXK_BACK;
3216                     break;
3217
3218                 case 9:
3219                     vId = WXK_TAB;
3220                     break;
3221
3222                 default:
3223                     bCtrlDown = TRUE;
3224                     vId = vId + 96;
3225             }
3226         }
3227     }
3228     else if ( (vId = wxCharCodeOS2ToWX(wParam)) == 0)
3229     {
3230         //
3231         // It's ASCII and will be processed here only when called from
3232         // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
3233         //
3234         vId = -1;
3235     }
3236
3237     if (vId != -1)
3238     {
3239         wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_CHAR
3240                                                           ,vId
3241                                                           ,lParam
3242                                                          ));
3243
3244         if (bCtrlDown)
3245         {
3246             vEvent.m_controlDown = TRUE;
3247         }
3248
3249         if (GetEventHandler()->ProcessEvent(vEvent))
3250             return TRUE;
3251     }
3252     return FALSE;
3253 }
3254
3255 bool wxWindow::HandleKeyDown(
3256   WXWORD                            wParam
3257 , WXLPARAM                          lParam
3258 )
3259 {
3260     int                             nId = wxCharCodeOS2ToWX(wParam);
3261
3262     if (!nId)
3263     {
3264         //
3265         // Normal ASCII char
3266         //
3267         nId = wParam;
3268     }
3269
3270     if (nId != -1)
3271     {
3272         wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_KEY_DOWN
3273                                                           ,nId
3274                                                           ,lParam
3275                                                          ));
3276
3277         if (GetEventHandler()->ProcessEvent(vEvent))
3278         {
3279             return TRUE;
3280         }
3281     }
3282     return FALSE;
3283 } // end of wxWindow::HandleKeyDown
3284
3285 bool wxWindow::HandleKeyUp(
3286   WXWORD                            wParam
3287 , WXLPARAM                          lParam
3288 )
3289 {
3290     int                             nId = wxCharCodeOS2ToWX(wParam);
3291
3292     if (!nId)
3293     {
3294         //
3295         // Normal ASCII char
3296         //
3297         nId = wParam;
3298     }
3299
3300     if (nId != -1)
3301     {
3302         wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_KEY_UP
3303                                                           ,nId
3304                                                           ,lParam
3305                                                          ));
3306
3307         if (GetEventHandler()->ProcessEvent(vEvent))
3308             return TRUE;
3309     }
3310     return FALSE;
3311 } // end of wxWindow::HandleKeyUp
3312
3313 // ---------------------------------------------------------------------------
3314 // joystick
3315 // ---------------------------------------------------------------------------
3316
3317 // ---------------------------------------------------------------------------
3318 // scrolling
3319 // ---------------------------------------------------------------------------
3320
3321 bool wxWindow::OS2OnScroll(
3322   int                               nOrientation
3323 , WXWORD                            wParam
3324 , WXWORD                            wPos
3325 , WXHWND                            hControl
3326 )
3327 {
3328     if (hControl)
3329     {
3330         wxWindow*                   pChild = wxFindWinFromHandle(hControl);
3331
3332         if (pChild )
3333             return pChild->OS2OnScroll( nOrientation
3334                                        ,wParam
3335                                        ,wPos
3336                                        ,hControl
3337                                       );
3338     }
3339
3340     wxScrollWinEvent                vEvent;
3341
3342     vEvent.SetPosition(wPos);
3343     vEvent.SetOrientation(nOrientation);
3344     vEvent.m_eventObject = this;
3345
3346     switch (wParam)
3347     {
3348         case SB_LINEUP:
3349             vEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
3350             break;
3351
3352         case SB_LINEDOWN:
3353             vEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
3354             break;
3355
3356         case SB_PAGEUP:
3357             vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
3358             break;
3359
3360         case SB_PAGEDOWN:
3361             vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
3362             break;
3363
3364         case SB_SLIDERPOSITION:
3365             vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBRELEASE;
3366             break;
3367
3368         case SB_SLIDERTRACK:
3369             vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBTRACK;
3370             break;
3371
3372         default:
3373             return FALSE;
3374     }
3375     return GetEventHandler()->ProcessEvent(vEvent);
3376 } // end of wxWindow::OS2OnScroll
3377
3378 // ===========================================================================
3379 // global functions
3380 // ===========================================================================
3381
3382 void wxGetCharSize(
3383   WXHWND                            hWnd
3384 , int*                              pX
3385 , int*                              pY
3386 ,wxFont*                            pTheFont
3387 )
3388 {
3389   // TODO: we'll do this later
3390 } // end of wxGetCharSize
3391
3392 //
3393 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
3394 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
3395 //
3396 int wxCharCodeOS2ToWX(
3397   int                               nKeySym
3398 )
3399 {
3400     int                             nId = 0;
3401
3402     switch (nKeySym)
3403     {
3404         case VK_BACKTAB:    nId = WXK_BACK; break;
3405         case VK_TAB:        nId = WXK_TAB; break;
3406         case VK_CLEAR:      nId = WXK_CLEAR; break;
3407         case VK_ENTER:      nId = WXK_RETURN; break;
3408         case VK_SHIFT:      nId = WXK_SHIFT; break;
3409         case VK_CTRL:       nId = WXK_CONTROL; break;
3410         case VK_PAUSE:      nId = WXK_PAUSE; break;
3411         case VK_SPACE:      nId = WXK_SPACE; break;
3412         case VK_ESC:        nId = WXK_ESCAPE; break;
3413         case VK_END:        nId = WXK_END; break;
3414         case VK_HOME :      nId = WXK_HOME; break;
3415         case VK_LEFT :      nId = WXK_LEFT; break;
3416         case VK_UP:         nId = WXK_UP; break;
3417         case VK_RIGHT:      nId = WXK_RIGHT; break;
3418         case VK_DOWN :      nId = WXK_DOWN; break;
3419         case VK_PRINTSCRN:  nId = WXK_PRINT; break;
3420         case VK_INSERT:     nId = WXK_INSERT; break;
3421         case VK_DELETE:     nId = WXK_DELETE; break;
3422         case VK_F1:         nId = WXK_F1; break;
3423         case VK_F2:         nId = WXK_F2; break;
3424         case VK_F3:         nId = WXK_F3; break;
3425         case VK_F4:         nId = WXK_F4; break;
3426         case VK_F5:         nId = WXK_F5; break;
3427         case VK_F6:         nId = WXK_F6; break;
3428         case VK_F7:         nId = WXK_F7; break;
3429         case VK_F8:         nId = WXK_F8; break;
3430         case VK_F9:         nId = WXK_F9; break;
3431         case VK_F10:        nId = WXK_F10; break;
3432         case VK_F11:        nId = WXK_F11; break;
3433         case VK_F12:        nId = WXK_F12; break;
3434         case VK_F13:        nId = WXK_F13; break;
3435         case VK_F14:        nId = WXK_F14; break;
3436         case VK_F15:        nId = WXK_F15; break;
3437         case VK_F16:        nId = WXK_F16; break;
3438         case VK_F17:        nId = WXK_F17; break;
3439         case VK_F18:        nId = WXK_F18; break;
3440         case VK_F19:        nId = WXK_F19; break;
3441         case VK_F20:        nId = WXK_F20; break;
3442         case VK_F21:        nId = WXK_F21; break;
3443         case VK_F22:        nId = WXK_F22; break;
3444         case VK_F23:        nId = WXK_F23; break;
3445         case VK_F24:        nId = WXK_F24; break;
3446         case VK_NUMLOCK:    nId = WXK_NUMLOCK; break;
3447         case VK_SCRLLOCK:   nId = WXK_SCROLL; break;
3448         default:
3449         {
3450             return 0;
3451         }
3452     }
3453     return nId;
3454 } // end of wxCharCodeOS2ToWX
3455
3456 int wxCharCodeWXToOS2(
3457   int                               nId
3458 , bool*                             bIsVirtual
3459 )
3460 {
3461     int                             nKeySym = 0;
3462
3463     *bIsVirtual = TRUE;
3464     switch (nId)
3465     {
3466         case WXK_CLEAR:     nKeySym = VK_CLEAR; break;
3467         case WXK_SHIFT:     nKeySym = VK_SHIFT; break;
3468         case WXK_CONTROL:   nKeySym = VK_CTRL; break;
3469         case WXK_PAUSE:     nKeySym = VK_PAUSE; break;
3470         case WXK_END:       nKeySym = VK_END; break;
3471         case WXK_HOME :     nKeySym = VK_HOME; break;
3472         case WXK_LEFT :     nKeySym = VK_LEFT; break;
3473         case WXK_UP:        nKeySym = VK_UP; break;
3474         case WXK_RIGHT:     nKeySym = VK_RIGHT; break;
3475         case WXK_DOWN :     nKeySym = VK_DOWN; break;
3476         case WXK_PRINT:     nKeySym = VK_PRINTSCRN; break;
3477         case WXK_INSERT:    nKeySym = VK_INSERT; break;
3478         case WXK_DELETE:    nKeySym = VK_DELETE; break;
3479         case WXK_F1:        nKeySym = VK_F1; break;
3480         case WXK_F2:        nKeySym = VK_F2; break;
3481         case WXK_F3:        nKeySym = VK_F3; break;
3482         case WXK_F4:        nKeySym = VK_F4; break;
3483         case WXK_F5:        nKeySym = VK_F5; break;
3484         case WXK_F6:        nKeySym = VK_F6; break;
3485         case WXK_F7:        nKeySym = VK_F7; break;
3486         case WXK_F8:        nKeySym = VK_F8; break;
3487         case WXK_F9:        nKeySym = VK_F9; break;
3488         case WXK_F10:       nKeySym = VK_F10; break;
3489         case WXK_F11:       nKeySym = VK_F11; break;
3490         case WXK_F12:       nKeySym = VK_F12; break;
3491         case WXK_F13:       nKeySym = VK_F13; break;
3492         case WXK_F14:       nKeySym = VK_F14; break;
3493         case WXK_F15:       nKeySym = VK_F15; break;
3494         case WXK_F16:       nKeySym = VK_F16; break;
3495         case WXK_F17:       nKeySym = VK_F17; break;
3496         case WXK_F18:       nKeySym = VK_F18; break;
3497         case WXK_F19:       nKeySym = VK_F19; break;
3498         case WXK_F20:       nKeySym = VK_F20; break;
3499         case WXK_F21:       nKeySym = VK_F21; break;
3500         case WXK_F22:       nKeySym = VK_F22; break;
3501         case WXK_F23:       nKeySym = VK_F23; break;
3502         case WXK_F24:       nKeySym = VK_F24; break;
3503         case WXK_NUMLOCK:   nKeySym = VK_NUMLOCK; break;
3504         case WXK_SCROLL:    nKeySym = VK_SCRLLOCK; break;
3505         default:
3506         {
3507             *bIsVirtual = FALSE;
3508             nKeySym = nId;
3509             break;
3510         }
3511     }
3512     return nKeySym;
3513 } // end of wxCharCodeWXToOS2
3514
3515 wxWindow* wxGetActiveWindow()
3516 {
3517     HWND                            hWnd = ::WinQueryActiveWindow(HWND_DESKTOP);
3518
3519     if (hWnd != 0)
3520     {
3521         return wxFindWinFromHandle((WXHWND)hWnd);
3522     }
3523     return NULL;
3524 } // end of wxGetActiveWindow
3525
3526 #ifdef __WXDEBUG__
3527 const char* wxGetMessageName(
3528   int                               nMessage)
3529 {
3530     switch (nMessage)
3531     {
3532         case 0x0000: return "WM_NULL";
3533         case 0x0001: return "WM_CREATE";
3534         case 0x0002: return "WM_DESTROY";
3535         case 0x0004: return "WM_ENABLE";
3536         case 0x0005: return "WM_SHOW";
3537         case 0x0006: return "WM_MOVE";
3538         case 0x0007: return "WM_SIZE";
3539         case 0x0008: return "WM_ADJUSTWINDOWPOS";
3540         case 0x0009: return "WM_CALCVALIDRECTS";
3541         case 0x000A: return "WM_SETWINDOWPARAMS";
3542         case 0x000B: return "WM_QUERYWINDOWPARAMS";
3543         case 0x000C: return "WM_HITTEST";
3544         case 0x000D: return "WM_ACTIVATE";
3545         case 0x000F: return "WM_SETFOCUS";
3546         case 0x0010: return "WM_SETSELECTION";
3547         case 0x0011: return "WM_PPAINT";
3548         case 0x0012: return "WM_PSETFOCUS";
3549         case 0x0013: return "WM_PSYSCOLORCHANGE";
3550         case 0x0014: return "WM_PSIZE";
3551         case 0x0015: return "WM_PACTIVATE";
3552         case 0x0016: return "WM_PCONTROL";
3553         case 0x0020: return "WM_COMMAND";
3554         case 0x0021: return "WM_SYSCOMMAND";
3555         case 0x0022: return "WM_HELP";
3556         case 0x0023: return "WM_PAINT";
3557         case 0x0024: return "WM_TIMER";
3558         case 0x0025: return "WM_SEM1";
3559         case 0x0026: return "WM_SEM2";
3560         case 0x0027: return "WM_SEM3";
3561         case 0x0028: return "WM_SEM4";
3562         case 0x0029: return "WM_CLOSE";
3563         case 0x002A: return "WM_QUIT";
3564         case 0x002B: return "WM_SYSCOLORCHANGE";
3565         case 0x002D: return "WM_SYSVALUECHANGE";
3566         case 0x002E: return "WM_APPTERMINATENOTIFY";
3567         case 0x002F: return "WM_PRESPARAMCHANGED";
3568         // Control notification messages
3569         case 0x0030: return "WM_CONTROL";
3570         case 0x0031: return "WM_VSCROLL";
3571         case 0x0032: return "WM_HSCROLL";
3572         case 0x0033: return "WM_INITMENU";
3573         case 0x0034: return "WM_MENUSELECT";
3574         case 0x0035: return "WM_MENUSEND";
3575         case 0x0036: return "WM_DRAWITEM";
3576         case 0x0037: return "WM_MEASUREITEM";
3577         case 0x0038: return "WM_CONTROLPOINTER";
3578         case 0x003A: return "WM_QUERYDLGCODE";
3579         case 0x003B: return "WM_INITDLG";
3580         case 0x003C: return "WM_SUBSTITUTESTRING";
3581         case 0x003D: return "WM_MATCHMNEMONIC";
3582         case 0x003E: return "WM_SAVEAPPLICATION";
3583         case 0x0129: return "WM_CTLCOLORCHANGE";
3584         case 0x0130: return "WM_QUERYCTLTYPE";
3585         // Frame messages
3586         case 0x0040: return "WM_FLASHWINDOW";
3587         case 0x0041: return "WM_FORMATFRAME";
3588         case 0x0042: return "WM_UPDATEFRAME";
3589         case 0x0043: return "WM_FOCUSCHANGE";
3590         case 0x0044: return "WM_SETBORDERSIZE";
3591         case 0x0045: return "WM_TRACKFRAME";
3592         case 0x0046: return "WM_MINMAXFRAME";
3593         case 0x0047: return "WM_SETICON";
3594         case 0x0048: return "WM_QUERYICON";
3595         case 0x0049: return "WM_SETACCELTABLE";
3596         case 0x004A: return "WM_QUERYACCELTABLE";
3597         case 0x004B: return "WM_TRANSLATEACCEL";
3598         case 0x004C: return "WM_QUERYTRACKINFO";
3599         case 0x004D: return "WM_QUERYBORDERSIZE";
3600         case 0x004E: return "WM_NEXTMENU";
3601         case 0x004F: return "WM_ERASEBACKGROUND";
3602         case 0x0050: return "WM_QUERYFRAMEINFO";
3603         case 0x0051: return "WM_QUERYFOCUSCHAIN";
3604         case 0x0052: return "WM_OWNERPOSCHANGE";
3605         case 0x0053: return "WM_CACLFRAMERECT";
3606         case 0x0055: return "WM_WINDOWPOSCHANGED";
3607         case 0x0056: return "WM_ADJUSTFRAMEPOS";
3608         case 0x0059: return "WM_QUERYFRAMECTLCOUNT";
3609         case 0x005B: return "WM_QUERYHELPINFO";
3610         case 0x005C: return "WM_SETHELPINFO";
3611         case 0x005D: return "WM_ERROR";
3612         case 0x005E: return "WM_REALIZEPALETTE";
3613         // Clipboard messages
3614         case 0x0060: return "WM_RENDERFMT";
3615         case 0x0061: return "WM_RENDERALLFMTS";
3616         case 0x0062: return "WM_DESTROYCLIPBOARD";
3617         case 0x0063: return "WM_PAINTCLIPBOARD";
3618         case 0x0064: return "WM_SIZECLIPBOARD";
3619         case 0x0065: return "WM_HSCROLLCLIPBOARD";
3620         case 0x0066: return "WM_VSCROLLCLIPBOARD";
3621         case 0x0067: return "WM_DRAWCLIPBOARD";
3622         // mouse messages
3623         case 0x0070: return "WM_MOUSEMOVE";
3624         case 0x0071: return "WM_BUTTON1DOWN";
3625         case 0x0072: return "WM_BUTTON1UP";
3626         case 0x0073: return "WM_BUTTON1DBLCLK";
3627         case 0x0074: return "WM_BUTTON2DOWN";
3628         case 0x0075: return "WM_BUTTON2UP";
3629         case 0x0076: return "WM_BUTTON2DBLCLK";
3630         case 0x0077: return "WM_BUTTON3DOWN";
3631         case 0x0078: return "WM_BUTTON3UP";
3632         case 0x0079: return "WM_BUTTON3DBLCLK";
3633         case 0x007D: return "WM_MOUSEMAP";
3634         case 0x007E: return "WM_VRNDISABLED";
3635         case 0x007F: return "WM_VRNENABLED";
3636         case 0x0410: return "WM_CHORD";
3637         case 0x0411: return "WM_BUTTON1MOTIONSTART";
3638         case 0x0412: return "WM_BUTTON1MOTIONEND";
3639         case 0x0413: return "WM_BUTTON1CLICK";
3640         case 0x0414: return "WM_BUTTON2MOTIONSTART";
3641         case 0x0415: return "WM_BUTTON2MOTIONEND";
3642         case 0x0416: return "WM_BUTTON2CLICK";
3643         case 0x0417: return "WM_BUTTON3MOTIONSTART";
3644         case 0x0418: return "WM_BUTTON3MOTIONEND";
3645         case 0x0419: return "WM_BUTTON3CLICK";
3646         case 0x0420: return "WM_BEGINDRAG";
3647         case 0x0421: return "WM_ENDDRAG";
3648         case 0x0422: return "WM_SINGLESELECT";
3649         case 0x0423: return "WM_OPEN";
3650         case 0x0424: return "WM_CONTEXTMENU";
3651         case 0x0425: return "WM_CONTEXTHELP";
3652         case 0x0426: return "WM_TEXTEDIT";
3653         case 0x0427: return "WM_BEGINSELECT";
3654         case 0x0228: return "WM_ENDSELECT";
3655         case 0x0429: return "WM_PICKUP";
3656         case 0x04C0: return "WM_PENFIRST";
3657         case 0x04FF: return "WM_PENLAST";
3658         case 0x0500: return "WM_MMPMFIRST";
3659         case 0x05FF: return "WM_MMPMLAST";
3660         case 0x0600: return "WM_STDDLGFIRST";
3661         case 0x06FF: return "WM_STDDLGLAST";
3662         case 0x0BD0: return "WM_BIDI_FIRST";
3663         case 0x0BFF: return "WM_BIDI_LAST";
3664         // keyboard input
3665         case 0x007A: return "WM_CHAR";
3666         case 0x007B: return "WM_VIOCHAR";
3667         // DDE messages
3668         case 0x00A0: return "WM_DDE_INITIATE";
3669         case 0x00A1: return "WM_DDE_REQUEST";
3670         case 0x00A2: return "WM_DDE_ACK";
3671         case 0x00A3: return "WM_DDE_DATA";
3672         case 0x00A4: return "WM_DDE_ADVISE";
3673         case 0x00A5: return "WM_DDE_UNADVISE";
3674         case 0x00A6: return "WM_DDE_POKE";
3675         case 0x00A7: return "WM_DDE_EXECUTE";
3676         case 0x00A8: return "WM_DDE_TERMINATE";
3677         case 0x00A9: return "WM_DDE_INITIATEACK";
3678         case 0x00AF: return "WM_DDE_LAST";
3679         // Buttons
3680         case 0x0120: return "BM_CLICK";
3681         case 0x0121: return "BM_QUERYCHECKINDEX";
3682         case 0x0122: return "BM_QUERYHILITE";
3683         case 0x0123: return "BM_SETHILITE";
3684         case 0x0124: return "BM_QUERYCHECK";
3685         case 0x0125: return "BM_SETCHECK";
3686         case 0x0126: return "BM_SETDEFAULT";
3687         case 0x0128: return "BM_AUTOSIZE";
3688         // Combo boxes
3689         case 0x029A: return "CBID_LIST";
3690         case 0x029B: return "CBID_EDIT";
3691         case 0x0170: return "CBM_SHOWLIST";
3692         case 0x0171: return "CBM_HILITE";
3693         case 0x0172: return "CBM_ISLISTSHOWING";
3694         // Edit fields
3695         case 0x0140: return "EM_QUERYCHANGED";
3696         case 0x0141: return "EM_QUERYSEL";
3697         case 0x0142: return "EM_SETSEL";
3698         case 0x0143: return "EM_SETTEXTLIMIT";
3699         case 0x0144: return "EM_CUT";
3700         case 0x0145: return "EM_COPY";
3701         case 0x0146: return "EM_CLEAR";
3702         case 0x0147: return "EM_PASTE";
3703         case 0x0148: return "EM_QUERYFIRSTCHAR";
3704         case 0x0149: return "EM_SETFIRSTCHAR";
3705         case 0x014A: return "EM_QUERYREADONLY";
3706         case 0x014B: return "EM_SETREADONLY";
3707         case 0x014C: return "EM_SETINSERTMODE";
3708         // Listboxes
3709         case 0x0160: return "LM_QUERYITEMCOUNT";
3710         case 0x0161: return "LM_INSERTITEM";
3711         case 0x0162: return "LM_SETOPENINDEX";
3712         case 0x0163: return "LM_DELETEITEM";
3713         case 0x0164: return "LM_SELECTITEM";
3714         case 0x0165: return "LM_QUERYSELECTION";
3715         case 0x0166: return "LM_SETITEMTEXT";
3716         case 0x0167: return "LM_QUERYITEMTEXTLENGTH";
3717         case 0x0168: return "LM_QUERYITEMTEXT";
3718         case 0x0169: return "LM_SETITEMHANDLE";
3719         case 0x016A: return "LM_QUERYITEMHANDLE";
3720         case 0x016B: return "LM_SEARCHSTRING";
3721         case 0x016C: return "LM_SETITEMHEIGHT";
3722         case 0x016D: return "LM_QUERYTOPINDEX";
3723         case 0x016E: return "LM_DELETEALL";
3724         case 0x016F: return "LM_INSERTMULITEMS";
3725         case 0x0660: return "LM_SETITEMWIDTH";
3726         // Menus
3727         case 0x0180: return "MM_INSERTITEM";
3728         case 0x0181: return "MM_DELETEITEM";
3729         case 0x0182: return "MM_QUERYITEM";
3730         case 0x0183: return "MM_SETITEM";
3731         case 0x0184: return "MM_QUERYITEMCOUNT";
3732         case 0x0185: return "MM_STARTMENUMODE";
3733         case 0x0186: return "MM_ENDMENUMODE";
3734         case 0x0188: return "MM_REMOVEITEM";
3735         case 0x0189: return "MM_SELECTITEM";
3736         case 0x018A: return "MM_QUERYSELITEMID";
3737         case 0x018B: return "MM_QUERYITEMTEXT";
3738         case 0x018C: return "MM_QUERYITEMTEXTLENGTH";
3739         case 0x018D: return "MM_SETITEMHANDLE";
3740         case 0x018E: return "MM_SETITEMTEXT";
3741         case 0x018F: return "MM_ITEMPOSITIONFROMID";
3742         case 0x0190: return "MM_ITEMIDFROMPOSITION";
3743         case 0x0191: return "MM_QUERYITEMATTR";
3744         case 0x0192: return "MM_SETITEMATTR";
3745         case 0x0193: return "MM_ISITEMVALID";
3746         case 0x0194: return "MM_QUERYITEMRECT";
3747         case 0x0431: return "MM_QUERYDEFAULTITEMID";
3748         case 0x0432: return "MM_SETDEFAULTITEMID";
3749         // Scrollbars
3750         case 0x01A0: return "SBM_SETSCROLLBAR";
3751         case 0x01A1: return "SBM_SETPOS";
3752         case 0x01A2: return "SBM_QUERYPOS";
3753         case 0x01A3: return "SBM_QUERYRANGE";
3754         case 0x01A6: return "SBM_SETTHUMBSIZE";
3755
3756         // Help messages
3757         case 0x0F00: return "WM_HELPBASE";
3758         case 0x0FFF: return "WM_HELPTOP";
3759         // Beginning of user defined messages
3760         case 0x1000: return "WM_USER";
3761
3762         // wxWindows user defined types
3763
3764         // listview
3765         // case 0x1000 + 0: return "LVM_GETBKCOLOR";
3766         case 0x1000 + 1: return "LVM_SETBKCOLOR";
3767         case 0x1000 + 2: return "LVM_GETIMAGELIST";
3768         case 0x1000 + 3: return "LVM_SETIMAGELIST";
3769         case 0x1000 + 4: return "LVM_GETITEMCOUNT";
3770         case 0x1000 + 5: return "LVM_GETITEMA";
3771         case 0x1000 + 75: return "LVM_GETITEMW";
3772         case 0x1000 + 6: return "LVM_SETITEMA";
3773         case 0x1000 + 76: return "LVM_SETITEMW";
3774         case 0x1000 + 7: return "LVM_INSERTITEMA";
3775         case 0x1000 + 77: return "LVM_INSERTITEMW";
3776         case 0x1000 + 8: return "LVM_DELETEITEM";
3777         case 0x1000 + 9: return "LVM_DELETEALLITEMS";
3778         case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
3779         case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
3780         case 0x1000 + 12: return "LVM_GETNEXTITEM";
3781         case 0x1000 + 13: return "LVM_FINDITEMA";
3782         case 0x1000 + 83: return "LVM_FINDITEMW";
3783         case 0x1000 + 14: return "LVM_GETITEMRECT";
3784         case 0x1000 + 15: return "LVM_SETITEMPOSITION";
3785         case 0x1000 + 16: return "LVM_GETITEMPOSITION";
3786         case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
3787         case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
3788         case 0x1000 + 18: return "LVM_HITTEST";
3789         case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
3790         case 0x1000 + 20: return "LVM_SCROLL";
3791         case 0x1000 + 21: return "LVM_REDRAWITEMS";
3792         case 0x1000 + 22: return "LVM_ARRANGE";
3793         case 0x1000 + 23: return "LVM_EDITLABELA";
3794         case 0x1000 + 118: return "LVM_EDITLABELW";
3795         case 0x1000 + 24: return "LVM_GETEDITCONTROL";
3796         case 0x1000 + 25: return "LVM_GETCOLUMNA";
3797         case 0x1000 + 95: return "LVM_GETCOLUMNW";
3798         case 0x1000 + 26: return "LVM_SETCOLUMNA";
3799         case 0x1000 + 96: return "LVM_SETCOLUMNW";
3800         case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
3801         case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
3802         case 0x1000 + 28: return "LVM_DELETECOLUMN";
3803         case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
3804         case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
3805         case 0x1000 + 31: return "LVM_GETHEADER";
3806         case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
3807         case 0x1000 + 34: return "LVM_GETVIEWRECT";
3808         case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
3809         case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
3810         case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
3811         case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
3812         case 0x1000 + 39: return "LVM_GETTOPINDEX";
3813         case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
3814         case 0x1000 + 41: return "LVM_GETORIGIN";
3815         case 0x1000 + 42: return "LVM_UPDATE";
3816         case 0x1000 + 43: return "LVM_SETITEMSTATE";
3817         case 0x1000 + 44: return "LVM_GETITEMSTATE";
3818         case 0x1000 + 45: return "LVM_GETITEMTEXTA";
3819         case 0x1000 + 115: return "LVM_GETITEMTEXTW";
3820         case 0x1000 + 46: return "LVM_SETITEMTEXTA";
3821         case 0x1000 + 116: return "LVM_SETITEMTEXTW";
3822         case 0x1000 + 47: return "LVM_SETITEMCOUNT";
3823         case 0x1000 + 48: return "LVM_SORTITEMS";
3824         case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
3825         case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
3826         case 0x1000 + 51: return "LVM_GETITEMSPACING";
3827         case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
3828         case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
3829         case 0x1000 + 53: return "LVM_SETICONSPACING";
3830         case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
3831         case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
3832         case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
3833         case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
3834         case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
3835         case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
3836         case 0x1000 + 60: return "LVM_SETHOTITEM";
3837         case 0x1000 + 61: return "LVM_GETHOTITEM";
3838         case 0x1000 + 62: return "LVM_SETHOTCURSOR";
3839         case 0x1000 + 63: return "LVM_GETHOTCURSOR";
3840         case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
3841         case 0x1000 + 65: return "LVM_SETWORKAREA";
3842
3843         // tree view
3844         case 0x1100 + 0: return "TVM_INSERTITEMA";
3845         case 0x1100 + 50: return "TVM_INSERTITEMW";
3846         case 0x1100 + 1: return "TVM_DELETEITEM";
3847         case 0x1100 + 2: return "TVM_EXPAND";
3848         case 0x1100 + 4: return "TVM_GETITEMRECT";
3849         case 0x1100 + 5: return "TVM_GETCOUNT";
3850         case 0x1100 + 6: return "TVM_GETINDENT";
3851         case 0x1100 + 7: return "TVM_SETINDENT";
3852         case 0x1100 + 8: return "TVM_GETIMAGELIST";
3853         case 0x1100 + 9: return "TVM_SETIMAGELIST";
3854         case 0x1100 + 10: return "TVM_GETNEXTITEM";
3855         case 0x1100 + 11: return "TVM_SELECTITEM";
3856         case 0x1100 + 12: return "TVM_GETITEMA";
3857         case 0x1100 + 62: return "TVM_GETITEMW";
3858         case 0x1100 + 13: return "TVM_SETITEMA";
3859         case 0x1100 + 63: return "TVM_SETITEMW";
3860         case 0x1100 + 14: return "TVM_EDITLABELA";
3861         case 0x1100 + 65: return "TVM_EDITLABELW";
3862         case 0x1100 + 15: return "TVM_GETEDITCONTROL";
3863         case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
3864         case 0x1100 + 17: return "TVM_HITTEST";
3865         case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
3866         case 0x1100 + 19: return "TVM_SORTCHILDREN";
3867         case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
3868         case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
3869         case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
3870         case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
3871         case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
3872         case 0x1100 + 24: return "TVM_SETTOOLTIPS";
3873         case 0x1100 + 25: return "TVM_GETTOOLTIPS";
3874
3875         // header
3876         case 0x1200 + 0: return "HDM_GETITEMCOUNT";
3877         case 0x1200 + 1: return "HDM_INSERTITEMA";
3878         case 0x1200 + 10: return "HDM_INSERTITEMW";
3879         case 0x1200 + 2: return "HDM_DELETEITEM";
3880         case 0x1200 + 3: return "HDM_GETITEMA";
3881         case 0x1200 + 11: return "HDM_GETITEMW";
3882         case 0x1200 + 4: return "HDM_SETITEMA";
3883         case 0x1200 + 12: return "HDM_SETITEMW";
3884         case 0x1200 + 5: return "HDM_LAYOUT";
3885         case 0x1200 + 6: return "HDM_HITTEST";
3886         case 0x1200 + 7: return "HDM_GETITEMRECT";
3887         case 0x1200 + 8: return "HDM_SETIMAGELIST";
3888         case 0x1200 + 9: return "HDM_GETIMAGELIST";
3889         case 0x1200 + 15: return "HDM_ORDERTOINDEX";
3890         case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
3891         case 0x1200 + 17: return "HDM_GETORDERARRAY";
3892         case 0x1200 + 18: return "HDM_SETORDERARRAY";
3893         case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
3894
3895         // tab control
3896         case 0x1300 + 2: return "TCM_GETIMAGELIST";
3897         case 0x1300 + 3: return "TCM_SETIMAGELIST";
3898         case 0x1300 + 4: return "TCM_GETITEMCOUNT";
3899         case 0x1300 + 5: return "TCM_GETITEMA";
3900         case 0x1300 + 60: return "TCM_GETITEMW";
3901         case 0x1300 + 6: return "TCM_SETITEMA";
3902         case 0x1300 + 61: return "TCM_SETITEMW";
3903         case 0x1300 + 7: return "TCM_INSERTITEMA";
3904         case 0x1300 + 62: return "TCM_INSERTITEMW";
3905         case 0x1300 + 8: return "TCM_DELETEITEM";
3906         case 0x1300 + 9: return "TCM_DELETEALLITEMS";
3907         case 0x1300 + 10: return "TCM_GETITEMRECT";
3908         case 0x1300 + 11: return "TCM_GETCURSEL";
3909         case 0x1300 + 12: return "TCM_SETCURSEL";
3910         case 0x1300 + 13: return "TCM_HITTEST";
3911         case 0x1300 + 14: return "TCM_SETITEMEXTRA";
3912         case 0x1300 + 40: return "TCM_ADJUSTRECT";
3913         case 0x1300 + 41: return "TCM_SETITEMSIZE";
3914         case 0x1300 + 42: return "TCM_REMOVEIMAGE";
3915         case 0x1300 + 43: return "TCM_SETPADDING";
3916         case 0x1300 + 44: return "TCM_GETROWCOUNT";
3917         case 0x1300 + 45: return "TCM_GETTOOLTIPS";
3918         case 0x1300 + 46: return "TCM_SETTOOLTIPS";
3919         case 0x1300 + 47: return "TCM_GETCURFOCUS";
3920         case 0x1300 + 48: return "TCM_SETCURFOCUS";
3921         case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
3922         case 0x1300 + 50: return "TCM_DESELECTALL";
3923
3924         // toolbar
3925         case WM_USER+1000+1: return "TB_ENABLEBUTTON";
3926         case WM_USER+1000+2: return "TB_CHECKBUTTON";
3927         case WM_USER+1000+3: return "TB_PRESSBUTTON";
3928         case WM_USER+1000+4: return "TB_HIDEBUTTON";
3929         case WM_USER+1000+5: return "TB_INDETERMINATE";
3930         case WM_USER+1000+9: return "TB_ISBUTTONENABLED";
3931         case WM_USER+1000+10: return "TB_ISBUTTONCHECKED";
3932         case WM_USER+1000+11: return "TB_ISBUTTONPRESSED";
3933         case WM_USER+1000+12: return "TB_ISBUTTONHIDDEN";
3934         case WM_USER+1000+13: return "TB_ISBUTTONINDETERMINATE";
3935         case WM_USER+1000+17: return "TB_SETSTATE";
3936         case WM_USER+1000+18: return "TB_GETSTATE";
3937         case WM_USER+1000+19: return "TB_ADDBITMAP";
3938         case WM_USER+1000+20: return "TB_ADDBUTTONS";
3939         case WM_USER+1000+21: return "TB_INSERTBUTTON";
3940         case WM_USER+1000+22: return "TB_DELETEBUTTON";
3941         case WM_USER+1000+23: return "TB_GETBUTTON";
3942         case WM_USER+1000+24: return "TB_BUTTONCOUNT";
3943         case WM_USER+1000+25: return "TB_COMMANDTOINDEX";
3944         case WM_USER+1000+26: return "TB_SAVERESTOREA";
3945         case WM_USER+1000+76: return "TB_SAVERESTOREW";
3946         case WM_USER+1000+27: return "TB_CUSTOMIZE";
3947         case WM_USER+1000+28: return "TB_ADDSTRINGA";
3948         case WM_USER+1000+77: return "TB_ADDSTRINGW";
3949         case WM_USER+1000+29: return "TB_GETITEMRECT";
3950         case WM_USER+1000+30: return "TB_BUTTONSTRUCTSIZE";
3951         case WM_USER+1000+31: return "TB_SETBUTTONSIZE";
3952         case WM_USER+1000+32: return "TB_SETBITMAPSIZE";
3953         case WM_USER+1000+33: return "TB_AUTOSIZE";
3954         case WM_USER+1000+35: return "TB_GETTOOLTIPS";
3955         case WM_USER+1000+36: return "TB_SETTOOLTIPS";
3956         case WM_USER+1000+37: return "TB_SETPARENT";
3957         case WM_USER+1000+39: return "TB_SETROWS";
3958         case WM_USER+1000+40: return "TB_GETROWS";
3959         case WM_USER+1000+42: return "TB_SETCMDID";
3960         case WM_USER+1000+43: return "TB_CHANGEBITMAP";
3961         case WM_USER+1000+44: return "TB_GETBITMAP";
3962         case WM_USER+1000+45: return "TB_GETBUTTONTEXTA";
3963         case WM_USER+1000+75: return "TB_GETBUTTONTEXTW";
3964         case WM_USER+1000+46: return "TB_REPLACEBITMAP";
3965         case WM_USER+1000+47: return "TB_SETINDENT";
3966         case WM_USER+1000+48: return "TB_SETIMAGELIST";
3967         case WM_USER+1000+49: return "TB_GETIMAGELIST";
3968         case WM_USER+1000+50: return "TB_LOADIMAGES";
3969         case WM_USER+1000+51: return "TB_GETRECT";
3970         case WM_USER+1000+52: return "TB_SETHOTIMAGELIST";
3971         case WM_USER+1000+53: return "TB_GETHOTIMAGELIST";
3972         case WM_USER+1000+54: return "TB_SETDISABLEDIMAGELIST";
3973         case WM_USER+1000+55: return "TB_GETDISABLEDIMAGELIST";
3974         case WM_USER+1000+56: return "TB_SETSTYLE";
3975         case WM_USER+1000+57: return "TB_GETSTYLE";
3976         case WM_USER+1000+58: return "TB_GETBUTTONSIZE";
3977         case WM_USER+1000+59: return "TB_SETBUTTONWIDTH";
3978         case WM_USER+1000+60: return "TB_SETMAXTEXTROWS";
3979         case WM_USER+1000+61: return "TB_GETTEXTROWS";
3980         case WM_USER+1000+41: return "TB_GETBITMAPFLAGS";
3981
3982         default:
3983             static char s_szBuf[128];
3984             sprintf(s_szBuf, "<unknown message = %d>", nMessage);
3985             return s_szBuf;
3986     }
3987    return NULL;
3988 } // end of wxGetMessageName
3989
3990 #endif // __WXDEBUG__
3991
3992 static void TranslateKbdEventToMouse(
3993   wxWindow*                         pWin
3994 , int*                              pX
3995 , int*                              pY
3996 , ULONG*                            pFlags
3997 )
3998 {
3999     //
4000     // Construct the key mask
4001     ULONG&                          fwKeys = *pFlags;
4002
4003     fwKeys = VK_BUTTON2;
4004     if ((::WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x100) != 0)
4005         fwKeys |= VK_CTRL;
4006     if ((::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x100) != 0)
4007         fwKeys |= VK_SHIFT;
4008
4009     //
4010     // Simulate right mouse button click
4011     //
4012     POINTL                          vPoint;
4013
4014     ::WinQueryMsgPos(vHabmain, &vPoint);
4015     *pX = vPoint.x;
4016     *pY = vPoint.y;
4017
4018     pWin->ScreenToClient(pX, pY);
4019 } // end of TranslateKbdEventToMouse
4020
4021 // Find the wxWindow at the current mouse position, returning the mouse
4022 // position.
4023 wxWindow* wxFindWindowAtPointer(
4024   wxPoint&                          rPt
4025 )
4026 {
4027     return wxFindWindowAtPoint(wxGetMousePosition());
4028 }
4029
4030 wxWindow* wxFindWindowAtPoint(
4031   const wxPoint&                    rPt
4032 )
4033 {
4034     POINTL                          vPt2;
4035
4036     vPt2.x = rPt.x;
4037     vPt2.y = rPt.y;
4038
4039     HWND                            hWndHit = ::WinWindowFromPoint(HWND_DESKTOP, &vPt2, FALSE);
4040     wxWindow*                       pWin = wxFindWinFromHandle((WXHWND)hWndHit) ;
4041     HWND                            hWnd = hWndHit;
4042
4043     //
4044     // Try to find a window with a wxWindow associated with it
4045     //
4046     while (!pWin && (hWnd != 0))
4047     {
4048         hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
4049         pWin = wxFindWinFromHandle((WXHWND)hWnd) ;
4050     }
4051     return pWin;
4052 }
4053
4054 // Get the current mouse position.
4055 wxPoint wxGetMousePosition()
4056 {
4057     POINTL                          vPt;
4058
4059     ::WinQueryPointerPos(HWND_DESKTOP, &vPt);
4060     return wxPoint(vPt.x, vPt.y);
4061 }
4062