]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/window.cpp
applied (slightly modified) wxGLApp patch for MSW
[wxWidgets.git] / src / os2 / window.cpp
index fb4a8cb4b76170b4d97b9d86cbac11ab51021379..bd50f98ca95ba20f8d9690ede9e90042d3624b7c 100644 (file)
@@ -149,11 +149,11 @@ static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL
     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 
 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
-    EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
-    EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
-    EVT_INIT_DIALOG(wxWindow::OnInitDialog)
-    EVT_IDLE(wxWindow::OnIdle)
-    EVT_SET_FOCUS(wxWindow::OnSetFocus)
+    EVT_ERASE_BACKGROUND(wxWindowOS2::OnEraseBackground)
+    EVT_SYS_COLOUR_CHANGED(wxWindowOS2::OnSysColourChanged)
+    EVT_INIT_DIALOG(wxWindowOS2::OnInitDialog)
+    EVT_IDLE(wxWindowOS2::OnIdle)
+    EVT_SET_FOCUS(wxWindowOS2::OnSetFocus)
 END_EVENT_TABLE()
 
 // ===========================================================================
@@ -163,7 +163,7 @@ END_EVENT_TABLE()
 //
 // Find an item given the PM Window id
 //
-wxWindow* wxWindow::FindItem(
+wxWindow* wxWindowOS2::FindItem(
   long                              lId
 ) const
 {
@@ -196,12 +196,12 @@ wxWindow* wxWindow::FindItem(
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
-} // end of wxWindow::FindItem
+} // end of wxWindowOS2::FindItem
 
 //
 // Find an item given the PM Window handle
 //
-wxWindow* wxWindow::FindItemByHWND(
+wxWindow* wxWindowOS2::FindItemByHWND(
   WXHWND                            hWnd
 , bool                              bControlOnly
 ) const
@@ -235,12 +235,12 @@ wxWindow* wxWindow::FindItemByHWND(
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
-} // end of wxWindow::FindItemByHWND
+} // end of wxWindowOS2::FindItemByHWND
 
 //
 // Default command handler
 //
-bool wxWindow::OS2Command(
+bool wxWindowOS2::OS2Command(
   WXUINT                            WXUNUSED(uParam)
 , WXWORD                            WXUNUSED(uId)
 )
@@ -252,7 +252,7 @@ bool wxWindow::OS2Command(
 // constructors and such
 // ----------------------------------------------------------------------------
 
-void wxWindow::Init()
+void wxWindowOS2::Init()
 {
     //
     // Generic
@@ -273,9 +273,10 @@ void wxWindow::Init()
     //
     // wxWnd
     //
-    m_hMenu         = 0L;
-    m_hWnd          = 0L;
-    m_hWndScrollBar = 0L;
+    m_hMenu             = 0L;
+    m_hWnd              = 0L;
+    m_hWndScrollBarHorz = 0L;
+    m_hWndScrollBarVert = 0L;
 
     //
     // Pass WM_GETDLGCODE to DefWindowProc()
@@ -295,16 +296,26 @@ void wxWindow::Init()
     m_lLastMouseY = -1;
     m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK
-} // wxWindow::Init
+} // wxWindowOS2::Init
 
 //
 // Destructor
 //
-wxWindow::~wxWindow()
+wxWindowOS2::~wxWindowOS2()
 {
     m_isBeingDeleted = TRUE;
 
     OS2DetachWindowMenu();
+    for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
+    {
+        wxFrame*                    pFrame = wxDynamicCast(pWin, wxFrame);
+
+        if (pFrame)
+        {
+            if (pFrame->GetLastFocus() == this)
+                pFrame->SetLastFocus((wxWindow*)NULL);
+        }
+    }
     if (m_parent)
         m_parent->RemoveChild(this);
     DestroyChildren();
@@ -318,9 +329,9 @@ wxWindow::~wxWindow()
         //
         wxRemoveHandleAssociation(this);
     }
-} // end of wxWindow::~wxWindow
+} // end of wxWindowOS2::~wxWindowOS2
 
-bool wxWindow::Create(
+bool wxWindowOS2::Create(
   wxWindow*                         pParent
 , wxWindowID                        vId
 , const wxPoint&                    rPos
@@ -331,6 +342,7 @@ bool wxWindow::Create(
 {
     HWND                            hParent = NULLHANDLE;
     wxPoint                         vPos = rPos; // The OS/2 position
+    ULONG                           ulCreateFlags = 0L;
 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 
@@ -346,12 +358,32 @@ bool wxWindow::Create(
 
     if (pParent)
     {
+        int                         nTempy;
+
         pParent->AddChild(this);
         hParent = GetWinHwnd(pParent);
         //
         // OS2 uses normal coordinates, no bassackwards Windows ones
         //
-        vPos.y = pParent->GetSize().y - (vPos.y + rSize.y);
+        if (pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+            pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+           )
+        {
+            wxWindow*               pGrandParent = NULL;
+
+            pGrandParent = pParent->GetParent();
+            if (pGrandParent)
+                nTempy = pGrandParent->GetSize().y - (vPos.y + rSize.y);
+            else
+                nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
+        }
+        else
+            nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
+        vPos.y = nTempy;
+        if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+             pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+           )
+            ulCreateFlags |= WS_CLIPSIBLINGS;
     }
     else
     {
@@ -362,9 +394,6 @@ bool wxWindow::Create(
         vPos.y = vRect.yTop - (vPos.y + rSize.y);
     }
 
-    ULONG                           ulCreateFlags = 0L;
-
-
     //
     // Most wxSTYLES are really PM Class specific styles and will be
     // set in those class create procs.  PM's basic windows styles are
@@ -373,18 +402,25 @@ bool wxWindow::Create(
     ulCreateFlags |=  WS_VISIBLE;
 
 
-    if ( lStyle & wxCLIP_SIBLINGS )
+    if (lStyle & wxCLIP_SIBLINGS)
         ulCreateFlags |= WS_CLIPSIBLINGS;
 
     if (lStyle & wxCLIP_CHILDREN )
         ulCreateFlags |= WS_CLIPCHILDREN;
 
     //
-    // Empty stuff for now since PM has no custome 3D effects
-    // Doesn't mean someone cannot make some up though
+    //
     //
     bool                            bWant3D;
-    WXDWORD                         dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
+    WXDWORD                         dwExStyle = Determine3DEffects( WS_EX_CLIENTEDGE
+                                                                   ,&bWant3D
+                                                                  );
+
+    //
+    // Add the simple border style as we'll use this to draw borders
+    //
+    if (lStyle & wxSIMPLE_BORDER)
+        dwExStyle |= wxSIMPLE_BORDER;
 
     //
     // Generic OS/2 Windows are created with no owner, no Z Order, no Control data,
@@ -401,22 +437,25 @@ bool wxWindow::Create(
               ,NULLHANDLE
               ,NULLHANDLE
               ,m_windowId
+              ,NULL
+              ,NULL
+              ,dwExStyle
              );
 
     return(TRUE);
-} // end of wxWindow::Create
+} // end of wxWindowOS2::Create
 
 // ---------------------------------------------------------------------------
 // basic operations
 // ---------------------------------------------------------------------------
 
-void wxWindow::SetFocus()
+void wxWindowOS2::SetFocus()
 {
     HWND                            hWnd = GetHwnd();
 
     if (hWnd)
         ::WinSetFocus(HWND_DESKTOP, hWnd);
-} // end of wxWindow::SetFocus
+} // end of wxWindowOS2::SetFocus
 
 wxWindow* wxWindowBase::FindFocus()
 {
@@ -429,7 +468,7 @@ wxWindow* wxWindowBase::FindFocus()
     return NULL;
 } // wxWindowBase::FindFocus
 
-bool wxWindow::Enable(
+bool wxWindowOS2::Enable(
   bool                              bEnable
 )
 {
@@ -451,9 +490,9 @@ bool wxWindow::Enable(
         pNode = pNode->GetNext();
     }
     return(TRUE);
-} // end of wxWindow::Enable
+} // end of wxWindowOS2::Enable
 
-bool wxWindow::Show(
+bool wxWindowOS2::Show(
   bool                              bShow
 )
 {
@@ -469,31 +508,31 @@ bool wxWindow::Show(
         ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
     }
     return(TRUE);
-} // end of wxWindow::Show
+} // end of wxWindowOS2::Show
 
-void wxWindow::Raise()
+void wxWindowOS2::Raise()
 {
     ::WinSetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | SWP_ACTIVATE);
-} // end of wxWindow::Raise
+} // end of wxWindowOS2::Raise
 
-void wxWindow::Lower()
+void wxWindowOS2::Lower()
 {
     ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER | SWP_DEACTIVATE);
-} // end of wxWindow::Lower
+} // end of wxWindowOS2::Lower
 
