added wxListView class: this is going to be a wxListCtrl with human (inter)face

[wxWidgets.git] / src / os2 / window.cpp

diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index 595e23f4e00f8e0e6bdc8d7c9f9356080bff334d..fbcfcc1029725ada2cdf3a2132028e5b70974d77 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -149,11 +149,11 @@ static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL
     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 
 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
     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()
 
 // ===========================================================================
 END_EVENT_TABLE()
 
 // ===========================================================================


@@ -163,7 +163,7 @@ END_EVENT_TABLE()
 //
 // Find an item given the PM Window id
 //
 //
 // Find an item given the PM Window id
 //

-wxWindow* wxWindow::FindItem(
+wxWindow* wxWindowOS2::FindItem(

   long                              lId
 ) const
 {
   long                              lId
 ) const
 {


@@ -196,12 +196,12 @@ wxWindow* wxWindow::FindItem(
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);

-} // end of wxWindow::FindItem
+} // end of wxWindowOS2::FindItem

 
 //
 // Find an item given the PM Window handle
 //
 
 //
 // Find an item given the PM Window handle
 //

-wxWindow* wxWindow::FindItemByHWND(
+wxWindow* wxWindowOS2::FindItemByHWND(

   WXHWND                            hWnd
 , bool                              bControlOnly
 ) const
   WXHWND                            hWnd
 , bool                              bControlOnly
 ) const


@@ -235,12 +235,12 @@ wxWindow* wxWindow::FindItemByHWND(
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);
         pCurrent = pCurrent->GetNext();
     }
     return(NULL);

-} // end of wxWindow::FindItemByHWND
+} // end of wxWindowOS2::FindItemByHWND

 
 //
 // Default command handler
 //
 
 //
 // Default command handler
 //

-bool wxWindow::OS2Command(
+bool wxWindowOS2::OS2Command(

   WXUINT                            WXUNUSED(uParam)
 , WXWORD                            WXUNUSED(uId)
 )
   WXUINT                            WXUNUSED(uParam)
 , WXWORD                            WXUNUSED(uId)
 )


@@ -252,7 +252,7 @@ bool wxWindow::OS2Command(
 // constructors and such
 // ----------------------------------------------------------------------------
 
 // constructors and such
 // ----------------------------------------------------------------------------
 

-void wxWindow::Init()
+void wxWindowOS2::Init()

 {
     //
     // Generic
 {
     //
     // Generic


@@ -296,16 +296,26 @@ void wxWindow::Init()
     m_lLastMouseY = -1;
     m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK
     m_lLastMouseY = -1;
     m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK

-} // wxWindow::Init
+} // wxWindowOS2::Init

 
 //
 // Destructor
 //
 
 //
 // Destructor
 //

-wxWindow::~wxWindow()
+wxWindowOS2::~wxWindowOS2()

 {
     m_isBeingDeleted = TRUE;
 
     OS2DetachWindowMenu();
 {
     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();
     if (m_parent)
         m_parent->RemoveChild(this);
     DestroyChildren();


@@ -319,9 +329,9 @@ wxWindow::~wxWindow()
         //
         wxRemoveHandleAssociation(this);
     }
         //
         wxRemoveHandleAssociation(this);
     }

-} // end of wxWindow::~wxWindow
+} // end of wxWindowOS2::~wxWindowOS2

 
 

-bool wxWindow::Create(
+bool wxWindowOS2::Create(

   wxWindow*                         pParent
 , wxWindowID                        vId
 , const wxPoint&                    rPos
   wxWindow*                         pParent
 , wxWindowID                        vId
 , const wxPoint&                    rPos


@@ -433,19 +443,19 @@ bool wxWindow::Create(
              );
 
     return(TRUE);
              );
 
     return(TRUE);

-} // end of wxWindow::Create
+} // end of wxWindowOS2::Create

 
 // ---------------------------------------------------------------------------
 // basic operations
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // basic operations
 // ---------------------------------------------------------------------------
 

-void wxWindow::SetFocus()
+void wxWindowOS2::SetFocus()

 {
     HWND                            hWnd = GetHwnd();
 
     if (hWnd)
         ::WinSetFocus(HWND_DESKTOP, hWnd);
 {
     HWND                            hWnd = GetHwnd();
 
     if (hWnd)
         ::WinSetFocus(HWND_DESKTOP, hWnd);

-} // end of wxWindow::SetFocus
+} // end of wxWindowOS2::SetFocus

 
 wxWindow* wxWindowBase::FindFocus()
 {
 
 wxWindow* wxWindowBase::FindFocus()
 {


@@ -458,7 +468,7 @@ wxWindow* wxWindowBase::FindFocus()
     return NULL;
 } // wxWindowBase::FindFocus
 
     return NULL;
 } // wxWindowBase::FindFocus
 

-bool wxWindow::Enable(
+bool wxWindowOS2::Enable(

   bool                              bEnable
 )
 {
   bool                              bEnable
 )
 {


@@ -480,9 +490,9 @@ bool wxWindow::Enable(
         pNode = pNode->GetNext();
     }
     return(TRUE);
         pNode = pNode->GetNext();
     }
     return(TRUE);

-} // end of wxWindow::Enable
+} // end of wxWindowOS2::Enable

 
 

-bool wxWindow::Show(
+bool wxWindowOS2::Show(

   bool                              bShow
 )
 {
   bool                              bShow
 )
 {


@@ -498,31 +508,31 @@ bool wxWindow::Show(
         ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
     }
     return(TRUE);
         ::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);
 {
     ::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);
 {
     ::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());
   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());
 {
     return wxGetWindowText(GetHWND());

-} // end of wxWindow::GetTitle
+} // end of wxWindowOS2::GetTitle

 
 

-void wxWindow::CaptureMouse()
+void wxWindowOS2::CaptureMouse()

 {
     HWND                            hWnd = GetHwnd();
 
 {
     HWND                            hWnd = GetHwnd();
 


@@ -531,18 +541,24 @@ void wxWindow::CaptureMouse()
         ::WinSetCapture(HWND_DESKTOP, hWnd);
         m_bWinCaptured = TRUE;
     }
         ::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;
     }
 {
     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
 )
 {
   const wxFont&                     rFont
 )
 {


@@ -564,7 +580,7 @@ bool wxWindow::SetFont(
     return(TRUE);
 }
 
     return(TRUE);
 }
 

