]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/window.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
no message
[wxWidgets.git] / src / os2 / window.cpp
diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index 7673bf4463b8eb75b82eea82e4fae25bd5280735..088db7e071e2c3d31c0d602ff202ee0d7c1602a4 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -96,6 +96,11 @@ MRESULT wxWndProc( HWND hWnd
                   ,MPARAM mp1
                   ,MPARAM mp2
                  );
                   ,MPARAM mp1
                   ,MPARAM mp2
                  );
+
+#ifdef  __WXDEBUG__
+    const char *wxGetMessageName(int message);
+#endif  //__WXDEBUG__
+
 void wxRemoveHandleAssociation(wxWindow *win);
 void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
 void wxRemoveHandleAssociation(wxWindow *win);
 void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
@@ -104,9 +109,7 @@ wxWindow *wxFindWinFromHandle(WXHWND hWnd);
 // event tables
 // ---------------------------------------------------------------------------
 
 // event tables
 // ---------------------------------------------------------------------------
 
-#if !USE_SHARED_LIBRARY
     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
-#endif
 
 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
 
 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
@@ -119,71 +122,81 @@ END_EVENT_TABLE()
 // implementation
 // ===========================================================================
 
 // implementation
 // ===========================================================================
 
-// Find an item given the MS Windows id
-wxWindow *wxWindow::FindItem(long id) const
+// Find an item given the PM Window id
+wxWindow* wxWindow::FindItem(
+  long                              ulId
+) const
 {
 {
-    wxWindowList::Node *current = GetChildren().GetFirst();
-    while (current)
+    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
+
+    while (pCurrent)
     {
     {
-        wxWindow *childWin = current->GetData();
+        wxWindow*                   pChildWin = pCurrent->GetData();
+        wxWindow*                   pWnd = pChildWin->FindItem(ulId);
 
 
-        wxWindow *wnd = childWin->FindItem(id);
-        if ( wnd )
-            return wnd;
+        if (pWnd)
+            return pWnd;
 
 
-        if ( childWin->IsKindOf(CLASSINFO(wxControl)) )
+        if (pChildWin->IsKindOf(CLASSINFO(wxControl)))
         {
         {
-            wxControl *item = (wxControl *)childWin;
-            if ( item->GetId() == id )
-                return item;
+            wxControl*              pItem = (wxControl *)pChildWin;
+
+            if (pItem->GetId() == ulId)
+                return(pItem);
             else
             {
                 // In case it's a 'virtual' control (e.g. radiobox)
             else
             {
                 // In case it's a 'virtual' control (e.g. radiobox)
-                if ( item->GetSubcontrols().Member((wxObject *)id) )
-                    return item;
+                if (pItem->GetSubcontrols().Member((wxObject *)ulId))
+                    return(pItem);
             }
         }
             }
         }
-
-        current = current->GetNext();
+        pCurrent = pCurrent->GetNext();
     }
     }
-
-    return NULL;
+    return(NULL);
 }
 
 }
 
-// Find an item given the MS Windows handle
-wxWindow *wxWindow::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
+// Find an item given the PM Window handle
+wxWindow* wxWindow::FindItemByHWND(
+  WXHWND                            hWnd
+, bool                              bControlOnly
+) const
 {
 {
-    wxWindowList::Node *current = GetChildren().GetFirst();
-    while (current)
+    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
+
+    while (pCurrent)
     {
     {
-        wxWindow *parent = current->GetData();
+        wxWindow*                   pParent = pCurrent->GetData();
 
         // Do a recursive search.
 
         // Do a recursive search.
-        wxWindow *wnd = parent->FindItemByHWND(hWnd);
-        if ( wnd )
-            return wnd;
+        wxWindow*                   pWnd = pParent->FindItemByHWND(hWnd);
+
+        if (pWnd)
+            return(pWnd);
 
 
-        if ( !controlOnly || parent->IsKindOf(CLASSINFO(wxControl)) )
+        if (!bControlOnly || pParent->IsKindOf(CLASSINFO(wxControl)))
         {
         {
-            wxWindow *item = current->GetData();
-            if ( item->GetHWND() == hWnd )
-                return item;
+            wxWindow*               pItem = pCurrent->GetData();
+
+            if (pItem->GetHWND() == hWnd)
+                return(pItem);
             else
             {
             else
             {
-                if ( item->ContainsHWND(hWnd) )
-                    return item;
+                if (pItem->ContainsHWND(hWnd))
+                    return(pItem);
             }
         }
             }
         }
-
-        current = current->GetNext();
+        pCurrent = pCurrent->GetNext();
     }
     }
-    return NULL;
+    return(NULL);
 }
 
 // Default command handler
 }
 
 // Default command handler