-void wxWindow::SetTitle(
+void wxWindowOS2::SetTitle(
   const wxString&                   rTitle
 )
 {
     ::WinSetWindowText(GetHwnd(), rTitle.c_str());
-} // end of wxWindow::SetTitle
+} // end of wxWindowOS2::SetTitle
 
-wxString wxWindow::GetTitle() const
+wxString wxWindowOS2::GetTitle() const
 {
     return wxGetWindowText(GetHWND());
-} // end of wxWindow::GetTitle
+} // end of wxWindowOS2::GetTitle
 
-void wxWindow::CaptureMouse()
+void wxWindowOS2::CaptureMouse()
 {
     HWND                            hWnd = GetHwnd();
 
@@ -502,18 +541,24 @@ void wxWindow::CaptureMouse()
         ::WinSetCapture(HWND_DESKTOP, hWnd);
         m_bWinCaptured = TRUE;
     }
-} // end of wxWindow::GetTitle
+} // end of wxWindowOS2::GetTitle
 
-void wxWindow::ReleaseMouse()
+void wxWindowOS2::ReleaseMouse()
 {
     if (m_bWinCaptured)
     {
         ::WinSetCapture(HWND_DESKTOP, NULLHANDLE);
         m_bWinCaptured = FALSE;
     }
-} // end of wxWindow::ReleaseMouse
+} // end of wxWindowOS2::ReleaseMouse
+
+/* static */ wxWindow* wxWindowBase::GetCapture()
+{
+    HWND hwnd = ::WinQueryCapture(HWND_DESKTOP);
+    return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL;
+} // end of wxWindowBase::GetCapture
 
-bool wxWindow::SetFont(
+bool wxWindowOS2::SetFont(
   const wxFont&                     rFont
 )
 {
@@ -535,7 +580,7 @@ bool wxWindow::SetFont(
     return(TRUE);
 }
 
-bool wxWindow::SetCursor(
+bool wxWindowOS2::SetCursor(
   const wxCursor&                   rCursor
 ) // check if base implementation is OK
 {
@@ -566,9 +611,9 @@ bool wxWindow::SetCursor(
         ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
     }
     return TRUE;
-} // end of wxWindow::SetCursor
+} // end of wxWindowOS2::SetCursor
 
-void wxWindow::WarpPointer(
+void wxWindowOS2::WarpPointer(
   int                               nXPos
 , int                               nYPos
 )
@@ -582,10 +627,10 @@ void wxWindow::WarpPointer(
     nY += vRect.yBottom;
 
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
-} // end of wxWindow::WarpPointer
+} // end of wxWindowOS2::WarpPointer
 
 #if WXWIN_COMPATIBILITY
-void wxWindow::OS2DeviceToLogical (float *x, float *y) const
+void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const
 {
 }
 #endif // WXWIN_COMPATIBILITY
@@ -595,28 +640,45 @@ void wxWindow::OS2DeviceToLogical (float *x, float *y) const
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY
-void wxWindow::SetScrollRange(
+void wxWindowOS2::SetScrollRange(
   int                               nOrient
 , int                               nRange
 , bool                              bRefresh
 )
 {
-    ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, nRange));
-} // end of wxWindow::SetScrollRange
+    int                             nRange1 = nRange;
+    int                             nPageSize = GetScrollPage(nOrient);
 
-void wxWindow::SetScrollPage(
+    if (nPpageSize > 1 && nRange > 0)
+    {
+        nRange1 += (nPageSize - 1);
+    }
+
+    if (nOrient == wxHORIZONTAL)
+    {
+        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
+        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+    }
+    else
+    {
+        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
+        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+    }
+} // end of wxWindowOS2::SetScrollRange
+
+void wxWindowOS2::SetScrollPage(
   int                               nOrient
 , int                               nPage
 , bool                              bRefresh
 )
 {
-    if ( orient == wxHORIZONTAL )
-        m_xThumbSize = page;
+    if (nOrient == wxHORIZONTAL )
+        m_nXThumbSize = nPage;
     else
-        m_yThumbSize = page;
-}
+        m_nYThumbSize = nPage;
+} // end of wxWindowOS2::SetScrollPage
 
-int wxWindow::OldGetScrollRange(
+int wxWindowOS2::OldGetScrollRange(
   int                               nOrient
 ) const
 {
@@ -629,9 +691,9 @@ int wxWindow::OldGetScrollRange(
         return(SHORT2FROMMR(mRc));
      }
      return 0;
-} // end of wxWindow::OldGetScrollRange
+} // end of wxWindowOS2::OldGetScrollRange
 