-bool wxWindow::SetCursor(
+bool wxWindowOS2::SetCursor(

   const wxCursor&                   rCursor
 ) // check if base implementation is OK
 {
   const wxCursor&                   rCursor
 ) // check if base implementation is OK
 {


@@ -595,9 +611,9 @@ bool wxWindow::SetCursor(
         ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
     }
     return TRUE;
         ::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
 )
   int                               nXPos
 , int                               nYPos
 )


@@ -611,10 +627,10 @@ void wxWindow::WarpPointer(
     nY += vRect.yBottom;
 
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
     nY += vRect.yBottom;
 
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));

-} // end of wxWindow::WarpPointer
+} // end of wxWindowOS2::WarpPointer

 
 #if WXWIN_COMPATIBILITY
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::OS2DeviceToLogical (float *x, float *y) const
+void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const

 {
 }
 #endif // WXWIN_COMPATIBILITY
 {
 }
 #endif // WXWIN_COMPATIBILITY


@@ -624,7 +640,7 @@ void wxWindow::OS2DeviceToLogical (float *x, float *y) const
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY
 // ---------------------------------------------------------------------------
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::SetScrollRange(
+void wxWindowOS2::SetScrollRange(

   int                               nOrient
 , int                               nRange
 , bool                              bRefresh
   int                               nOrient
 , int                               nRange
 , bool                              bRefresh


@@ -648,9 +664,9 @@ void wxWindow::SetScrollRange(
         ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
         ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
     }
         ::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 wxWindow::SetScrollRange
+} // end of wxWindowOS2::SetScrollRange

 
 

-void wxWindow::SetScrollPage(
+void wxWindowOS2::SetScrollPage(

   int                               nOrient
 , int                               nPage
 , bool                              bRefresh
   int                               nOrient
 , int                               nPage
 , bool                              bRefresh


@@ -660,9 +676,9 @@ void wxWindow::SetScrollPage(
         m_nXThumbSize = nPage;
     else
         m_nYThumbSize = nPage;
         m_nXThumbSize = nPage;
     else
         m_nYThumbSize = nPage;

-} // end of wxWindow::SetScrollPage
+} // end of wxWindowOS2::SetScrollPage

 
 

-int wxWindow::OldGetScrollRange(
+int wxWindowOS2::OldGetScrollRange(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {


@@ -675,9 +691,9 @@ int wxWindow::OldGetScrollRange(
         return(SHORT2FROMMR(mRc));
      }
      return 0;
         return(SHORT2FROMMR(mRc));
      }
      return 0;

-} // end of wxWindow::OldGetScrollRange
+} // end of wxWindowOS2::OldGetScrollRange

 
 

-int  wxWindow::GetScrollPage(
+int  wxWindowOS2::GetScrollPage(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {


@@ -685,10 +701,10 @@ int  wxWindow::GetScrollPage(
         return m_nXThumbSize;
     else
         return m_nYThumbSize;
         return m_nXThumbSize;
     else
         return m_nYThumbSize;

-} // end of wxWindow::GetScrollPage
+} // end of wxWindowOS2::GetScrollPage

 #endif // WXWIN_COMPATIBILITY
 
 #endif // WXWIN_COMPATIBILITY
 

-int  wxWindow::GetScrollPos(
+int  wxWindowOS2::GetScrollPos(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {


@@ -696,9 +712,9 @@ int  wxWindow::GetScrollPos(
         return((int)::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
     else
         return((int)::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
         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 wxWindow::GetScrollPos
+} // end of wxWindowOS2::GetScrollPos

 
 

-int wxWindow::GetScrollRange(
+int wxWindowOS2::GetScrollRange(

   int                               nOrient
 ) const
 {
   int                               nOrient
 ) const
 {


@@ -709,9 +725,9 @@ int wxWindow::GetScrollRange(
     else
         mr = ::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
     return((int)SHORT2FROMMR(mr));
     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
 {
   int                               nOrient
 ) const
 {


@@ -719,9 +735,9 @@ int wxWindow::GetScrollThumb(
         return m_nXThumbSize;
     else
         return m_nYThumbSize;
         return m_nXThumbSize;
     else
         return m_nYThumbSize;

-} // end of wxWindow::GetScrollThumb
+} // end of wxWindowOS2::GetScrollThumb

 
 

-void wxWindow::SetScrollPos(
+void wxWindowOS2::SetScrollPos(

   int                               nOrient
 , int                               nPos
 , bool                              bRefresh
   int                               nOrient
 , int                               nPos
 , bool                              bRefresh


@@ -731,9 +747,9 @@ void wxWindow::SetScrollPos(
         ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
     else
         ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
         ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
     else
         ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);

-} // end of wxWindow::SetScrollPos(
+} // end of wxWindowOS2::SetScrollPos(

 
 

-void wxWindow::SetScrollbar(
+void wxWindowOS2::SetScrollbar(

   int                               nOrient
 , int                               nPos
 , int                               nThumbVisible
   int                               nOrient
 , int                               nPos
 , int                               nThumbVisible


@@ -866,9 +882,9 @@ void wxWindow::SetScrollbar(
         }
         m_nYThumbSize = nThumbVisible;
     }
         }
         m_nYThumbSize = nThumbVisible;
     }

-} // end of wxWindow::SetScrollbar
+} // end of wxWindowOS2::SetScrollbar

 
 

-void wxWindow::ScrollWindow(
+void wxWindowOS2::ScrollWindow(

   int                               nDx
 , int                               nDy
 , const wxRect*                     pRect
   int                               nDx
 , int                               nDy
 , const wxRect*                     pRect


@@ -955,13 +971,13 @@ void wxWindow::ScrollWindow(
         }
         pCurrent = pCurrent->GetNext();
     }
         }
         pCurrent = pCurrent->GetNext();
     }

-} // end of wxWindow::ScrollWindow
+} // end of wxWindowOS2::ScrollWindow

 
 // ---------------------------------------------------------------------------
 // subclassing
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // subclassing
 // ---------------------------------------------------------------------------
 

-void wxWindow::SubclassWin(
+void wxWindowOS2::SubclassWin(

   WXHWND                            hWnd
 )
 {
   WXHWND                            hWnd
 )
 {


@@ -970,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);
     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
 {
     //
     // Restore old Window proc


@@ -991,12 +1007,12 @@ void wxWindow::UnsubclassWin()
             m_fnOldWndProc = 0;
         }
     }
             m_fnOldWndProc = 0;
         }
     }

-} // end of wxWindow::UnsubclassWin
+} // end of wxWindowOS2::UnsubclassWin

 
 //
 // Make a Windows extended style from the given wxWindows window style
 //
 
 //
 // Make a Windows extended style from the given wxWindows window style
 //

-WXDWORD wxWindow::MakeExtendedStyle(
+WXDWORD wxWindowOS2::MakeExtendedStyle(

   long                              lStyle
 , bool                              bEliminateBorders
 )
   long                              lStyle
 , bool                              bEliminateBorders
 )


@@ -1022,14 +1038,14 @@ WXDWORD wxWindow::MakeExtendedStyle(
             dwStyle |= wxSTATIC_BORDER;
     }
     return dwStyle;
             dwStyle |= wxSTATIC_BORDER;
     }
     return dwStyle;

-} // end of wxWindow::MakeExtendedStyle
+} // end of wxWindowOS2::MakeExtendedStyle

 
 //
 // 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 OS2Create.
 //
 
 //
 // 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 OS2Create.
 //