-bool wxWindow::OS2Command(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
+bool wxWindow::OS2Command(
+  WXUINT                            WXUNUSED(uParam)
+, WXWORD                            WXUNUSED(uId)
+)
 {
 {
-    return FALSE;
+    return(FALSE);
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -196,13 +209,13 @@ void wxWindow::Init()
     InitBase();
 
     // PM specific
     InitBase();
 
     // PM specific
-    m_doubleClickAllowed = 0;
-    m_winCaptured = FALSE;
+    m_bDoubleClickAllowed = 0;
+    m_bWinCaptured = FALSE;
 
     m_isBeingDeleted = FALSE;
 
     m_isBeingDeleted = FALSE;
-    m_oldWndProc = 0;
-    m_useCtl3D = FALSE;
-    m_mouseInWindow = FALSE;
+    m_fnOldWndProc = 0;
+    m_bUseCtl3D = FALSE;
+    m_bMouseInWindow = FALSE;
 
     // wxWnd
     m_hMenu = 0;
 
     // wxWnd
     m_hMenu = 0;
@@ -212,17 +225,17 @@ void wxWindow::Init()
     // pass WM_GETDLGCODE to DefWindowProc()
     m_lDlgCode = 0;
 
     // pass WM_GETDLGCODE to DefWindowProc()
     m_lDlgCode = 0;
 
-    m_xThumbSize = 0;
-    m_yThumbSize = 0;
-    m_backgroundTransparent = FALSE;
+    m_nXThumbSize = 0;
+    m_nYThumbSize = 0;
+    m_bBackgroundTransparent = FALSE;
 
     // as all windows are created with WS_VISIBLE style...
     m_isShown = TRUE;
 
 #if wxUSE_MOUSEEVENT_HACK
 
     // as all windows are created with WS_VISIBLE style...
     m_isShown = TRUE;
 
 #if wxUSE_MOUSEEVENT_HACK
-    m_lastMouseX =
-    m_lastMouseY = -1;
-    m_lastMouseEvent = -1;
+    m_lLastMouseX =
+    m_lLastMouseY = -1;
+    m_nLastMouseEvent = -1;
 #endif // wxUSE_MOUSEEVENT_HACK
 }
 
 #endif // wxUSE_MOUSEEVENT_HACK
 }
 
@@ -245,25 +258,47 @@ wxWindow::~wxWindow()
     }
 }
 
     }
 }
 
