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