-WXDWORD wxWindow::Determine3DEffects(
+WXDWORD wxWindowOS2::Determine3DEffects(

   WXDWORD                           dwDefaultBorderStyle
 , bool*                             pbWant3D
 ) const
   WXDWORD                           dwDefaultBorderStyle
 , bool*                             pbWant3D
 ) const


@@ -1097,10 +1113,10 @@ WXDWORD wxWindow::Determine3DEffects(
         )
         dwStyle |= dwDefaultBorderStyle;
     return dwStyle;
         )
         dwStyle |= dwDefaultBorderStyle;
     return dwStyle;

-} // end of wxWindow::Determine3DEffects
+} // end of wxWindowOS2::Determine3DEffects

 
 #if WXWIN_COMPATIBILITY
 
 #if WXWIN_COMPATIBILITY

-void wxWindow::OnCommand(
+void wxWindowOS2::OnCommand(

   wxWindow&                         rWin
 , wxCommandEvent&                   rEvent
 )
   wxWindow&                         rWin
 , wxCommandEvent&                   rEvent
 )


@@ -1111,9 +1127,9 @@ void wxWindow::OnCommand(
         m_parent->GetEventHandler()->OnCommand( rWin
                                                ,rEvent
                                               );
         m_parent->GetEventHandler()->OnCommand( rWin
                                                ,rEvent
                                               );

-} // end of wxWindow::OnCommand
+} // end of wxWindowOS2::OnCommand

 
 

-wxObject* wxWindow::GetChild(
+wxObject* wxWindowOS2::GetChild(

   int                               nNumber
 ) const
 {
   int                               nNumber
 ) const
 {


@@ -1132,20 +1148,20 @@ wxObject* wxWindow::GetChild(
     }
     else
         return NULL;
     }
     else
         return NULL;

-} // end of wxWindow::GetChild
+} // end of wxWindowOS2::GetChild

 
 #endif // WXWIN_COMPATIBILITY
 
 //
 // Setup background and foreground colours correctly
 //
 
 #endif // WXWIN_COMPATIBILITY
 
 //
 // Setup background and foreground colours correctly
 //

-void wxWindow::SetupColours()
+void wxWindowOS2::SetupColours()

 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 {
     if ( GetParent() )
         SetBackgroundColour(GetParent()->GetBackgroundColour());

-} // end of wxWindow::SetupColours
+} // end of wxWindowOS2::SetupColours

 
 

-void wxWindow::OnIdle(
+void wxWindowOS2::OnIdle(

   wxIdleEvent&                      rEvent
 )
 {
   wxIdleEvent&                      rEvent
 )
 {


@@ -1187,12 +1203,12 @@ void wxWindow::OnIdle(
         }
     }
     UpdateWindowUI();
         }
     }
     UpdateWindowUI();

-} // end of wxWindow::OnIdle
+} // end of wxWindowOS2::OnIdle

 
 //
 // Set this window to be the child of 'parent'.
 //
 
 //
 // Set this window to be the child of 'parent'.
 //

-bool wxWindow::Reparent(
+bool wxWindowOS2::Reparent(

   wxWindow*                         pParent
 )
 {
   wxWindow*                         pParent
 )
 {


@@ -1204,9 +1220,9 @@ bool wxWindow::Reparent(
 
     ::WinSetParent(hWndChild, hWndParent, TRUE);
     return TRUE;
 
     ::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()
 {
     wxClientDC                      vDc(this);
     wxBrush                         vBrush( GetBackgroundColour()


@@ -1215,9 +1231,9 @@ void wxWindow::Clear()
 
     vDc.SetBackground(vBrush);
     vDc.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
 )
   bool                              bEraseBack
 , const wxRect*                     pRect
 )


@@ -1240,14 +1256,14 @@ void wxWindow::Refresh(
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
     }
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
     }

-} // end of wxWindow::Refresh
+} // end of wxWindowOS2::Refresh

 
 // ---------------------------------------------------------------------------
 // drag and drop
 // ---------------------------------------------------------------------------
 
 #if wxUSE_DRAG_AND_DROP
 
 // ---------------------------------------------------------------------------
 // drag and drop
 // ---------------------------------------------------------------------------
 
 #if wxUSE_DRAG_AND_DROP

-void wxWindow::SetDropTarget(
+void wxWindowOS2::SetDropTarget(

   wxDropTarget*                     pDropTarget
 )
 {
   wxDropTarget*                     pDropTarget
 )
 {


@@ -1259,14 +1275,14 @@ void wxWindow::SetDropTarget(
     m_dropTarget = pDropTarget;
     if (m_dropTarget != 0)
         m_dropTarget->Register(m_hWnd);
     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.
 //
 #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
 )
 {
   bool                              bAccept
 )
 {


@@ -1274,7 +1290,7 @@ void wxWindow::DragAcceptFiles(
 
     if (hWnd && bAccept)
         ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);
 
     if (hWnd && bAccept)
         ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);

-} // end of wxWindow::DragAcceptFiles
+} // end of wxWindowOS2::DragAcceptFiles

 
 // ----------------------------------------------------------------------------
 // tooltips
 
 // ----------------------------------------------------------------------------
 // tooltips