-bool wxWindow::Create(wxWindow *parent, wxWindowID id,
-                      const wxPoint& pos,
-                      const wxSize& size,
-                      long style,
-                      const wxString& name)
-{
-    wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
-
-    if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
-        return FALSE;
-
-    parent->AddChild(this);
-
-    // TODO: PM Specific initialization
-    OS2Create(m_windowId, parent, wxCanvasClassName, this, NULL,
-              pos.x, pos.y,
-              WidthDefault(size.x), HeightDefault(size.y),
-              msflags, NULL, exStyle);
-    return TRUE;
+bool wxWindow::Create(
+  wxWindow*                         pParent
+, wxWindowID                        vId
+, const wxPoint&                    rPos
+, const wxSize&                     rSize
+, long                              lStyle
+, const wxString&                   rName
+)
+{
+    wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
+
+    if ( !CreateBase( pParent
+                     ,vId
+                     ,rPos
+                     ,rSize
+                     ,lStyle
+                     ,wxDefaultValidator
+                     ,rName
+                    ))
+        return(FALSE);
+
+    pParent->AddChild(this);
+
+    bool                            bWant3D;
+    WXDWORD                         dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
+    DWORD                           ulFlags = 0L;
+
+    OS2Create( m_windowId
+              ,pParent
+              ,wxCanvasClassName
+              ,this
+              ,NULL
+              ,rPos.x
+              ,rPos.y
+              ,WidthDefault(rSize.x)
+              ,HeightDefault(rSize.y)
+              ,ulFlags
+              ,NULL
+              ,dwExStyle
+             );
+    return(TRUE);
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------
@@ -272,41 +307,80 @@ bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 
 void wxWindow::SetFocus()
 {
 
 void wxWindow::SetFocus()
 {
-    // TODO:
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd)
+        ::WinSetFocus(HWND_DESKTOP, hWnd);
 }
 
 }
 
-wxWindow* wxWindow::FindFocus()
+wxWindow* wxWindowBase::FindFocus()
 {
 {
-    wxWindow*                       window = NULL;
-    // TODO:
-    return(window);
+    HWND                            hWnd = ::WinQueryFocus(HWND_DESKTOP);
+
+    if (hWnd)
+    {
+        return wxFindWinFromHandle((WXHWND)hWnd);
+    }
+    return NULL;
 }
 
 }
 
-bool wxWindow::Enable(bool enable) // check if base implementation is OK
+bool wxWindow::Enable(
+  bool                              bEnable
+)
 {
 {
-    // TODO:
+    if (!wxWindowBase::Enable(bEnable))
+        return(FALSE);
+
+    HWND                            hWnd = GetHwnd();
+
+    if ( hWnd )
+        ::WinEnableWindow(hWnd, (BOOL)bEnable);
+
+    wxWindowList::Node*             pNode = GetChildren().GetFirst();
+
+    while (pNode)
+    {
+        wxWindow*                   pChild = pNode->GetData();
+
+        pChild->Enable(bEnable);
+        pNode = pNode->GetNext();
+    }
     return(TRUE);
 }
 
     return(TRUE);
 }
 
-bool wxWindow::Show(bool show) // check if base implementation is OK
+bool wxWindow::Show(
+  bool                              bShow
+)
 {
 {
-    // TODO:
+    if (!wxWindowBase::Show(bShow))
+        return(FALSE);
+
+    HWND                            hWnd = GetHwnd();
+
+    ::WinShowWindow(hWnd, bShow);
+
+    if (bShow)
+    {
+        ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
+    }
     return(TRUE);
 }
 
 void wxWindow::Raise()
 {
     return(TRUE);
 }
 
 void wxWindow::Raise()
 {
-    // TODO:
+    ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ACTIVATE);
 }
 
 void wxWindow::Lower()
 {
 }
 
 void wxWindow::Lower()
 {
-    // TODO:
+    ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_DEACTIVATE);
 }
 
 }
 
-void wxWindow::SetTitle( const wxString& title)
+void wxWindow::SetTitle(
+  const wxString&                   rTitle
+)
 {
 {
-    SetWindowText(GetHwnd(), title.c_str());
+    ::WinSetWindowText(GetHwnd(), rTitle.c_str());
 }
 
 wxString wxWindow::GetTitle() const
 }
 
 wxString wxWindow::GetTitle() const
@@ -316,24 +390,77 @@ wxString wxWindow::GetTitle() const
 
 void wxWindow::CaptureMouse()
 {
 
 void wxWindow::CaptureMouse()
 {
-    // TODO:
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd && !m_bWinCaptured)
+    {
+        ::WinSetCapture(HWND_DESKTOP, hWnd);
+        m_bWinCaptured = TRUE;
+    }
 }
 
 void wxWindow::ReleaseMouse()
 {
 }
 
 void wxWindow::ReleaseMouse()
 {
-    // TODO:
+    if ( m_bWinCaptured )
+    {
+        ::WinSetCapture(HWND_DESKTOP, NULLHANDLE);
+        m_bWinCaptured = FALSE;
+    }
 }
 
 }
 