-int  wxWindow::GetScrollPage(
+int  wxWindowOS2::GetScrollPage(
   int                               nOrient
 ) const
 {
@@ -639,48 +701,55 @@ int  wxWindow::GetScrollPage(
         return m_nXThumbSize;
     else
         return m_nYThumbSize;
-} // end of wxWindow::GetScrollPage
+} // end of wxWindowOS2::GetScrollPage
 #endif // WXWIN_COMPATIBILITY
 
-int  wxWindow::GetScrollPos(
+int  wxWindowOS2::GetScrollPos(
   int                               nOrient
 ) const
 {
-    return((int)::WinSendMsg(GetHwnd(), SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
-} // end of wxWindow::GetScrollPos
+    if (nOrient == wxHORIZONTAL)
+        return((int)::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
+    else
+        return((int)::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
+} // end of wxWindowOS2::GetScrollPos
 
-int wxWindow::GetScrollRange(
+int wxWindowOS2::GetScrollRange(
   int                               nOrient
 ) const
 {
     MRESULT                         mr;
 
-    mr = ::WinSendMsg(GetHwnd(), SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
+    if (nOrient == wxHORIZONTAL)
+        mr = ::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
+    else
+        mr = ::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
     return((int)SHORT2FROMMR(mr));
-} // end of wxWindow::GetScrollRange
+} // end of wxWindowOS2::GetScrollRange
 
-int wxWindow::GetScrollThumb(
+int wxWindowOS2::GetScrollThumb(
   int                               nOrient
 ) const
 {
-    WNDPARAMS                       vWndParams;
-    PSBCDATA                        pSbcd;
-
-    ::WinSendMsg(GetHwnd(), WM_QUERYWINDOWPARAMS, (MPARAM)&vWndParams, (MPARAM)NULL);
-    pSbcd = (PSBCDATA)vWndParams.pCtlData;
-    return((int)pSbcd->posThumb);
-} // end of wxWindow::GetScrollThumb
+    if (nOrient == wxHORIZONTAL )
+        return m_nXThumbSize;
+    else
+        return m_nYThumbSize;
+} // end of wxWindowOS2::GetScrollThumb
 
-void wxWindow::SetScrollPos(
+void wxWindowOS2::SetScrollPos(
   int                               nOrient
 , int                               nPos
 , bool                              bRefresh
 )
 {
-    ::WinSendMsg(GetHwnd(), SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
-} // end of wxWindow::SetScrollPos(
+    if (nOrient == wxHORIZONTAL )
+        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
+    else
+        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
+} // end of wxWindowOS2::SetScrollPos(
 
-void wxWindow::SetScrollbar(
+void wxWindowOS2::SetScrollbar(
   int                               nOrient
 , int                               nPos
 , int                               nThumbVisible
@@ -693,7 +762,7 @@ void wxWindow::SetScrollbar(
     int                             nPageSize = nThumbVisible;
     SBCDATA                         vInfo;
     HWND                            hWnd = GetHwnd();
-    ULONG                           ulStyle = WS_VISIBLE;
+    ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     RECTL                           vRect;
 
     ::WinQueryWindowRect(hWnd, &vRect);
@@ -710,83 +779,205 @@ void wxWindow::SetScrollbar(
     if (nOrient == wxHORIZONTAL )
     {
         ulStyle |= SBS_HORZ;
-        if (m_hWndScrollBar == 0L)
+        if (m_hWndScrollBarHorz == 0L)
         {
-            m_hWndScrollBar = ::WinCreateWindow( hWnd
-                                                ,WC_SCROLLBAR
-                                                ,(PSZ)NULL
-                                                ,ulStyle
-                                                ,vRect.xLeft
-                                                ,vRect.yBottom
-                                                ,vRect.xRight - vRect.xLeft
-                                                ,20
-                                                ,hWnd
-                                                ,HWND_TOP
-                                                ,-1
-                                                ,&vInfo
-                                                ,NULL
-                                               );
+            //
+            // We create the scrollbars with the desktop so that they are not
+            // registered as child windows of the window in order that child
+            // windows may be scrolled without scrolling the scrollbars themselves!
+            //
+            m_hWndScrollBarHorz = ::WinCreateWindow( hWnd
+                                                    ,WC_SCROLLBAR
+                                                    ,(PSZ)NULL
+                                                    ,ulStyle
+                                                    ,vRect.xLeft
+                                                    ,vRect.yBottom
+                                                    ,vRect.xRight - vRect.xLeft
+                                                    ,20
+                                                    ,hWnd
+                                                    ,HWND_TOP
+                                                    ,FID_HORZSCROLL
+                                                    ,&vInfo
+                                                    ,NULL
+                                                   );
         }
         else
         {
-            ::WinSendMsg(m_hWndScrollBar, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
+            RECTL                   vRect2;
+
+            //
+            // Only want to resize the scrollbar if it changes, otherwise
+            // we'd probably end up in a recursive loop until we crash the call stack
+            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
+            // generates those events.
+            //
+            ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect2);
+            if (!(vRect2.xLeft == vRect.xLeft     &&
+                  vRect2.xRight == vRect.xRight   &&
+                  vRect2.yBottom == vRect.yBottom &&
+                  vRect2.yTop == vRect.yTop
+                ) )
+            {
+                ::WinSetWindowPos( m_hWndScrollBarHorz
+                                  ,HWND_TOP
+                                  ,vRect.xLeft
+                                  ,vRect.yBottom
+                                  ,vRect.xRight - vRect.xLeft
+                                  ,20
+                                  ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
+                                 );
+            }
+            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
+            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
         }
     }
     else
     {
         ulStyle |= SBS_VERT;
-        if (m_hWndScrollBar == 0L)
+        if (m_hWndScrollBarVert == 0L)
         {
-            m_hWndScrollBar = ::WinCreateWindow( hWnd
-                                                ,WC_SCROLLBAR
-                                                ,(PSZ)NULL
-                                                ,ulStyle
-                                                ,vRect.xRight - 20
-                                                ,vRect.yBottom
-                                                ,20
-                                                ,vRect.yTop - vRect.yBottom
-                                                ,hWnd
-                                                ,HWND_TOP
-                                                ,-1
-                                                ,&vInfo
-                                                ,NULL
-                                               );
+            m_hWndScrollBarVert = ::WinCreateWindow( hWnd
+                                                    ,WC_SCROLLBAR
+                                                    ,(PSZ)NULL
+                                                    ,ulStyle
+                                                    ,vRect.xRight - 20
+                                                    ,vRect.yBottom + 20
+                                                    ,20
+                                                    ,vRect.yTop - (vRect.yBottom + 20)
+                                                    ,hWnd
+                                                    ,HWND_TOP
+                                                    ,FID_VERTSCROLL
+                                                    ,&vInfo
+                                                    ,NULL
+                                                   );
         }
         else
         {
-            ::WinSendMsg(m_hWndScrollBar, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
+            RECTL                   vRect2;
+
+            //
+            // Only want to resize the scrollbar if it changes, otherwise
+            // we'd probably end up in a recursive loop until we crash the call stack
+            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
+            // generates those events.
+            //
+            ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect2);
+            if (!(vRect2.xLeft == vRect.xLeft     &&
+                  vRect2.xRight == vRect.xRight   &&
+                  vRect2.yBottom == vRect.yBottom &&
+                  vRect2.yTop == vRect.yTop
+                ) )
+            {
+                ::WinSetWindowPos( m_hWndScrollBarVert
+                                  ,HWND_TOP
+                                  ,vRect.xRight - 20
+                                  ,vRect.yBottom + 20
+                                  ,20
+                                  ,vRect.yTop - (vRect.yBottom + 20)
+                                  ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
+                                 );
+            }
+            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
+            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
         }
         m_nYThumbSize = nThumbVisible;
     }
-} // end of wxWindow::SetScrollbar
+} // end of wxWindowOS2::SetScrollbar
 
-void wxWindow::ScrollWindow(
+void wxWindowOS2::ScrollWindow(
   int                               nDx
 , int                               nDy
 , const wxRect*                     pRect
 )
 {
+    RECTL                           vRect;
     RECTL                           vRect2;
 
+    nDy *= -1; // flip the sign of Dy as OS/2 is opposite wxWin.
     if (pRect)
     {
         vRect2.xLeft   = pRect->x;
-        vRect2.yTop    = pRect->y;
+        vRect2.yTop    = pRect->y + pRect->height;
         vRect2.xRight  = pRect->x + pRect->width;
-        vRect2.yBottom = pRect->y + pRect->height;
+        vRect2.yBottom = pRect->y;
     }
+    else
+    {
+        ::WinQueryWindowRect(GetHwnd(), &vRect2);
+        ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect);
+        vRect2.yBottom += vRect.yTop - vRect.yBottom;
+        ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect);
+        vRect2.xRight -= vRect.xRight - vRect.xLeft;
 
+    }
     if (pRect)
-        ::WinScrollWindow(GetHwnd(), (LONG)nDx, (LONG)nDy, &vRect2, NULL, NULLHANDLE, NULL, 0L);
+        ::WinScrollWindow( GetHwnd()
+                          ,(LONG)nDx
+                          ,(LONG)nDy
+                          ,&vRect2
+                          ,NULL
+                          ,NULLHANDLE
+                          ,NULL
+                          ,SW_INVALIDATERGN
+                         );
     else
-        ::WinScrollWindow(GetHwnd(), nDx, nDy, NULL, NULL, NULLHANDLE, NULL, 0L);
-} // end of wxWindow::ScrollWindow
+        ::WinScrollWindow( GetHwnd()
+                          ,nDx
+                          ,nDy
+                          ,NULL
+                          ,NULL
+                          ,NULLHANDLE
+                          ,NULL
+                          ,SW_INVALIDATERGN
+                         );
+
+    //
+    // Move the children
+    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
+    SWP                             vSwp;
+
+    while (pCurrent)
+    {
+        wxWindow*                   pChildWin = pCurrent->GetData();
+
+        if (pChildWin->GetHWND() != NULLHANDLE)
+        {
+            ::WinQueryWindowPos(pChildWin->GetHWND(), &vSwp);
+            ::WinQueryWindowRect(pChildWin->GetHWND(), &vRect);
+            if (pChildWin->GetHWND() == m_hWndScrollBarVert ||
+                pChildWin->GetHWND() == m_hWndScrollBarHorz)
+            {
+                ::WinSetWindowPos( pChildWin->GetHWND()
+                                  ,HWND_TOP
+                                  ,vSwp.x + nDx
+                                  ,vSwp.y + nDy
+                                  ,0
+                                  ,0
+                                  ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
+                                 );
+            }
+            else
+            {
+                ::WinSetWindowPos( pChildWin->GetHWND()
+                                  ,HWND_BOTTOM
+                                  ,vSwp.x + nDx
+                                  ,vSwp.y + nDy
+                                  ,0
+                                  ,0
+                                  ,SWP_MOVE | SWP_ZORDER
+                                 );
+                ::WinInvalidateRect(pChildWin->GetHWND(), &vRect, FALSE);
+            }
+        }
+        pCurrent = pCurrent->GetNext();
+    }
+} // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
 // subclassing
 // ---------------------------------------------------------------------------
 
-void wxWindow::SubclassWin(
+void wxWindowOS2::SubclassWin(
   WXHWND                            hWnd
 )
 {
@@ -795,9 +986,9 @@ void wxWindow::SubclassWin(
     wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
     m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
-} // end of wxWindow::SubclassWin
+} // end of wxWindowOS2::SubclassWin
 
-void wxWindow::UnsubclassWin()
+void wxWindowOS2::UnsubclassWin()
 {
     //
     // Restore old Window proc
@@ -816,29 +1007,45 @@ void wxWindow::UnsubclassWin()
             m_fnOldWndProc = 0;
         }
     }
-} // end of wxWindow::UnsubclassWin
+} // end of wxWindowOS2::UnsubclassWin
 
 //
 // Make a Windows extended style from the given wxWindows window style
 //
-WXDWORD wxWindow::MakeExtendedStyle(
+WXDWORD wxWindowOS2::MakeExtendedStyle(
   long                              lStyle
 , bool                              bEliminateBorders
 )
 {
    //
-   // PM does not support extended style
+   // Simply fill out with wxWindow extended styles.  We'll conjure
+   // something up in OS2Create and all window redrawing pieces later
    //
-    WXDWORD                         exStyle = 0;
-    return exStyle;
-} // end of wxWindow::MakeExtendedStyle
+    WXDWORD                         dwStyle = 0;
+
+    if (lStyle & wxTRANSPARENT_WINDOW )
+        dwStyle |= wxTRANSPARENT_WINDOW;
+
+    if (!bEliminateBorders)
+    {
+        if (lStyle & wxSUNKEN_BORDER)
+            dwStyle |= wxSUNKEN_BORDER;
+        if (lStyle & wxDOUBLE_BORDER)
+            dwStyle |= wxDOUBLE_BORDER;
+        if (lStyle & wxRAISED_BORDER )
+            dwStyle |= wxRAISED_BORDER;
+        if (lStyle & wxSTATIC_BORDER)
+            dwStyle |= wxSTATIC_BORDER;
+    }
+    return dwStyle;
+} // end of wxWindowOS2::MakeExtendedStyle
 
 //
-// Determines whether native 3D effects or CTL3D should be used,
+// Determines whether simulated 3D effects or CTL3D should be used,
 // applying a default border style if required, and returning an extended
-// style to pass to CreateWindowEx.
+// style to pass to OS2Create.
 //
-WXDWORD wxWindow::Determine3DEffects(
+WXDWORD wxWindowOS2::Determine3DEffects(
   WXDWORD                           dwDefaultBorderStyle
 , bool*                             pbWant3D
 ) const
@@ -846,14 +1053,70 @@ WXDWORD wxWindow::Determine3DEffects(
     WXDWORD                         dwStyle = 0L;
 
     //
-    // Native PM does not have any specialize 3D effects like WIN32 does
+    // Native PM does not have any specialize 3D effects like WIN32 does,
+    // so we have to try and invent them.
+    //
+
+    //
+    // If matches certain criteria, then assume no 3D effects
+    // unless specifically requested (dealt with in MakeExtendedStyle)
+    //
+    if (!GetParent()                    ||
+        !IsKindOf(CLASSINFO(wxControl)) ||
+        (m_windowStyle & wxNO_BORDER)
+       )
+    {
+        *pbWant3D = FALSE;
+        return MakeExtendedStyle(m_windowStyle, FALSE);
+    }
+
+    //
+    // 1) App can specify global 3D effects
+    //
+    *pbWant3D = wxTheApp->GetAuto3D();
+
+    //
+    // 2) If the parent is being drawn with user colours, or simple border
+    //    specified, switch effects off.
+    //
+    if (GetParent() &&
+        (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) ||
+        (m_windowStyle & wxSIMPLE_BORDER)
+       )
+        *pbWant3D = FALSE;
+
+    //
+    // 3) Control can override this global setting by defining
+    //    a border style, e.g. wxSUNKEN_BORDER
     //
-    *pbWant3D = FALSE;
+    if ((m_windowStyle & wxDOUBLE_BORDER) ||
+        (m_windowStyle & wxRAISED_BORDER) ||
+        (m_windowStyle & wxSTATIC_BORDER) ||
+        (m_windowStyle & wxSUNKEN_BORDER)
+       )
+        *pbWant3D = TRUE;
+
+    dwStyle = MakeExtendedStyle( m_windowStyle
+                                ,FALSE
+                               );
+
+    //
+    // If we want 3D, but haven't specified a border here,
+    // apply the default border style specified.
+    //
+    if (dwDefaultBorderStyle && (*pbWant3D) &&
+        !((m_windowStyle & wxDOUBLE_BORDER) ||
+          (m_windowStyle & wxRAISED_BORDER) ||
+          (m_windowStyle & wxSTATIC_BORDER) ||
+          (m_windowStyle & wxSIMPLE_BORDER)
+         )
+        )
+        dwStyle |= dwDefaultBorderStyle;
     return dwStyle;
-} // end of wxWindow::Determine3DEffects
+} // end of wxWindowOS2::Determine3DEffects
 
 #if WXWIN_COMPATIBILITY
-void wxWindow::OnCommand(
+void wxWindowOS2::OnCommand(
   wxWindow&                         rWin
 , wxCommandEvent&                   rEvent
 )
@@ -864,9 +1127,9 @@ void wxWindow::OnCommand(
         m_parent->GetEventHandler()->OnCommand( rWin
                                                ,rEvent
                                               );
-} // end of wxWindow::OnCommand
+} // end of wxWindowOS2::OnCommand
 
-wxObject* wxWindow::GetChild(
+wxObject* wxWindowOS2::GetChild(
   int                               nNumber
 ) const
 {
@@ -885,20 +1148,20 @@ wxObject* wxWindow::GetChild(
     }
     else
         return NULL;
-} // end of wxWindow::GetChild
+} // end of wxWindowOS2::GetChild
 
 #endif // WXWIN_COMPATIBILITY
 
 //
 // Setup background and foreground colours correctly
 //
-void wxWindow::SetupColours()
+void wxWindowOS2::SetupColours()
 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());
-} // end of wxWindow::SetupColours
+} // end of wxWindowOS2::SetupColours
 
-void wxWindow::OnIdle(
+void wxWindowOS2::OnIdle(
   wxIdleEvent&                      rEvent
 )
 {
@@ -940,12 +1203,12 @@ void wxWindow::OnIdle(
         }
     }
     UpdateWindowUI();
-} // end of wxWindow::OnIdle
+} // end of wxWindowOS2::OnIdle
 
 //
 // Set this window to be the child of 'parent'.
 //
-bool wxWindow::Reparent(
+bool wxWindowOS2::Reparent(
   wxWindow*                         pParent
 )
 {
@@ -957,9 +1220,9 @@ bool wxWindow::Reparent(
 
     ::WinSetParent(hWndChild, hWndParent, TRUE);
     return TRUE;
-} // end of wxWindow::Reparent
+} // end of wxWindowOS2::Reparent
 
-void wxWindow::Clear()
+void wxWindowOS2::Clear()
 {
     wxClientDC                      vDc(this);
     wxBrush                         vBrush( GetBackgroundColour()
@@ -968,9 +1231,9 @@ void wxWindow::Clear()
 
     vDc.SetBackground(vBrush);
     vDc.Clear();
-} // end of wxWindow::Clear
+} // end of wxWindowOS2::Clear
 
-void wxWindow::Refresh(
+void wxWindowOS2::Refresh(
   bool                              bEraseBack
 , const wxRect*                     pRect
 )
@@ -993,14 +1256,14 @@ void wxWindow::Refresh(
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
     }
-} // end of wxWindow::Refresh
+} // end of wxWindowOS2::Refresh
 
 // ---------------------------------------------------------------------------
 // drag and drop
 // ---------------------------------------------------------------------------
 
 #if wxUSE_DRAG_AND_DROP
-void wxWindow::SetDropTarget(
+void wxWindowOS2::SetDropTarget(
   wxDropTarget*                     pDropTarget
 )
 {
@@ -1012,14 +1275,14 @@ void wxWindow::SetDropTarget(
     m_dropTarget = pDropTarget;
     if (m_dropTarget != 0)
         m_dropTarget->Register(m_hWnd);
-} // end of wxWindow::SetDropTarget
+} // end of wxWindowOS2::SetDropTarget
 #endif
 
 //
 // old style file-manager drag&drop support: we retain the old-style
 // DragAcceptFiles in parallel with SetDropTarget.
 //
-void wxWindow::DragAcceptFiles(
+void wxWindowOS2::DragAcceptFiles(
   bool                              bAccept
 )
 {
@@ -1027,7 +1290,7 @@ void wxWindow::DragAcceptFiles(
 
     if (hWnd && bAccept)
         ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);
-} // end of wxWindow::DragAcceptFiles
+} // end of wxWindowOS2::DragAcceptFiles
 
 // ----------------------------------------------------------------------------
 // tooltips
@@ -1035,7 +1298,7 @@ void wxWindow::DragAcceptFiles(
 
 #if wxUSE_TOOLTIPS
 
-void wxWindow::DoSetToolTip(
+void wxWindowOS2::DoSetToolTip(
   wxToolTip*                        pTooltip
 )
 {
@@ -1043,7 +1306,7 @@ void wxWindow::DoSetToolTip(
 
     if (m_tooltip)
         m_tooltip->SetWindow(this);
-} // end of wxWindow::DoSetToolTip
+} // end of wxWindowOS2::DoSetToolTip
 
 #endif // wxUSE_TOOLTIPS
 
@@ -1052,7 +1315,7 @@ void wxWindow::DoSetToolTip(
 // ---------------------------------------------------------------------------
 
 // Get total size
-void wxWindow::DoGetSize(
+void wxWindowOS2::DoGetSize(
   int*                              pWidth
 , int*                              pHeight
 ) const
@@ -1067,9 +1330,9 @@ void wxWindow::DoGetSize(
     if (pHeight )
         // OS/2 PM is backwards from windows
         *pHeight = vRect.yTop - vRect.yBottom;
-} // end of wxWindow::DoGetSize
+} // end of wxWindowOS2::DoGetSize
 
-void wxWindow::DoGetPosition(
+void wxWindowOS2::DoGetPosition(
   int*                              pX
 , int*                              pY
 ) const
@@ -1122,9 +1385,9 @@ void wxWindow::DoGetPosition(
         *pX = vPoint.x;
     if  (pY)
         *pY = vPoint.y;
-} // end of wxWindow::DoGetPosition
+} // end of wxWindowOS2::DoGetPosition
 
-void wxWindow::DoScreenToClient(
+void wxWindowOS2::DoScreenToClient(
   int*                              pX
 , int*                              pY
 ) const
@@ -1138,9 +1401,9 @@ void wxWindow::DoScreenToClient(
         *pX -= vSwp.x;
     if (pY)
         *pY -= vSwp.y;
-} // end of wxWindow::DoScreenToClient
+} // end of wxWindowOS2::DoScreenToClient
 
-void wxWindow::DoClientToScreen(
+void wxWindowOS2::DoClientToScreen(
   int*                              pX
 , int*                              pY
 ) const
@@ -1154,13 +1417,13 @@ void wxWindow::DoClientToScreen(
         *pX += vSwp.x;
     if (pY)
         *pY += vSwp.y;
-} // end of wxWindow::DoClientToScreen
+} // end of wxWindowOS2::DoClientToScreen
 
 //
 // Get size *available for subwindows* i.e. excluding menu bar etc.
 // Must be a frame type window
 //
-void wxWindow::DoGetClientSize(
+void wxWindowOS2::DoGetClientSize(
   int*                              pWidth
 , int*                              pHeight
 ) const
@@ -1169,7 +1432,10 @@ void wxWindow::DoGetClientSize(
     HWND                            hWndClient;
     RECTL                           vRect;
 
-    hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
+    if (IsKindOf(CLASSINFO(wxFrame)))
+        hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
+    else
+        hWndClient = NULLHANDLE;
     if( hWndClient == NULLHANDLE)
        ::WinQueryWindowRect(GetHwnd(), &vRect);
     else
@@ -1179,15 +1445,27 @@ void wxWindow::DoGetClientSize(
         *pWidth  = vRect.xRight;
     if (pHeight)
         *pHeight = vRect.yTop;
-} // end of wxWindow::DoGetClientSize
+} // end of wxWindowOS2::DoGetClientSize
 
-void wxWindow::DoMoveWindow(
+void wxWindowOS2::DoMoveWindow(
   int                               nX
 , int                               nY
 , int                               nWidth
 , int                               nHeight
 )
 {
+#if 0 // x and y coords should already be in os2 coordinates
+    RECTL                           vRect;
+    HWND                            hParent;
+    wxWindow*                       pParent = GetParent();
+
+    if (pParent)
+        hParent = GetWinHwnd(pParent);
+    else
+        hParent = HWND_DESKTOP;
+    ::WinQueryWindowRect(hParent, &vRect);
+    nY = vRect.yTop - (nY + nHeight);
+#endif
     if ( !::WinSetWindowPos( GetHwnd()
                             ,HWND_TOP
                             ,(LONG)nX
@@ -1199,7 +1477,7 @@ void wxWindow::DoMoveWindow(
     {
         wxLogLastError("MoveWindow");
     }
-} // end of wxWindow::DoMoveWindow
+} // end of wxWindowOS2::DoMoveWindow
 
 //
 // Set the size of the window: if the dimensions are positive, just use them,
@@ -1211,7 +1489,7 @@ void wxWindow::DoMoveWindow(
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height
 //
-void wxWindow::DoSetSize(
+void wxWindowOS2::DoSetSize(
   int                               nX
 , int                               nY
 , int                               nWidth
@@ -1295,9 +1573,9 @@ void wxWindow::DoSetSize(
                  ,nWidth
                  ,nHeight
                 );
-} // end of wxWindow::DoSetSize
+} // end of wxWindowOS2::DoSetSize
 
-void wxWindow::DoSetClientSize(
+void wxWindowOS2::DoSetClientSize(
   int                               nWidth
 , int                               nHeight
 )
@@ -1354,41 +1632,18 @@ void wxWindow::DoSetClientSize(
 
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::DoSetClientSize
+} // end of wxWindowOS2::DoSetClientSize
 
-wxPoint wxWindow::GetClientAreaOrigin() const
+wxPoint wxWindowOS2::GetClientAreaOrigin() const
 {
     return wxPoint(0, 0);
-} // end of wxWindow::GetClientAreaOrigin
-
-void wxWindow::AdjustForParentClientOrigin(
-  int&                              rX
-, int&                              rY
-, int                               nSizeFlags
-)
-{
-    //
-    // Don't do it for the dialogs/frames - they float independently of their
-    // parent
-    //
-    if (!IsTopLevel())
-    {
-        wxWindow*                   pParent = GetParent();
-
-        if (!(nSizeFlags & wxSIZE_NO_ADJUSTMENTS) && pParent)
-        {
-            wxPoint                 vPoint(pParent->GetClientAreaOrigin());
-            rX += vPoint.x;
-            rY += vPoint.y;
-        }
-    }
-} // end of wxWindow::AdjustForParentClientOrigin
+} // end of wxWindowOS2::GetClientAreaOrigin
 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 
-int wxWindow::GetCharHeight() const
+int wxWindowOS2::GetCharHeight() const
 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;
@@ -1403,9 +1658,9 @@ int wxWindow::GetCharHeight() const
     }
     ::WinReleasePS(hPs);
     return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
-} // end of wxWindow::GetCharHeight
+} // end of wxWindowOS2::GetCharHeight
 
-int wxWindow::GetCharWidth() const
+int wxWindowOS2::GetCharWidth() const
 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;
@@ -1419,9 +1674,9 @@ int wxWindow::GetCharWidth() const
     }
     ::WinReleasePS(hPs);
     return(vFontMetrics.lAveCharWidth);
-} // end of wxWindow::GetCharWidth
+} // end of wxWindowOS2::GetCharWidth
 
-void wxWindow::GetTextExtent(
+void wxWindowOS2::GetTextExtent(
   const wxString&                   rString
 , int*                              pX
 , int*                              pY
@@ -1478,7 +1733,7 @@ void wxWindow::GetTextExtent(
 // Caret manipulation
 // ---------------------------------------------------------------------------
 
-void wxWindow::CreateCaret(
+void wxWindowOS2::CreateCaret(
   int                               nWidth
 , int                               nHeight
 )
@@ -1487,30 +1742,30 @@ void wxWindow::CreateCaret(
                          ,nWidth
                          ,nHeight
                         ));
-} // end of wxWindow::CreateCaret
+} // end of wxWindowOS2::CreateCaret
 
-void wxWindow::CreateCaret(
+void wxWindowOS2::CreateCaret(
   const wxBitmap*                   pBitmap
 )
 {
     wxFAIL_MSG("not implemented");
-} // end of wxWindow::CreateCaret
+} // end of wxWindowOS2::CreateCaret
 
-void wxWindow::ShowCaret(
+void wxWindowOS2::ShowCaret(
   bool                              bShow
 )
 {
     wxCHECK_RET( m_caret, "no caret to show" );
 
     m_caret->Show(bShow);
-} // end of wxWindow::ShowCaret
+} // end of wxWindowOS2::ShowCaret
 
-void wxWindow::DestroyCaret()
+void wxWindowOS2::DestroyCaret()
 {
     SetCaret(NULL);
-} // end of wxWindow::DestroyCaret
+} // end of wxWindowOS2::DestroyCaret
 
-void wxWindow::SetCaretPos(
+void wxWindowOS2::SetCaretPos(
   int                               nX
 , int                               nY)
 {
@@ -1519,9 +1774,9 @@ void wxWindow::SetCaretPos(
     m_caret->Move( nX
                   ,nY
                  );
-} // end of wxWindow::SetCaretPos
+} // end of wxWindowOS2::SetCaretPos
 
-void wxWindow::GetCaretPos(
+void wxWindowOS2::GetCaretPos(
   int*                              pX
 , int*                              pY
 ) const
@@ -1531,7 +1786,7 @@ void wxWindow::GetCaretPos(
     m_caret->GetPosition( pX
                          ,pY
                         );
-} // end of wxWindow::GetCaretPos
+} // end of wxWindowOS2::GetCaretPos
 
 #endif //wxUSE_CARET
 
@@ -1539,7 +1794,27 @@ void wxWindow::GetCaretPos(
 // popup menu
 // ---------------------------------------------------------------------------
 
-bool wxWindow::DoPopupMenu(
+static void wxYieldForCommandsOnly()
+{
+    //
+    // Peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
+    // want to process it here)
+    //
+    QMSG                            vMsg;
+
+    while (::WinPeekMsg( vHabmain
+                        ,&vMsg
+                        ,(HWND)0
+                        ,WM_COMMAND
+                        ,WM_COMMAND
+                        ,PM_REMOVE
+                       ) && vMsg.msg != WM_QUIT)
+    {
+        wxTheApp->DoMessage((WXMSG*)&vMsg);
+    }
+}
+
+bool wxWindowOS2::DoPopupMenu(
   wxMenu*                           pMenu
 , int                               nX
 , int                               nY
@@ -1565,18 +1840,25 @@ bool wxWindow::DoPopupMenu(
                    ,0L
                    ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD
                   );
-    wxYield();
+    // we need to do it righ now as otherwise the events are never going to be
+    // sent to wxCurrentPopupMenu from HandleCommand()
+    //
+    // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
+    // help and we'd still need wxYieldForCommandsOnly() as the menu may be
+    // destroyed as soon as we return (it can be a local variable in the caller
+    // for example) and so we do need to process the event immediately
+    wxYieldForCommandsOnly();
     wxCurrentPopupMenu = NULL;
 
     pMenu->SetInvokingWindow(NULL);
     return TRUE;
-} // end of wxWindow::DoPopupMenu
+} // end of wxWindowOS2::DoPopupMenu
 
 // ===========================================================================
 // pre/post message processing
 // ===========================================================================
 
-MRESULT wxWindow::OS2DefWindowProc(
+MRESULT wxWindowOS2::OS2DefWindowProc(
   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam
@@ -1586,9 +1868,9 @@ MRESULT wxWindow::OS2DefWindowProc(
         return (MRESULT)m_fnOldWndProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
     else
         return ::WinDefWindowProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
-} // end of wxWindow::OS2DefWindowProc
+} // end of wxWindowOS2::OS2DefWindowProc
 
-bool wxWindow::OS2ProcessMessage(
+bool wxWindowOS2::OS2ProcessMessage(
   WXMSG*                            pMsg
 )
 {
@@ -1701,17 +1983,9 @@ bool wxWindow::OS2ProcessMessage(
                         }
                         else
                         {
-                            wxPanel*    pPanel = wxDynamicCast(this, wxPanel);
-                            wxButton*   pBtn = NULL;
-
-                            if (pPanel)
-                            {
-                                //
-                                // Panel may have a default button which should
-                                // be activated by Enter
-                                //
-                                pBtn = pPanel->GetDefaultItem();
-                            }
+                            wxButton*   pBtn = wxDynamicCast( GetDefaultItem()
+                                                             ,wxButton
+                                                            );
 
                             if (pBtn && pBtn->IsEnabled())
                             {
@@ -1774,9 +2048,9 @@ bool wxWindow::OS2ProcessMessage(
 #endif // wxUSE_TOOLTIPS
 
     return FALSE;
-} // end of wxWindow::OS2ProcessMessage
+} // end of wxWindowOS2::OS2ProcessMessage
 
-bool wxWindow::OS2TranslateMessage(
+bool wxWindowOS2::OS2TranslateMessage(
   WXMSG*                            pMsg
 )
 {
@@ -1785,13 +2059,13 @@ bool wxWindow::OS2TranslateMessage(
 #else
   return FALSE;
 #endif //wxUSE_ACCEL
-} // end of wxWindow::OS2TranslateMessage
+} // end of wxWindowOS2::OS2TranslateMessage
 
 // ---------------------------------------------------------------------------
 // message params unpackers
 // ---------------------------------------------------------------------------
 
-void wxWindow::UnpackCommand(
+void wxWindowOS2::UnpackCommand(
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WORD*                             pId
@@ -1802,9 +2076,9 @@ void wxWindow::UnpackCommand(
     *pId = LOWORD(wParam);
     *phWnd = NULL;  // or may be GetHWND() ?
     *pCmd = LOWORD(lParam);
-} // end of wxWindow::UnpackCommand
+} // end of wxWindowOS2::UnpackCommand
 
-void wxWindow::UnpackActivate(
+void wxWindowOS2::UnpackActivate(
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pState
@@ -1813,9 +2087,9 @@ void wxWindow::UnpackActivate(
 {
     *pState     = LOWORD(wParam);
     *phWnd      = (WXHWND)lParam;
-} // end of wxWindow::UnpackActivate
+} // end of wxWindowOS2::UnpackActivate
 
-void wxWindow::UnpackScroll(
+void wxWindowOS2::UnpackScroll(
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pCode
@@ -1823,12 +2097,21 @@ void wxWindow::UnpackScroll(
 , WXHWND*                           phWnd
 )
 {
-    *pCode = LOWORD(wParam);
-    *pPos  = HIWORD(wParam);
-    *phWnd = (WXHWND)lParam;
-} // end of wxWindow::UnpackScroll
+    ULONG                           ulId;
+    HWND                            hWnd;
 
-void wxWindow::UnpackMenuSelect(
+    ulId    = (ULONG)LONGFROMMP(wParam);
+    hWnd = ::WinWindowFromID(GetHwnd(), ulId);
+    if (hWnd == m_hWndScrollBarHorz || hWnd == m_hWndScrollBarVert)
+        *phWnd = NULLHANDLE;
+    else
+        *phWnd = hWnd;
+
+    *pPos  = SHORT1FROMMP(lParam);
+    *pCode = SHORT2FROMMP(lParam);
+} // end of wxWindowOS2::UnpackScroll
+
+void wxWindowOS2::UnpackMenuSelect(
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pItem
@@ -1839,7 +2122,7 @@ void wxWindow::UnpackMenuSelect(
     *pItem = (WXWORD)LOWORD(wParam);
     *pFlags = HIWORD(wParam);
     *phMenu = (WXHMENU)lParam;
-} // end of wxWindow::UnpackMenuSelect
+} // end of wxWindowOS2::UnpackMenuSelect
 
 // ---------------------------------------------------------------------------
 // Main wxWindows window proc and the window proc for wxWindow
@@ -1910,7 +2193,7 @@ MRESULT EXPENTRY wxWndProc(
 // We will add (or delete) messages we need to handle at this default
 // level as we go
 //
-MRESULT wxWindow::OS2WindowProc(
+MRESULT wxWindowOS2::OS2WindowProc(
   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam
@@ -2272,7 +2555,7 @@ MRESULT wxWindow::OS2WindowProc(
             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
     }
     return mResult;
-} // end of wxWindow::OS2WindowProc
+} // end of wxWindowOS2::OS2WindowProc
 
 //
 // Dialog window proc
@@ -2354,11 +2637,11 @@ void wxRemoveHandleAssociation(
 // Default destroyer - override if you destroy it in some other way
 // (e.g. with MDI child windows)
 //
-void wxWindow::OS2DestroyWindow()
+void wxWindowOS2::OS2DestroyWindow()
 {
 }
 
-void wxWindow::OS2DetachWindowMenu()
+void wxWindowOS2::OS2DetachWindowMenu()
 {
     if (m_hMenu)
     {
@@ -2388,9 +2671,9 @@ void wxWindow::OS2DetachWindowMenu()
             }
         }
     }
-} // end of wxWindow::OS2DetachWindowMenu
+} // end of wxWindowOS2::OS2DetachWindowMenu
 
-bool wxWindow::OS2Create(
+bool wxWindowOS2::OS2Create(
   WXHWND                            hParent
 , PSZ                               zClass
 , const wxChar*                     zTitle
@@ -2404,6 +2687,7 @@ bool wxWindow::OS2Create(
 , unsigned long                     ulId
 , void*                             pCtlData
 , void*                             pPresParams
+, WXDWORD                           dwExStyle
 )
 {
     ERRORID                         vError;
@@ -2423,10 +2707,8 @@ bool wxWindow::OS2Create(
     RECTL                           vParentRect;
     HWND                            hWndClient;
 
-    if (lX > -1L)
-        lX1 = lX;
-    if (lY > -1L)
-        lY1 = lY;
+    lX1 = lX;
+    lY1 = lY;
     if (lWidth > -1L)
         lWidth1 = lWidth;
     if (lHeight > -1L)
@@ -2494,6 +2776,7 @@ bool wxWindow::OS2Create(
         wxLogError("Can't create window of class %s!. Error: %s\n", zClass, sError);
         return FALSE;
     }
+    m_dwExStyle = dwExStyle;
     ::WinSetWindowULong(m_hWnd, QWL_USER, (ULONG) this);
     wxWndHook = NULL;
 
@@ -2526,7 +2809,7 @@ bool wxWindow::OS2Create(
         SubclassWin(GetHWND());
     }
     return TRUE;
-} // end of wxWindow::OS2Create
+} // end of wxWindowOS2::OS2Create
 
 // ===========================================================================
 // OS2 PM message handlers
@@ -2536,7 +2819,7 @@ bool wxWindow::OS2Create(
 // window creation/destruction
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleCreate(
+bool wxWindowOS2::HandleCreate(
   WXLPCREATESTRUCT                  vCs
 , bool*                             pbMayCreate
 )
@@ -2546,9 +2829,9 @@ bool wxWindow::HandleCreate(
     (void)GetEventHandler()->ProcessEvent(vEvent);
     *pbMayCreate = TRUE;
     return TRUE;
-} // end of wxWindow::HandleCreate
+} // end of wxWindowOS2::HandleCreate
 
-bool wxWindow::HandleDestroy()
+bool wxWindowOS2::HandleDestroy()
 {
     wxWindowDestroyEvent            vEvent(this);
 
@@ -2570,45 +2853,19 @@ bool wxWindow::HandleDestroy()
     // WM_DESTROY handled
     //
     return TRUE;
-} // end of wxWindow::HandleDestroy
+} // end of wxWindowOS2::HandleDestroy
 
 // ---------------------------------------------------------------------------
 // activation/focus
 // ---------------------------------------------------------------------------
-void wxWindow::OnSetFocus(
+void wxWindowOS2::OnSetFocus(
   wxFocusEvent&                     rEvent
 )
 {
-    //
-    // Panel wants to track the window which was the last to have focus in it,
-    // so we want to set ourselves as the window which last had focus
-    //
-    // Notice that it's also important to do it upwards the tree becaus
-    // otherwise when the top level panel gets focus, it won't set it back to
-    // us, but to some other sibling
-    //
-    wxWindow*                       pWin = this;
-
-    while (pWin)
-    {
-        wxWindow*                   pParent = pWin->GetParent();
-        wxPanel*                    pPanel = wxDynamicCast( pParent
-                                                           ,wxPanel
-                                                          );
-        if (pPanel)
-        {
-            pPanel->SetLastFocus(pWin);
-        }
-        pWin = pParent;
-    }
-
-    wxLogTrace(_T("focus"), _T("%s (0x%08x) gets focus"),
-               GetClassInfo()->GetClassName(), GetHandle());
-
     rEvent.Skip();
-} // end of wxWindow::OnSetFocus
+} // end of wxWindowOS2::OnSetFocus
 
-bool wxWindow::HandleActivate(
+bool wxWindowOS2::HandleActivate(
   int                               nState
 , WXHWND                            WXUNUSED(hActivate)
 )
@@ -2619,9 +2876,9 @@ bool wxWindow::HandleActivate(
                                           );
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleActivate
+} // end of wxWindowOS2::HandleActivate
 
-bool wxWindow::HandleSetFocus(
+bool wxWindowOS2::HandleSetFocus(
   WXHWND                            WXUNUSED(hWnd)
 )
 {
@@ -2635,24 +2892,22 @@ bool wxWindow::HandleSetFocus(
     }
 #endif // wxUSE_CARET
 
-    //
-    // Panel wants to track the window which was the last to have focus in it
-    //
-    wxPanel*                        pPanel = wxDynamicCast( GetParent()
-                                                           ,wxPanel
-                                                          );
-    if (pPanel)
+#if wxUSE_TEXTCTRL
+    // If it's a wxTextCtrl don't send the event as it will be done
+    // after the control gets to process it from EN_FOCUS handler
+    if ( wxDynamicCastThis(wxTextCtrl) )
     {
-        pPanel->SetLastFocus(this);
+        return FALSE;
     }
+#endif // wxUSE_TEXTCTRL
 
     wxFocusEvent                    vEvent(wxEVT_SET_FOCUS, m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleSetFocus
+} // end of wxWindowOS2::HandleSetFocus
 
-bool wxWindow::HandleKillFocus(
+bool wxWindowOS2::HandleKillFocus(
   WXHWND                            WXUNUSED(hWnd)
 )
 {
@@ -2672,13 +2927,13 @@ bool wxWindow::HandleKillFocus(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleKillFocus
+} // end of wxWindowOS2::HandleKillFocus
 
 // ---------------------------------------------------------------------------
 // miscellaneous
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleShow(
+bool wxWindowOS2::HandleShow(
   bool                              bShow
 , int                               nStatus
 )
@@ -2689,9 +2944,9 @@ bool wxWindow::HandleShow(
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleShow
+} // end of wxWindowOS2::HandleShow
 
-bool wxWindow::HandleInitDialog(
+bool wxWindowOS2::HandleInitDialog(
   WXHWND                            WXUNUSED(hWndFocus)
 )
 {
@@ -2699,15 +2954,15 @@ bool wxWindow::HandleInitDialog(
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleInitDialog
+} // end of wxWindowOS2::HandleInitDialog
 
-bool wxWindow::HandleEndDrag(WXWPARAM wParam)
+bool wxWindowOS2::HandleEndDrag(WXWPARAM wParam)
 {
    // TODO: We'll handle drag and drop later
     return FALSE;
 }
 
-bool wxWindow::HandleSetCursor(
+bool wxWindowOS2::HandleSetCursor(
   USHORT                            vId
 , WXHWND                            hPointer
 )
@@ -2718,12 +2973,12 @@ bool wxWindow::HandleSetCursor(
     //
     ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer);
     return TRUE;
-} // end of wxWindow::HandleSetCursor
+} // end of wxWindowOS2::HandleSetCursor
 
 // ---------------------------------------------------------------------------
 // owner drawn stuff
 // ---------------------------------------------------------------------------
-bool wxWindow::OS2OnDrawItem(
+bool wxWindowOS2::OS2OnDrawItem(
   int                               vId
 , WXDRAWITEMSTRUCT*                 pItemStruct
 )
@@ -2874,9 +3129,9 @@ bool wxWindow::OS2OnDrawItem(
     }
 #endif
     return FALSE;
-} // end of wxWindow::OS2OnDrawItem
+} // end of wxWindowOS2::OS2OnDrawItem
 
-bool wxWindow::OS2OnMeasureItem(
+bool wxWindowOS2::OS2OnMeasureItem(
   int                               lId
 , WXMEASUREITEMSTRUCT*              pItemStruct
 )
@@ -2923,15 +3178,15 @@ bool wxWindow::OS2OnMeasureItem(
 // colours and palettes
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleSysColorChange()
+bool wxWindowOS2::HandleSysColorChange()
 {
     wxSysColourChangedEvent         vEvent;
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleSysColorChange
+} // end of wxWindowOS2::HandleSysColorChange
 
-bool wxWindow::HandleCtlColor(
+bool wxWindowOS2::HandleCtlColor(
   WXHBRUSH*                         phBrush
 )
 {
@@ -2939,9 +3194,9 @@ bool wxWindow::HandleCtlColor(
     // Not much provided with message. So not sure I can do anything with it
     //
     return TRUE;
-} // end of wxWindow::HandleCtlColor
+} // end of wxWindowOS2::HandleCtlColor
 
-bool wxWindow::HandleWindowParams(
+bool wxWindowOS2::HandleWindowParams(
   PWNDPARAMS                        pWndParams
 , WXLPARAM                          lParam
 )
@@ -2951,7 +3206,7 @@ bool wxWindow::HandleWindowParams(
 }
 
 // Define for each class of dialog and control
-WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC,
+WXHBRUSH wxWindowOS2::OnCtlColor(WXHDC hDC,
                               WXHWND hWnd,
                               WXUINT nCtlColor,
                               WXUINT message,
@@ -2961,7 +3216,7 @@ WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC,
     return (WXHBRUSH)0;
 }
 
-bool wxWindow::HandlePaletteChanged()
+bool wxWindowOS2::HandlePaletteChanged()
 {
     // need to set this to something first
     WXHWND                          hWndPalChange = NULLHANDLE;
@@ -2972,9 +3227,9 @@ bool wxWindow::HandlePaletteChanged()
     vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
 
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandlePaletteChanged
+} // end of wxWindowOS2::HandlePaletteChanged
 
-bool wxWindow::HandlePresParamChanged(
+bool wxWindowOS2::HandlePresParamChanged(
   WXWPARAM                          wParam
 )
 {
@@ -2992,7 +3247,7 @@ bool wxWindow::HandlePresParamChanged(
 //
 // Responds to colour changes: passes event on to children.
 //
-void wxWindow::OnSysColourChanged(
+void wxWindowOS2::OnSysColourChanged(
   wxSysColourChangedEvent&          rEvent
 )
 {
@@ -3014,13 +3269,13 @@ void wxWindow::OnSysColourChanged(
         }
         pNode = pNode->Next();
     }
-} // end of wxWindow::OnSysColourChanged
+} // end of wxWindowOS2::OnSysColourChanged
 
 // ---------------------------------------------------------------------------
 // painting
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandlePaint()
+bool wxWindowOS2::HandlePaint()
 {
     HRGN                            hRgn = NULLHANDLE;
     wxPaintEvent                    vEvent;
@@ -3061,13 +3316,37 @@ bool wxWindow::HandlePaint()
                                     );
 
             ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
+
+            if (m_dwExStyle)
+            {
+                LINEBUNDLE                      vLineBundle;
+
+                vLineBundle.lColor     = 0x00000000; // Black
+                vLineBundle.usMixMode  = FM_OVERPAINT;
+                vLineBundle.fxWidth    = 1;
+                vLineBundle.lGeomWidth = 1;
+                vLineBundle.usType     = LINETYPE_SOLID;
+                vLineBundle.usEnd      = 0;
+                vLineBundle.usJoin     = 0;
+                ::GpiSetAttrs( hPS
+                              ,PRIM_LINE
+                              ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
+                              ,0L
+                              ,&vLineBundle
+                             );
+                ::WinQueryWindowRect(GetHwnd(), &vRect);
+                wxDrawBorder( hPS
+                             ,vRect
+                             ,m_dwExStyle
+                            );
+            }
             ::WinEndPaint(hPS);
         }
     }
     return (GetEventHandler()->ProcessEvent(vEvent));
-} // end of wxWindow::HandlePaint
+} // end of wxWindowOS2::HandlePaint
 
-bool wxWindow::HandleEraseBkgnd(
+bool wxWindowOS2::HandleEraseBkgnd(
   WXHDC                             hDC
 )
 {
@@ -3092,9 +3371,9 @@ bool wxWindow::HandleEraseBkgnd(
     vDC.EndDrawing();
     vDC.m_hPS = NULLHANDLE;
     return TRUE;
-} // end of wxWindow::HandleEraseBkgnd
+} // end of wxWindowOS2::HandleEraseBkgnd
 
-void wxWindow::OnEraseBackground(
+void wxWindowOS2::OnEraseBackground(
   wxEraseEvent&                     rEvent
 )
 {
@@ -3103,29 +3382,29 @@ void wxWindow::OnEraseBackground(
 
     ::WinQueryWindowRect(GetHwnd(), &vRect);
     ::WinFillRect(hPS, &vRect,  m_backgroundColour.GetPixel());
-}  // end of wxWindow::OnEraseBackground
+}  // end of wxWindowOS2::OnEraseBackground
 
 // ---------------------------------------------------------------------------
 // moving and resizing
 // ---------------------------------------------------------------------------
 
-bool wxWindow::HandleMinimize()
+bool wxWindowOS2::HandleMinimize()
 {
     wxIconizeEvent                  vEvent(m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleMinimize
+} // end of wxWindowOS2::HandleMinimize
 
-bool wxWindow::HandleMaximize()
+bool wxWindowOS2::HandleMaximize()
 {
     wxMaximizeEvent                 vEvent(m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleMaximize
+} // end of wxWindowOS2::HandleMaximize
 
-bool wxWindow::HandleMove(
+bool wxWindowOS2::HandleMove(
   int                               nX
 , int                               nY
 )
@@ -3138,9 +3417,9 @@ bool wxWindow::HandleMove(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-}  // end of wxWindow::HandleMove
+}  // end of wxWindowOS2::HandleMove
 
-bool wxWindow::HandleSize(
+bool wxWindowOS2::HandleSize(
   int                               nWidth
 , int                               nHeight
 , WXUINT                            WXUNUSED(nFlag)
@@ -3154,9 +3433,9 @@ bool wxWindow::HandleSize(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleSize
+} // end of wxWindowOS2::HandleSize
 
-bool wxWindow::HandleGetMinMaxInfo(
+bool wxWindowOS2::HandleGetMinMaxInfo(
   PSWP                              pSwp
 )
 {
@@ -3181,12 +3460,12 @@ bool wxWindow::HandleGetMinMaxInfo(
             return FALSE;
     }
     return TRUE;
-} // end of wxWindow::HandleGetMinMaxInfo
+} // end of wxWindowOS2::HandleGetMinMaxInfo
 
 // ---------------------------------------------------------------------------
 // command messages
 // ---------------------------------------------------------------------------
-bool wxWindow::HandleCommand(
+bool wxWindowOS2::HandleCommand(
   WXWORD                            wId
 , WXWORD                            wCmd
 , WXHWND                            hControl
@@ -3212,9 +3491,9 @@ bool wxWindow::HandleCommand(
                                 ,wId
                                );
     return FALSE;
-} // end of wxWindow::HandleCommand
+} // end of wxWindowOS2::HandleCommand
 
-bool wxWindow::HandleSysCommand(
+bool wxWindowOS2::HandleSysCommand(
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 )
@@ -3231,13 +3510,13 @@ bool wxWindow::HandleSysCommand(
             return HandleMinimize();
     }
     return FALSE;
-} // end of wxWindow::HandleSysCommand
+} // end of wxWindowOS2::HandleSysCommand
 
 // ---------------------------------------------------------------------------
 // mouse events
 // ---------------------------------------------------------------------------
 
-void wxWindow::InitMouseEvent(
+void wxWindowOS2::InitMouseEvent(
   wxMouseEvent&                     rEvent
 , int                               nX
 , int                               nY
@@ -3259,9 +3538,9 @@ void wxWindow::InitMouseEvent(
     m_lastMouseY = nY;
     m_lastMouseEvent = rEvent.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK
-} // end of wxWindow::InitMouseEvent
+} // end of wxWindowOS2::InitMouseEvent
 
-bool wxWindow::HandleMouseEvent(
+bool wxWindowOS2::HandleMouseEvent(
   WXUINT                            uMsg
 , int                               nX
 , int                               nY
@@ -3297,9 +3576,9 @@ bool wxWindow::HandleMouseEvent(
                   );
 
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::HandleMouseEvent
+} // end of wxWindowOS2::HandleMouseEvent
 
-bool wxWindow::HandleMouseMove(
+bool wxWindowOS2::HandleMouseMove(
   int                               nX
 , int                               nY
 , WXUINT                            uFlags
@@ -3327,7 +3606,7 @@ bool wxWindow::HandleMouseMove(
                             ,nY
                             ,uFlags
                            );
-} // end of wxWindow::HandleMouseMove
+} // end of wxWindowOS2::HandleMouseMove
 
 // ---------------------------------------------------------------------------
 // keyboard handling
@@ -3337,7 +3616,7 @@ bool wxWindow::HandleMouseMove(
 // Create the key event of the given type for the given key - used by
 // HandleChar and HandleKeyDown/Up
 //
-wxKeyEvent wxWindow::CreateKeyEvent(
+wxKeyEvent wxWindowOS2::CreateKeyEvent(
   wxEventType                       eType
 , int                               nId
 , WXLPARAM                          lParam
@@ -3372,13 +3651,13 @@ wxKeyEvent wxWindow::CreateKeyEvent(
     vEvent.m_y = vPoint.y;
 
     return vEvent;
-} // end of wxWindow::CreateKeyEvent
+} // end of wxWindowOS2::CreateKeyEvent
 
 //
 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
 // WM_KEYDOWN one
 //
-bool wxWindow::HandleChar(
+bool wxWindowOS2::HandleChar(
   WXWORD                            wParam
 , WXLPARAM                          lParam
 , bool                              isASCII
@@ -3442,7 +3721,7 @@ bool wxWindow::HandleChar(
     return FALSE;
 }
 
-bool wxWindow::HandleKeyDown(
+bool wxWindowOS2::HandleKeyDown(
   WXWORD                            wParam
 , WXLPARAM                          lParam
 )
@@ -3470,9 +3749,9 @@ bool wxWindow::HandleKeyDown(
         }
     }
     return FALSE;
-} // end of wxWindow::HandleKeyDown
+} // end of wxWindowOS2::HandleKeyDown
 
-bool wxWindow::HandleKeyUp(
+bool wxWindowOS2::HandleKeyUp(
   WXWORD                            wParam
 , WXLPARAM                          lParam
 )
@@ -3498,7 +3777,7 @@ bool wxWindow::HandleKeyUp(
             return TRUE;
     }
     return FALSE;
-} // end of wxWindow::HandleKeyUp
+} // end of wxWindowOS2::HandleKeyUp
 
 // ---------------------------------------------------------------------------
 // joystick
@@ -3508,7 +3787,7 @@ bool wxWindow::HandleKeyUp(
 // scrolling
 // ---------------------------------------------------------------------------
 
-bool wxWindow::OS2OnScroll(
+bool wxWindowOS2::OS2OnScroll(
   int                               nOrientation
 , WXWORD                            wParam
 , WXWORD                            wPos
@@ -3563,7 +3842,7 @@ bool wxWindow::OS2OnScroll(
             return FALSE;
     }
     return GetEventHandler()->ProcessEvent(vEvent);
-} // end of wxWindow::OS2OnScroll
+} // end of wxWindowOS2::OS2OnScroll
 
 // ===========================================================================
 // global functions