@@ -1282,7 +1298,7 @@ void wxWindow::DragAcceptFiles(
 
 #if wxUSE_TOOLTIPS
 
 
 #if wxUSE_TOOLTIPS
 

-void wxWindow::DoSetToolTip(
+void wxWindowOS2::DoSetToolTip(

   wxToolTip*                        pTooltip
 )
 {
   wxToolTip*                        pTooltip
 )
 {


@@ -1290,7 +1306,7 @@ void wxWindow::DoSetToolTip(
 
     if (m_tooltip)
         m_tooltip->SetWindow(this);
 
     if (m_tooltip)
         m_tooltip->SetWindow(this);

-} // end of wxWindow::DoSetToolTip
+} // end of wxWindowOS2::DoSetToolTip

 
 #endif // wxUSE_TOOLTIPS
 
 
 #endif // wxUSE_TOOLTIPS
 


@@ -1299,7 +1315,7 @@ void wxWindow::DoSetToolTip(
 // ---------------------------------------------------------------------------
 
 // Get total size
 // ---------------------------------------------------------------------------
 
 // Get total size

-void wxWindow::DoGetSize(
+void wxWindowOS2::DoGetSize(

   int*                              pWidth
 , int*                              pHeight
 ) const
   int*                              pWidth
 , int*                              pHeight
 ) const


@@ -1314,9 +1330,9 @@ void wxWindow::DoGetSize(
     if (pHeight )
         // OS/2 PM is backwards from windows
         *pHeight = vRect.yTop - vRect.yBottom;
     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
   int*                              pX
 , int*                              pY
 ) const


@@ -1369,9 +1385,9 @@ void wxWindow::DoGetPosition(
         *pX = vPoint.x;
     if  (pY)
         *pY = vPoint.y;
         *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
   int*                              pX
 , int*                              pY
 ) const


@@ -1385,9 +1401,9 @@ void wxWindow::DoScreenToClient(
         *pX -= vSwp.x;
     if (pY)
         *pY -= vSwp.y;
         *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
   int*                              pX
 , int*                              pY
 ) const


@@ -1401,13 +1417,13 @@ void wxWindow::DoClientToScreen(
         *pX += vSwp.x;
     if (pY)
         *pY += vSwp.y;
         *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
 //
 
 //
 // 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
   int*                              pWidth
 , int*                              pHeight
 ) const


@@ -1429,15 +1445,26 @@ void wxWindow::DoGetClientSize(
         *pWidth  = vRect.xRight;
     if (pHeight)
         *pHeight = vRect.yTop;
         *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
 )
 {
   int                               nX
 , int                               nY
 , int                               nWidth
 , int                               nHeight
 )
 {

+    RECTL                           vRect;
+    HWND                            hParent;
+    wxWindow*                       pParent = GetParent();
+
+    if (pParent)
+        hParent = GetWinHwnd(pParent);
+    else
+        hParent = HWND_DESKTOP;
+    ::WinQueryWindowRect(hParent, &vRect);
+    nY = vRect.yTop - (nY + nHeight);
+

     if ( !::WinSetWindowPos( GetHwnd()
                             ,HWND_TOP
                             ,(LONG)nX
     if ( !::WinSetWindowPos( GetHwnd()
                             ,HWND_TOP
                             ,(LONG)nX


@@ -1449,7 +1476,7 @@ void wxWindow::DoMoveWindow(
     {
         wxLogLastError("MoveWindow");
     }
     {
         wxLogLastError("MoveWindow");
     }

-} // end of wxWindow::DoMoveWindow
+} // end of wxWindowOS2::DoMoveWindow

 
 //
 // Set the size of the window: if the dimensions are positive, just use them,
 
 //
 // Set the size of the window: if the dimensions are positive, just use them,


@@ -1461,7 +1488,7 @@ void wxWindow::DoMoveWindow(
 // the width/height to best suit our contents, otherwise we reuse the current
 // width/height
 //
 // 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
   int                               nX
 , int                               nY
 , int                               nWidth


@@ -1545,9 +1572,9 @@ void wxWindow::DoSetSize(
                  ,nWidth
                  ,nHeight
                 );
                  ,nWidth
                  ,nHeight
                 );

-} // end of wxWindow::DoSetSize
+} // end of wxWindowOS2::DoSetSize

 
 

-void wxWindow::DoSetClientSize(
+void wxWindowOS2::DoSetClientSize(

   int                               nWidth
 , int                               nHeight
 )
   int                               nWidth
 , int                               nHeight
 )


@@ -1604,14 +1631,14 @@ void wxWindow::DoSetClientSize(
 
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);
 
     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);
 {
     return wxPoint(0, 0);

-} // end of wxWindow::GetClientAreaOrigin
+} // end of wxWindowOS2::GetClientAreaOrigin

 
 

-void wxWindow::AdjustForParentClientOrigin(
+void wxWindowOS2::AdjustForParentClientOrigin(

   int&                              rX
 , int&                              rY
 , int                               nSizeFlags
   int&                              rX
 , int&                              rY
 , int                               nSizeFlags


@@ -1632,13 +1659,13 @@ void wxWindow::AdjustForParentClientOrigin(
             rY += vPoint.y;
         }
     }
             rY += vPoint.y;
         }
     }

-} // end of wxWindow::AdjustForParentClientOrigin
+} // end of wxWindowOS2::AdjustForParentClientOrigin

 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
 

-int wxWindow::GetCharHeight() const
+int wxWindowOS2::GetCharHeight() const

 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;
 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;


@@ -1653,9 +1680,9 @@ int wxWindow::GetCharHeight() const
     }
     ::WinReleasePS(hPs);
     return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
     }
     ::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;
 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;