-bool wxWindow::SetFont(const wxFont& f)
+bool wxWindow::SetFont(
+  const wxFont&                     rFont
+)
 {
 {
-    // TODO:
+    if (!wxWindowBase::SetFont(rFont))
+    {
+        // nothing to do
+        return(FALSE);
+    }
+
+    HWND                            hWnd = GetHwnd();
+
+    if (hWnd != 0)
+    {
+        wxChar                      zFont[128];
+
+        sprintf(zFont, "%d.%s", rFont.GetPointSize(), rFont.GetFaceName().c_str());
+        return(::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont), (PVOID)zFont));
+    }
     return(TRUE);
 }
 
     return(TRUE);
 }
 
-bool wxWindow::SetCursor(const wxCursor& cursor) // check if base implementation is OK
+bool wxWindow::SetCursor(
+  const wxCursor&                   rCursor
+) // check if base implementation is OK
 {
 {
-    // TODO:
-    return(TRUE);
+    if ( !wxWindowBase::SetCursor(rCursor))
+    {
+        // no change
+        return FALSE;
+    }
+
+    wxASSERT_MSG( m_cursor.Ok(),
+                  wxT("cursor must be valid after call to the base version"));
+
+    HWND                            hWnd = GetHwnd();
+    POINTL                          vPoint;
+    RECTL                           vRect;
+    HPS                             hPS;
+    HRGN                            hRGN;
+
+    hPS = ::WinGetPS(hWnd);
+
+    ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
+    ::WinQueryWindowRect(hWnd, &vRect);
+
+    hRGN = ::GpiCreateRegion(hPS, 1L, &vRect);
+
+    if ((::GpiPtInRegion(hPS, hRGN, &vPoint) == PRGN_INSIDE) && !wxIsBusy())
+    {
+//        ::SetCursor((HCURSOR)m_cursor.GetHCURSOR());
+    }
+    return TRUE;
 }
 
 void wxWindow::WarpPointer(int x_pos, int y_pos)
 }
 
 void wxWindow::WarpPointer(int x_pos, int y_pos)
@@ -373,6 +500,7 @@ int  wxWindow::GetScrollPage(int orient) const
     // TODO:
     return(1);
 }
     // TODO:
     return(1);
 }