@@ -1669,9 +1696,9 @@ int wxWindow::GetCharWidth() const
     }
     ::WinReleasePS(hPs);
     return(vFontMetrics.lAveCharWidth);
     }
     ::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
   const wxString&                   rString
 , int*                              pX
 , int*                              pY


@@ -1728,7 +1755,7 @@ void wxWindow::GetTextExtent(
 // Caret manipulation
 // ---------------------------------------------------------------------------
 
 // Caret manipulation
 // ---------------------------------------------------------------------------
 

-void wxWindow::CreateCaret(
+void wxWindowOS2::CreateCaret(

   int                               nWidth
 , int                               nHeight
 )
   int                               nWidth
 , int                               nHeight
 )


@@ -1737,30 +1764,30 @@ void wxWindow::CreateCaret(
                          ,nWidth
                          ,nHeight
                         ));
                          ,nWidth
                          ,nHeight
                         ));

-} // end of wxWindow::CreateCaret
+} // end of wxWindowOS2::CreateCaret

 
 

-void wxWindow::CreateCaret(
+void wxWindowOS2::CreateCaret(

   const wxBitmap*                   pBitmap
 )
 {
     wxFAIL_MSG("not implemented");
   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);
   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);
 {
     SetCaret(NULL);

-} // end of wxWindow::DestroyCaret
+} // end of wxWindowOS2::DestroyCaret

 
 

-void wxWindow::SetCaretPos(
+void wxWindowOS2::SetCaretPos(

   int                               nX
 , int                               nY)
 {
   int                               nX
 , int                               nY)
 {


@@ -1769,9 +1796,9 @@ void wxWindow::SetCaretPos(
     m_caret->Move( nX
                   ,nY
                  );
     m_caret->Move( nX
                   ,nY
                  );

-} // end of wxWindow::SetCaretPos
+} // end of wxWindowOS2::SetCaretPos

 
 

-void wxWindow::GetCaretPos(
+void wxWindowOS2::GetCaretPos(

   int*                              pX
 , int*                              pY
 ) const
   int*                              pX
 , int*                              pY
 ) const


@@ -1781,7 +1808,7 @@ void wxWindow::GetCaretPos(
     m_caret->GetPosition( pX
                          ,pY
                         );
     m_caret->GetPosition( pX
                          ,pY
                         );

-} // end of wxWindow::GetCaretPos
+} // end of wxWindowOS2::GetCaretPos

 
 #endif //wxUSE_CARET
 
 
 #endif //wxUSE_CARET
 


@@ -1789,7 +1816,27 @@ void wxWindow::GetCaretPos(
 // popup menu
 // ---------------------------------------------------------------------------
 
 // 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
   wxMenu*                           pMenu
 , int                               nX
 , int                               nY


@@ -1815,18 +1862,25 @@ bool wxWindow::DoPopupMenu(
                    ,0L
                    ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD
                   );
                    ,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;
     wxCurrentPopupMenu = NULL;
 
     pMenu->SetInvokingWindow(NULL);
     return TRUE;

-} // end of wxWindow::DoPopupMenu
+} // end of wxWindowOS2::DoPopupMenu

 
 // ===========================================================================
 // pre/post message processing
 // ===========================================================================
 
 
 // ===========================================================================
 // pre/post message processing
 // ===========================================================================
 

-MRESULT wxWindow::OS2DefWindowProc(
+MRESULT wxWindowOS2::OS2DefWindowProc(

   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam
   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam


@@ -1836,9 +1890,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);
         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
 )
 {
   WXMSG*                            pMsg
 )
 {


@@ -2024,9 +2078,9 @@ bool wxWindow::OS2ProcessMessage(
 #endif // wxUSE_TOOLTIPS
 
     return FALSE;
 #endif // wxUSE_TOOLTIPS
 
     return FALSE;

-} // end of wxWindow::OS2ProcessMessage
+} // end of wxWindowOS2::OS2ProcessMessage

 
 

-bool wxWindow::OS2TranslateMessage(
+bool wxWindowOS2::OS2TranslateMessage(

   WXMSG*                            pMsg
 )
 {
   WXMSG*                            pMsg
 )
 {


@@ -2035,13 +2089,13 @@ bool wxWindow::OS2TranslateMessage(
 #else
   return FALSE;
 #endif //wxUSE_ACCEL
 #else
   return FALSE;
 #endif //wxUSE_ACCEL

-} // end of wxWindow::OS2TranslateMessage
+} // end of wxWindowOS2::OS2TranslateMessage

 
 // ---------------------------------------------------------------------------
 // message params unpackers
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // message params unpackers
 // ---------------------------------------------------------------------------
 

-void wxWindow::UnpackCommand(
+void wxWindowOS2::UnpackCommand(

   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WORD*                             pId
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WORD*                             pId


@@ -2052,9 +2106,9 @@ void wxWindow::UnpackCommand(
     *pId = LOWORD(wParam);
     *phWnd = NULL;  // or may be GetHWND() ?
     *pCmd = LOWORD(lParam);
     *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
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pState


@@ -2063,9 +2117,9 @@ void wxWindow::UnpackActivate(
 {
     *pState     = LOWORD(wParam);
     *phWnd      = (WXHWND)lParam;
 {
     *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
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pCode


@@ -2085,9 +2139,9 @@ void wxWindow::UnpackScroll(
 
     *pPos  = SHORT1FROMMP(lParam);
     *pCode = SHORT2FROMMP(lParam);
 
     *pPos  = SHORT1FROMMP(lParam);
     *pCode = SHORT2FROMMP(lParam);

-} // end of wxWindow::UnpackScroll
+} // end of wxWindowOS2::UnpackScroll

 
 

-void wxWindow::UnpackMenuSelect(
+void wxWindowOS2::UnpackMenuSelect(

   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pItem
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 , WXWORD*                           pItem


@@ -2098,7 +2152,7 @@ void wxWindow::UnpackMenuSelect(
     *pItem = (WXWORD)LOWORD(wParam);
     *pFlags = HIWORD(wParam);
     *phMenu = (WXHMENU)lParam;
     *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
 
 // ---------------------------------------------------------------------------
 // Main wxWindows window proc and the window proc for wxWindow


@@ -2169,7 +2223,7 @@ MRESULT EXPENTRY wxWndProc(
 // We will add (or delete) messages we need to handle at this default
 // level as we go
 //
 // 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
   WXUINT                            uMsg
 , WXWPARAM                          wParam
 , WXLPARAM                          lParam


@@ -2531,7 +2585,7 @@ MRESULT wxWindow::OS2WindowProc(
             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
     }
     return mResult;
             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
     }
     return mResult;

-} // end of wxWindow::OS2WindowProc
+} // end of wxWindowOS2::OS2WindowProc

 
 //
 // Dialog window proc
 
 //
 // Dialog window proc


@@ -2613,11 +2667,11 @@ void wxRemoveHandleAssociation(
 // Default destroyer - override if you destroy it in some other way
 // (e.g. with MDI child windows)
 //
 // 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)
     {
 {
     if (m_hMenu)
     {


@@ -2647,9 +2701,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
   WXHWND                            hParent
 , PSZ                               zClass
 , const wxChar*                     zTitle


@@ -2785,7 +2839,7 @@ bool wxWindow::OS2Create(
         SubclassWin(GetHWND());
     }
     return TRUE;
         SubclassWin(GetHWND());
     }
     return TRUE;

-} // end of wxWindow::OS2Create
+} // end of wxWindowOS2::OS2Create

 
 // ===========================================================================
 // OS2 PM message handlers
 
 // ===========================================================================
 // OS2 PM message handlers


@@ -2795,7 +2849,7 @@ bool wxWindow::OS2Create(
 // window creation/destruction
 // ---------------------------------------------------------------------------
 
 // window creation/destruction
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleCreate(
+bool wxWindowOS2::HandleCreate(

   WXLPCREATESTRUCT                  vCs
 , bool*                             pbMayCreate
 )
   WXLPCREATESTRUCT                  vCs
 , bool*                             pbMayCreate
 )


@@ -2805,9 +2859,9 @@ bool wxWindow::HandleCreate(
     (void)GetEventHandler()->ProcessEvent(vEvent);
     *pbMayCreate = TRUE;
     return TRUE;
     (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);
 
 {
     wxWindowDestroyEvent            vEvent(this);
 


@@ -2829,12 +2883,12 @@ bool wxWindow::HandleDestroy()
     // WM_DESTROY handled
     //
     return TRUE;
     // WM_DESTROY handled
     //
     return TRUE;

-} // end of wxWindow::HandleDestroy
+} // end of wxWindowOS2::HandleDestroy

 
 // ---------------------------------------------------------------------------
 // activation/focus
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // activation/focus
 // ---------------------------------------------------------------------------

-void wxWindow::OnSetFocus(
+void wxWindowOS2::OnSetFocus(

   wxFocusEvent&                     rEvent
 )
 {
   wxFocusEvent&                     rEvent
 )
 {


@@ -2865,9 +2919,9 @@ void wxWindow::OnSetFocus(
                GetClassInfo()->GetClassName(), GetHandle());
 
     rEvent.Skip();
                GetClassInfo()->GetClassName(), GetHandle());
 
     rEvent.Skip();

-} // end of wxWindow::OnSetFocus
+} // end of wxWindowOS2::OnSetFocus

 
 

-bool wxWindow::HandleActivate(
+bool wxWindowOS2::HandleActivate(

   int                               nState
 , WXHWND                            WXUNUSED(hActivate)
 )
   int                               nState
 , WXHWND                            WXUNUSED(hActivate)
 )


@@ -2878,9 +2932,9 @@ bool wxWindow::HandleActivate(
                                           );
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
                                           );
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleActivate
+} // end of wxWindowOS2::HandleActivate

 
 

-bool wxWindow::HandleSetFocus(
+bool wxWindowOS2::HandleSetFocus(

   WXHWND                            WXUNUSED(hWnd)
 )
 {
   WXHWND                            WXUNUSED(hWnd)
 )
 {


@@ -2909,9 +2963,9 @@ bool wxWindow::HandleSetFocus(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleSetFocus
+} // end of wxWindowOS2::HandleSetFocus

 
 

-bool wxWindow::HandleKillFocus(
+bool wxWindowOS2::HandleKillFocus(

   WXHWND                            WXUNUSED(hWnd)
 )
 {
   WXHWND                            WXUNUSED(hWnd)
 )
 {


@@ -2931,13 +2985,13 @@ bool wxWindow::HandleKillFocus(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleKillFocus
+} // end of wxWindowOS2::HandleKillFocus

 
 // ---------------------------------------------------------------------------
 // miscellaneous
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // miscellaneous
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleShow(
+bool wxWindowOS2::HandleShow(

   bool                              bShow
 , int                               nStatus
 )
   bool                              bShow
 , int                               nStatus
 )


@@ -2948,9 +3002,9 @@ bool wxWindow::HandleShow(
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);
 
     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)
 )
 {
   WXHWND                            WXUNUSED(hWndFocus)
 )
 {


@@ -2958,15 +3012,15 @@ bool wxWindow::HandleInitDialog(
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);
 
     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;
 }
 
 {
    // TODO: We'll handle drag and drop later
     return FALSE;
 }
 

-bool wxWindow::HandleSetCursor(
+bool wxWindowOS2::HandleSetCursor(

   USHORT                            vId
 , WXHWND                            hPointer
 )
   USHORT                            vId
 , WXHWND                            hPointer
 )


@@ -2977,12 +3031,12 @@ bool wxWindow::HandleSetCursor(
     //
     ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer);
     return TRUE;
     //
     ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer);
     return TRUE;

-} // end of wxWindow::HandleSetCursor
+} // end of wxWindowOS2::HandleSetCursor

 
 // ---------------------------------------------------------------------------
 // owner drawn stuff
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // owner drawn stuff
 // ---------------------------------------------------------------------------

-bool wxWindow::OS2OnDrawItem(
+bool wxWindowOS2::OS2OnDrawItem(

   int                               vId
 , WXDRAWITEMSTRUCT*                 pItemStruct
 )
   int                               vId
 , WXDRAWITEMSTRUCT*                 pItemStruct
 )


@@ -3133,9 +3187,9 @@ bool wxWindow::OS2OnDrawItem(
     }
 #endif
     return FALSE;
     }
 #endif
     return FALSE;

-} // end of wxWindow::OS2OnDrawItem
+} // end of wxWindowOS2::OS2OnDrawItem

 
 

-bool wxWindow::OS2OnMeasureItem(
+bool wxWindowOS2::OS2OnMeasureItem(

   int                               lId
 , WXMEASUREITEMSTRUCT*              pItemStruct
 )
   int                               lId
 , WXMEASUREITEMSTRUCT*              pItemStruct
 )


@@ -3182,15 +3236,15 @@ bool wxWindow::OS2OnMeasureItem(
 // colours and palettes
 // ---------------------------------------------------------------------------
 
 // colours and palettes
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleSysColorChange()
+bool wxWindowOS2::HandleSysColorChange()

 {
     wxSysColourChangedEvent         vEvent;
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 {
     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
 )
 {
   WXHBRUSH*                         phBrush
 )
 {


@@ -3198,9 +3252,9 @@ bool wxWindow::HandleCtlColor(
     // Not much provided with message. So not sure I can do anything with it
     //
     return TRUE;
     // 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
 )
   PWNDPARAMS                        pWndParams
 , WXLPARAM                          lParam
 )


@@ -3210,7 +3264,7 @@ bool wxWindow::HandleWindowParams(
 }
 
 // Define for each class of dialog and control
 }
 
 // Define for each class of dialog and control

-WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC,
+WXHBRUSH wxWindowOS2::OnCtlColor(WXHDC hDC,

                               WXHWND hWnd,
                               WXUINT nCtlColor,
                               WXUINT message,
                               WXHWND hWnd,
                               WXUINT nCtlColor,
                               WXUINT message,


@@ -3220,7 +3274,7 @@ WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC,
     return (WXHBRUSH)0;
 }
 
     return (WXHBRUSH)0;
 }
 

-bool wxWindow::HandlePaletteChanged()
+bool wxWindowOS2::HandlePaletteChanged()

 {
     // need to set this to something first
     WXHWND                          hWndPalChange = NULLHANDLE;
 {
     // need to set this to something first
     WXHWND                          hWndPalChange = NULLHANDLE;


@@ -3231,9 +3285,9 @@ bool wxWindow::HandlePaletteChanged()
     vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
 
     return GetEventHandler()->ProcessEvent(vEvent);
     vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
 
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandlePaletteChanged
+} // end of wxWindowOS2::HandlePaletteChanged

 
 

-bool wxWindow::HandlePresParamChanged(
+bool wxWindowOS2::HandlePresParamChanged(

   WXWPARAM                          wParam
 )
 {
   WXWPARAM                          wParam
 )
 {


@@ -3251,7 +3305,7 @@ bool wxWindow::HandlePresParamChanged(
 //
 // Responds to colour changes: passes event on to children.
 //
 //
 // Responds to colour changes: passes event on to children.
 //

-void wxWindow::OnSysColourChanged(
+void wxWindowOS2::OnSysColourChanged(

   wxSysColourChangedEvent&          rEvent
 )
 {
   wxSysColourChangedEvent&          rEvent
 )
 {


@@ -3273,13 +3327,13 @@ void wxWindow::OnSysColourChanged(
         }
         pNode = pNode->Next();
     }
         }
         pNode = pNode->Next();
     }

-} // end of wxWindow::OnSysColourChanged
+} // end of wxWindowOS2::OnSysColourChanged

 
 // ---------------------------------------------------------------------------
 // painting
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // painting
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandlePaint()
+bool wxWindowOS2::HandlePaint()

 {
     HRGN                            hRgn = NULLHANDLE;
     wxPaintEvent                    vEvent;
 {
     HRGN                            hRgn = NULLHANDLE;
     wxPaintEvent                    vEvent;


@@ -3348,9 +3402,9 @@ bool wxWindow::HandlePaint()
         }
     }
     return (GetEventHandler()->ProcessEvent(vEvent));
         }
     }
     return (GetEventHandler()->ProcessEvent(vEvent));

-} // end of wxWindow::HandlePaint
+} // end of wxWindowOS2::HandlePaint

 
 