+#endif // WXWIN_COMPATIBILITY
 
 int  wxWindow::GetScrollPos(int orient) const
 {
 
 int  wxWindow::GetScrollPos(int orient) const
 {
@@ -424,7 +552,7 @@ void wxWindow::ScrollWindow( int           dx
 
 void wxWindow::SubclassWin(WXHWND hWnd)
 {
 
 void wxWindow::SubclassWin(WXHWND hWnd)
 {
-    wxASSERT_MSG( !m_oldWndProc, wxT("subclassing window twice?") );
+    wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
 
     HWND hwnd = (HWND)hWnd;
 /*
 
     HWND hwnd = (HWND)hWnd;
 /*
@@ -493,7 +621,7 @@ WXDWORD wxWindow::MakeExtendedStyle(long style, bool eliminateBorders)
 WXDWORD wxWindow::Determine3DEffects(WXDWORD defaultBorderStyle,
                                      bool *want3D) const
 {
 WXDWORD wxWindow::Determine3DEffects(WXDWORD defaultBorderStyle,
                                      bool *want3D) const
 {
-   DWORD exStyle; // remove after implementation doe
+   DWORD exStyle = 0L; // remove after implementation doe
 /* TODO:  this ought to be fun
 *
     // If matches certain criteria, then assume no 3D effects
 /* TODO:  this ought to be fun
 *
     // If matches certain criteria, then assume no 3D effects
@@ -684,12 +812,6 @@ void wxWindow::DoSetSize(int x, int y,
     // TODO:
 }
 
     // TODO:
 }
 
-// for a generic window there is no natural best size - just use the current one
-wxSize wxWindow::DoGetBestSize()
-{
-    return GetSize();
-}
-
 void wxWindow::DoSetClientSize(int width, int height)
 {
     // TODO:
 void wxWindow::DoSetClientSize(int width, int height)
 {
     // TODO:
@@ -831,7 +953,7 @@ void wxWindow::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
 void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
                               WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
 {
 void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
                               WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
 {
-    *nCtlColor = CTLCOLOR_BTN;
+    *nCtlColor = 0; // TODO: CTLCOLOR_BTN;
     *hwnd = (WXHWND)lParam;
     *hdc = (WXHDC)wParam;
 }
     *hwnd = (WXHWND)lParam;
     *hdc = (WXHDC)wParam;
 }
@@ -839,7 +961,7 @@ void wxWindow::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
 void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
 {
 void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
                                 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
 {
-    *item = (WXWORD)wParam;
+    *item = (WXWORD)LOWORD(wParam);
     *flags = HIWORD(wParam);
     *hmenu = (WXHMENU)lParam;
 }
     *flags = HIWORD(wParam);
     *hmenu = (WXHMENU)lParam;
 }
@@ -853,7 +975,7 @@ void wxWindow::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
 wxWindow *wxWndHook = NULL;
 
 // Main window proc
 wxWindow *wxWndHook = NULL;
 
 // Main window proc
-MRESULT wxWndProc(HWND hWnd, UINT message, MPARAM wParam, MPARAM lParam)
+MRESULT wxWndProc(HWND hWnd, ULONG message, MPARAM wParam, MPARAM lParam)
 {
     // trace all messages - useful for the debugging
 #ifdef __WXDEBUG__
 {
     // trace all messages - useful for the debugging
 #ifdef __WXDEBUG__
@@ -886,7 +1008,7 @@ MRESULT wxWndProc(HWND hWnd, UINT message, MPARAM wParam, MPARAM lParam)
     {
         // FIXME: why do we do this?
         wnd->SetHWND((WXHWND) hWnd);
     {
         // FIXME: why do we do this?
         wnd->SetHWND((WXHWND) hWnd);
-        rc = wnd->OS2DefWindowProc(message, wParam, lParam );
+        rc = wnd->OS2DefWindowProc(hWnd, message, wParam, lParam );
         wnd->SetHWND(0);
     }
     else
         wnd->SetHWND(0);
     }
     else
@@ -894,7 +1016,7 @@ MRESULT wxWndProc(HWND hWnd, UINT message, MPARAM wParam, MPARAM lParam)
         if ( wnd )
             rc = wnd->OS2WindowProc(hWnd, message, wParam, lParam);
         else
         if ( wnd )
             rc = wnd->OS2WindowProc(hWnd, message, wParam, lParam);
         else
-            rc = DefWindowProc( hWnd, message, wParam, lParam );
+            rc = 0; //TODO: DefWindowProc( hWnd, message, wParam, lParam );
     }
 
     return rc;
     }
 
     return rc;
@@ -1249,11 +1371,11 @@ MRESULT wxWindow::OS2WindowProc(HWND hWnd, WXUINT message, WXWPARAM wParam, WXLP
         rc.result = MSWDefWindowProc(message, wParam, lParam);
     }
 */
         rc.result = MSWDefWindowProc(message, wParam, lParam);
     }
 */
-    return rc.result;
+    return (MRESULT)0;
 }
 
 // Dialog window proc
 }
 
 // Dialog window proc
-MRESULT wxDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+MRESULT wxDlgProc(HWND hWnd, UINT message, MPARAM wParam, MPARAM lParam)
 {
    // TODO:
 /*
 {
    // TODO:
 /*
@@ -1273,7 +1395,6 @@ MRESULT wxDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
     return (MRESULT)0;
 }
 
     return (MRESULT)0;
 }
 
-wxList *wxWinHandleList = NULL;
 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
 {
     wxNode *node = wxWinHandleList->Find((long)hWnd);
 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
 {
     wxNode *node = wxWinHandleList->Find((long)hWnd);
@@ -1551,7 +1672,7 @@ bool wxWindow::HandleDestroy()
 #if wxUSE_DRAG_AND_DROP
     if ( m_dropTarget != NULL )
     {
 #if wxUSE_DRAG_AND_DROP
     if ( m_dropTarget != NULL )
     {
-        m_dropTarget->Revoke(m_hWnd);
+//        m_dropTarget->Revoke(m_hWnd);
 
         delete m_dropTarget;
         m_dropTarget = NULL;
 
         delete m_dropTarget;
         m_dropTarget = NULL;
@@ -1570,12 +1691,16 @@ bool wxWindow::HandleActivate(int state,
                               bool WXUNUSED(minimized),
                               WXHWND WXUNUSED(activate))
 {
                               bool WXUNUSED(minimized),
                               WXHWND WXUNUSED(activate))
 {
+    // TODO:
+    /*
     wxActivateEvent event(wxEVT_ACTIVATE,
                           (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
                           m_windowId);
     event.SetEventObject(this);
 
     return GetEventHandler()->ProcessEvent(event);
     wxActivateEvent event(wxEVT_ACTIVATE,
                           (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
                           m_windowId);
     event.SetEventObject(this);
 
     return GetEventHandler()->ProcessEvent(event);
+    */
+    return FALSE;
 }
 
 bool wxWindow::HandleSetFocus(WXHWND WXUNUSED(hwnd))
 }
 
 bool wxWindow::HandleSetFocus(WXHWND WXUNUSED(hwnd))
@@ -1654,6 +1779,8 @@ bool wxWindow::HandleSetCursor(WXHWND hWnd,
     if ( GetHWND() == hWnd )
     {
         // don't set cursor when the mouse is not in the client part
     if ( GetHWND() == hWnd )
     {
         // don't set cursor when the mouse is not in the client part
+// TODO
+/*
         if ( nHitTest == HTCLIENT || nHitTest == HTERROR )
         {
             HCURSOR hcursor = 0;
         if ( nHitTest == HTCLIENT || nHitTest == HTERROR )
         {
             HCURSOR hcursor = 0;
@@ -1692,6 +1819,7 @@ bool wxWindow::HandleSetCursor(WXHWND hWnd,
                 return TRUE;
             }
         }
                 return TRUE;
             }
         }
+*/
     }
 
     return FALSE;
     }
 
     return FALSE;
@@ -1701,7 +1829,7 @@ bool wxWindow::HandleSetCursor(WXHWND hWnd,
 // owner drawn stuff
 // ---------------------------------------------------------------------------
 
 // owner drawn stuff
 // ---------------------------------------------------------------------------
 
-bool wxWindow::MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
+bool wxWindow::OS2OnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
 {
    // TODO:
 /*
 {
    // TODO:
 /*
@@ -1789,7 +1917,8 @@ bool wxWindow::HandleCtlColor(WXHBRUSH *brush,
                               WXLPARAM lParam)
 {
     WXHBRUSH hBrush = 0;
                               WXLPARAM lParam)
 {
     WXHBRUSH hBrush = 0;
-
+// TODO:
+/*
     if ( nCtlColor == CTLCOLOR_DLG )
     {
         hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
     if ( nCtlColor == CTLCOLOR_DLG )
     {
         hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
@@ -1805,6 +1934,8 @@ bool wxWindow::HandleCtlColor(WXHBRUSH *brush,
         *brush = hBrush;
 
     return hBrush != 0;
         *brush = hBrush;
 
     return hBrush != 0;
+*/
+    return FALSE;
 }
 
 // Define for each class of dialog and control
 }
 
 // Define for each class of dialog and control
@@ -1861,14 +1992,14 @@ void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 bool wxWindow::HandlePaint()
 {
    // TODO:
 bool wxWindow::HandlePaint()
 {
    // TODO:
-   Return FALSE;
+   return FALSE;
 }
 
 bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
 {
     // Prevents flicker when dragging
 }
 
 bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
 {
     // Prevents flicker when dragging
-    if ( ::IsIconic(GetHwnd()) )
-        return TRUE;
+//  if ( ::IsIconic(GetHwnd()) )
+//      return TRUE;
 
     wxDC dc;
 
 
     wxDC dc;
 
@@ -1930,6 +2061,8 @@ bool wxWindow::HandleSize(int w, int h, WXUINT WXUNUSED(flag))
 
 bool wxWindow::HandleGetMinMaxInfo(void *mmInfo)
 {
 
 bool wxWindow::HandleGetMinMaxInfo(void *mmInfo)
 {
+// TODO:
+/*
     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
 
     bool rc = FALSE;
     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
 
     bool rc = FALSE;
@@ -1959,6 +2092,8 @@ bool wxWindow::HandleGetMinMaxInfo(void *mmInfo)
     }
 
     return rc;
     }
 
     return rc;
+*/
+    return FALSE;
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------
@@ -1972,7 +2107,7 @@ bool wxWindow::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
         wxMenu *popupMenu = wxCurrentPopupMenu;
         wxCurrentPopupMenu = NULL;
 
         wxMenu *popupMenu = wxCurrentPopupMenu;
         wxCurrentPopupMenu = NULL;
 
-        return popupMenu->MSWCommand(cmd, id);
+        return popupMenu->OS2Command(cmd, id);
     }
 
     wxWindow *win = FindItem(id);
     }
 
     wxWindow *win = FindItem(id);
@@ -1982,7 +2117,7 @@ bool wxWindow::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
     }
 
     if ( win )
     }
 
     if ( win )
-        return win->MSWCommand(cmd, id);
+        return win->OS2Command(cmd, id);
 
     return FALSE;
 }
 
     return FALSE;
 }
@@ -1999,6 +2134,8 @@ bool wxWindow::HandleSysCommand(WXWPARAM wParam, WXLPARAM lParam)
 
 void wxWindow::InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags)
 {
 
 void wxWindow::InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags)
 {
+// TODO:
+/*
     event.m_x = x;
     event.m_y = y;
     event.m_shiftDown = ((flags & MK_SHIFT) != 0);
     event.m_x = x;
     event.m_y = y;
     event.m_shiftDown = ((flags & MK_SHIFT) != 0);
@@ -2014,7 +2151,7 @@ void wxWindow::InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags)
     m_lastMouseY = y;
     m_lastMouseEvent = event.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK
     m_lastMouseY = y;
     m_lastMouseEvent = event.GetEventType();
 #endif // wxUSE_MOUSEEVENT_HACK
-
+*/
 }
 
 bool wxWindow::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
 }
 
 bool wxWindow::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
@@ -2045,10 +2182,10 @@ bool wxWindow::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
 
 bool wxWindow::HandleMouseMove(int x, int y, WXUINT flags)
 {
 
 bool wxWindow::HandleMouseMove(int x, int y, WXUINT flags)
 {
-    if ( !m_mouseInWindow )
+    if ( !m_bMouseInWindow )
     {
         // Generate an ENTER event
     {
         // Generate an ENTER event
-        m_mouseInWindow = TRUE;
+        m_bMouseInWindow = TRUE;
 
         wxMouseEvent event(wxEVT_ENTER_WINDOW);
         InitMouseEvent(event, x, y, flags);
 
         wxMouseEvent event(wxEVT_ENTER_WINDOW);
         InitMouseEvent(event, x, y, flags);
@@ -2119,7 +2256,7 @@ bool wxWindow::OS2OnScroll(int orientation, WXWORD wParam,
     {
         wxWindow *child = wxFindWinFromHandle(control);
         if ( child )
     {
         wxWindow *child = wxFindWinFromHandle(control);
         if ( child )
-            return child->MSWOnScroll(orientation, wParam, pos, control);
+            return child->OS2OnScroll(orientation, wParam, pos, control);
     }
 
     wxScrollWinEvent event;
     }
 
     wxScrollWinEvent event;
@@ -2311,8 +2448,8 @@ wxWindow *wxGetActiveWindow()
 
 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
 // in active frames and dialogs, regardless of where the focus is.
 
 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
 // in active frames and dialogs, regardless of where the focus is.
-static HHOOK wxTheKeyboardHook = 0;
-static FARPROC wxTheKeyboardHookProc = 0;
+//static HHOOK wxTheKeyboardHook = 0;
+//static FARPROC wxTheKeyboardHookProc = 0;
 int wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
 
 void wxSetKeyboardHook(bool doIt)
 int wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
 
 void wxSetKeyboardHook(bool doIt)
@@ -2749,3 +2886,5 @@ const char *wxGetMessageName(int message)
    return NULL;
 }
 
    return NULL;
 }
 
+#endif // __WXDEBUG__
+
wxWidgets (Impactor)