-bool wxWindow::HandleEraseBkgnd(
+bool wxWindowOS2::HandleEraseBkgnd(

   WXHDC                             hDC
 )
 {
   WXHDC                             hDC
 )
 {


@@ -3375,9 +3429,9 @@ bool wxWindow::HandleEraseBkgnd(
     vDC.EndDrawing();
     vDC.m_hPS = NULLHANDLE;
     return TRUE;
     vDC.EndDrawing();
     vDC.m_hPS = NULLHANDLE;
     return TRUE;

-} // end of wxWindow::HandleEraseBkgnd
+} // end of wxWindowOS2::HandleEraseBkgnd

 
 

-void wxWindow::OnEraseBackground(
+void wxWindowOS2::OnEraseBackground(

   wxEraseEvent&                     rEvent
 )
 {
   wxEraseEvent&                     rEvent
 )
 {


@@ -3386,29 +3440,29 @@ void wxWindow::OnEraseBackground(
 
     ::WinQueryWindowRect(GetHwnd(), &vRect);
     ::WinFillRect(hPS, &vRect,  m_backgroundColour.GetPixel());
 
     ::WinQueryWindowRect(GetHwnd(), &vRect);
     ::WinFillRect(hPS, &vRect,  m_backgroundColour.GetPixel());

-}  // end of wxWindow::OnEraseBackground
+}  // end of wxWindowOS2::OnEraseBackground

 
 // ---------------------------------------------------------------------------
 // moving and resizing
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // moving and resizing
 // ---------------------------------------------------------------------------
 

-bool wxWindow::HandleMinimize()
+bool wxWindowOS2::HandleMinimize()

 {
     wxIconizeEvent                  vEvent(m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 {
     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);
 {
     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
 )
   int                               nX
 , int                               nY
 )


@@ -3421,9 +3475,9 @@ bool wxWindow::HandleMove(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     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)
   int                               nWidth
 , int                               nHeight
 , WXUINT                            WXUNUSED(nFlag)


@@ -3437,9 +3491,9 @@ bool wxWindow::HandleSize(
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleSize
+} // end of wxWindowOS2::HandleSize

 
 

-bool wxWindow::HandleGetMinMaxInfo(
+bool wxWindowOS2::HandleGetMinMaxInfo(

   PSWP                              pSwp
 )
 {
   PSWP                              pSwp
 )
 {


@@ -3464,12 +3518,12 @@ bool wxWindow::HandleGetMinMaxInfo(
             return FALSE;
     }
     return TRUE;
             return FALSE;
     }
     return TRUE;

-} // end of wxWindow::HandleGetMinMaxInfo
+} // end of wxWindowOS2::HandleGetMinMaxInfo

 
 // ---------------------------------------------------------------------------
 // command messages
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // command messages
 // ---------------------------------------------------------------------------

-bool wxWindow::HandleCommand(
+bool wxWindowOS2::HandleCommand(

   WXWORD                            wId
 , WXWORD                            wCmd
 , WXHWND                            hControl
   WXWORD                            wId
 , WXWORD                            wCmd
 , WXHWND                            hControl


@@ -3495,9 +3549,9 @@ bool wxWindow::HandleCommand(
                                 ,wId
                                );
     return FALSE;
                                 ,wId
                                );
     return FALSE;

-} // end of wxWindow::HandleCommand
+} // end of wxWindowOS2::HandleCommand

 
 

-bool wxWindow::HandleSysCommand(
+bool wxWindowOS2::HandleSysCommand(

   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 )
   WXWPARAM                          wParam
 , WXLPARAM                          lParam
 )


@@ -3514,13 +3568,13 @@ bool wxWindow::HandleSysCommand(
             return HandleMinimize();
     }
     return FALSE;
             return HandleMinimize();
     }
     return FALSE;

-} // end of wxWindow::HandleSysCommand
+} // end of wxWindowOS2::HandleSysCommand

 
 // ---------------------------------------------------------------------------
 // mouse events
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // mouse events
 // ---------------------------------------------------------------------------
 

-void wxWindow::InitMouseEvent(
+void wxWindowOS2::InitMouseEvent(

   wxMouseEvent&                     rEvent
 , int                               nX
 , int                               nY
   wxMouseEvent&                     rEvent
 , int                               nX
 , int                               nY


@@ -3542,9 +3596,9 @@ void wxWindow::InitMouseEvent(
     m_lastMouseY = nY;
     m_lastMouseEvent = rEvent.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK
     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
   WXUINT                            uMsg
 , int                               nX
 , int                               nY


@@ -3580,9 +3634,9 @@ bool wxWindow::HandleMouseEvent(
                   );
 
     return GetEventHandler()->ProcessEvent(vEvent);
                   );
 
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::HandleMouseEvent
+} // end of wxWindowOS2::HandleMouseEvent

 
 

-bool wxWindow::HandleMouseMove(
+bool wxWindowOS2::HandleMouseMove(

   int                               nX
 , int                               nY
 , WXUINT                            uFlags
   int                               nX
 , int                               nY
 , WXUINT                            uFlags


@@ -3610,7 +3664,7 @@ bool wxWindow::HandleMouseMove(
                             ,nY
                             ,uFlags
                            );
                             ,nY
                             ,uFlags
                            );

-} // end of wxWindow::HandleMouseMove
+} // end of wxWindowOS2::HandleMouseMove

 
 // ---------------------------------------------------------------------------
 // keyboard handling
 
 // ---------------------------------------------------------------------------
 // keyboard handling


@@ -3620,7 +3674,7 @@ bool wxWindow::HandleMouseMove(
 // Create the key event of the given type for the given key - used by
 // HandleChar and HandleKeyDown/Up
 //
 // 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
   wxEventType                       eType
 , int                               nId
 , WXLPARAM                          lParam


@@ -3655,13 +3709,13 @@ wxKeyEvent wxWindow::CreateKeyEvent(
     vEvent.m_y = vPoint.y;
 
     return vEvent;
     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
 //
 
 //
 // 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
   WXWORD                            wParam
 , WXLPARAM                          lParam
 , bool                              isASCII


@@ -3725,7 +3779,7 @@ bool wxWindow::HandleChar(
     return FALSE;
 }
 
     return FALSE;
 }
 

-bool wxWindow::HandleKeyDown(
+bool wxWindowOS2::HandleKeyDown(

   WXWORD                            wParam
 , WXLPARAM                          lParam
 )
   WXWORD                            wParam
 , WXLPARAM                          lParam
 )


@@ -3753,9 +3807,9 @@ bool wxWindow::HandleKeyDown(
         }
     }
     return FALSE;
         }
     }
     return FALSE;

-} // end of wxWindow::HandleKeyDown
+} // end of wxWindowOS2::HandleKeyDown

 
 

-bool wxWindow::HandleKeyUp(
+bool wxWindowOS2::HandleKeyUp(

   WXWORD                            wParam
 , WXLPARAM                          lParam
 )
   WXWORD                            wParam
 , WXLPARAM                          lParam
 )


@@ -3781,7 +3835,7 @@ bool wxWindow::HandleKeyUp(
             return TRUE;
     }
     return FALSE;
             return TRUE;
     }
     return FALSE;

-} // end of wxWindow::HandleKeyUp
+} // end of wxWindowOS2::HandleKeyUp

 
 // ---------------------------------------------------------------------------
 // joystick
 
 // ---------------------------------------------------------------------------
 // joystick


@@ -3791,7 +3845,7 @@ bool wxWindow::HandleKeyUp(
 // scrolling
 // ---------------------------------------------------------------------------
 
 // scrolling
 // ---------------------------------------------------------------------------
 

-bool wxWindow::OS2OnScroll(
+bool wxWindowOS2::OS2OnScroll(

   int                               nOrientation
 , WXWORD                            wParam
 , WXWORD                            wPos
   int                               nOrientation
 , WXWORD                            wParam
 , WXWORD                            wPos


@@ -3846,7 +3900,7 @@ bool wxWindow::OS2OnScroll(
             return FALSE;
     }
     return GetEventHandler()->ProcessEvent(vEvent);
             return FALSE;
     }
     return GetEventHandler()->ProcessEvent(vEvent);

-} // end of wxWindow::OS2OnScroll
+} // end of wxWindowOS2::OS2OnScroll

 
 // ===========================================================================
 // global functions
 
 // ===========================================================================
 // global functions