]> 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
Tried to restore wxPopupTransientWindow functionality
[wxWidgets.git] / src / os2 / window.cpp
diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index ce34797831607c4a650dbb6e9572c1e65aba87b1..9c096f077df6e889305076466ac3550772c789b4 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -27,13 +27,17 @@
     #include "wx/app.h"
     #include "wx/panel.h"
     #include "wx/layout.h"
     #include "wx/app.h"
     #include "wx/panel.h"
     #include "wx/layout.h"
+    #include "wx/checkbox.h"
+    #include "wx/combobox.h"
     #include "wx/dialog.h"
     #include "wx/frame.h"
     #include "wx/listbox.h"
     #include "wx/button.h"
     #include "wx/dialog.h"
     #include "wx/frame.h"
     #include "wx/listbox.h"
     #include "wx/button.h"
+    #include "wx/bmpbuttn.h"
     #include "wx/msgdlg.h"
     #include "wx/scrolwin.h"
     #include "wx/radiobox.h"
     #include "wx/msgdlg.h"
     #include "wx/scrolwin.h"
     #include "wx/radiobox.h"
+    #include "wx/radiobut.h"
     #include "wx/slider.h"
     #include "wx/statbox.h"
     #include "wx/statusbr.h"
     #include "wx/slider.h"
     #include "wx/statbox.h"
     #include "wx/statusbr.h"
@@ -124,8 +128,6 @@ QMSG                      s_currentMsg;
 wxMenu*                   wxCurrentPopupMenu = NULL;
 #endif // wxUSE_MENUS_NATIVE
 
 wxMenu*                   wxCurrentPopupMenu = NULL;
 #endif // wxUSE_MENUS_NATIVE
 
-wxList*                   wxWinHandleList = NULL;
-
 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // private functions
 // ---------------------------------------------------------------------------
@@ -176,7 +178,6 @@ static wxWindow*                    gpWinBeingCreated = NULL;
 BEGIN_EVENT_TABLE(wxWindowOS2, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindowOS2::OnEraseBackground)
     EVT_SYS_COLOUR_CHANGED(wxWindowOS2::OnSysColourChanged)
 BEGIN_EVENT_TABLE(wxWindowOS2, wxWindowBase)
     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()
     EVT_IDLE(wxWindowOS2::OnIdle)
     EVT_SET_FOCUS(wxWindowOS2::OnSetFocus)
 END_EVENT_TABLE()
@@ -215,17 +216,17 @@ wxWindow* wxWindowOS2::FindItem(
     }
 #endif // wxUSE_CONTROLS
 
     }
 #endif // wxUSE_CONTROLS
 
-    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
+    wxWindowList::compatibility_iterator  current = GetChildren().GetFirst();
 
 
-    while (pCurrent)
+    while (current)
     {
     {
-        wxWindow*                   pChildWin = pCurrent->GetData();
+        wxWindow*                   pChildWin = current->GetData();
         wxWindow*                   pWnd = pChildWin->FindItem(lId);
 
         if (pWnd)
             return pWnd;
 
         wxWindow*                   pWnd = pChildWin->FindItem(lId);
 
         if (pWnd)
             return pWnd;
 
-        pCurrent = pCurrent->GetNext();
+        current = current->GetNext();
     }
     return(NULL);
 } // end of wxWindowOS2::FindItem
     }
     return(NULL);
 } // end of wxWindowOS2::FindItem
@@ -238,11 +239,11 @@ wxWindow* wxWindowOS2::FindItemByHWND(
 , bool                              bControlOnly
 ) const
 {
 , bool                              bControlOnly
 ) const
 {
-    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
+    wxWindowList::compatibility_iterator current = GetChildren().GetFirst();
 
 
-    while (pCurrent)
+    while (current)
     {
     {
-        wxWindow*                   pParent = pCurrent->GetData();
+        wxWindow*                   pParent = current->GetData();
 
         //
         // Do a recursive search.
 
         //
         // Do a recursive search.
@@ -258,7 +259,7 @@ wxWindow* wxWindowOS2::FindItemByHWND(
 #endif // wxUSE_CONTROLS
             )
         {
 #endif // wxUSE_CONTROLS
             )
         {
-            wxWindow*               pItem = pCurrent->GetData();
+            wxWindow*               pItem = current->GetData();
 
             if (pItem->GetHWND() == hWnd)
                 return(pItem);
 
             if (pItem->GetHWND() == hWnd)
                 return(pItem);
@@ -268,7 +269,7 @@ wxWindow* wxWindowOS2::FindItemByHWND(
                     return(pItem);
             }
         }
                     return(pItem);
             }
         }
-        pCurrent = pCurrent->GetNext();
+        current = current->GetNext();
     }
     return(NULL);
 } // end of wxWindowOS2::FindItemByHWND
     }
     return(NULL);
 } // end of wxWindowOS2::FindItemByHWND
@@ -290,17 +291,11 @@ bool wxWindowOS2::OS2Command(
 
 void wxWindowOS2::Init()
 {
 
 void wxWindowOS2::Init()
 {
-    //
-    // Generic
-    //
-    InitBase();
-
     //
     // PM specific
     //
     m_bWinCaptured = FALSE;
 
     //
     // PM specific
     //
     m_bWinCaptured = FALSE;
 
-    m_isBeingDeleted        = FALSE;
     m_fnOldWndProc          = NULL;
     m_bUseCtl3D             = FALSE;
     m_bMouseInWindow        = FALSE;
     m_fnOldWndProc          = NULL;
     m_bUseCtl3D             = FALSE;
     m_bMouseInWindow        = FALSE;
@@ -358,9 +353,6 @@ wxWindowOS2::~wxWindowOS2()
 
     DestroyChildren();
 
 
     DestroyChildren();
 
-    if (m_parent)
-        m_parent->RemoveChild(this);
-
     if (m_hWnd)
     {
         if(!::WinDestroyWindow(GetHWND()))
     if (m_hWnd)
     {
         if(!::WinDestroyWindow(GetHWND()))
@@ -414,8 +406,6 @@ bool wxWindowOS2::Create(
 
     if (pParent)
     {
 
     if (pParent)
     {
-        int                         nTempy;
-
         pParent->AddChild(this);
         hParent = GetWinHwnd(pParent);
 
         pParent->AddChild(this);
         hParent = GetWinHwnd(pParent);
 
@@ -483,7 +473,7 @@ void wxWindowOS2::SetFocusFromKbd()
     wxWindowBase::SetFocusFromKbd();
 } // end of wxWindowOS2::SetFocus
 
     wxWindowBase::SetFocusFromKbd();
 } // end of wxWindowOS2::SetFocus
 
-wxWindow* wxWindowBase::FindFocus()
+wxWindow* wxWindowBase::DoFindFocus()
 {
     HWND                            hWnd = ::WinQueryFocus(HWND_DESKTOP);
 
 {
     HWND                            hWnd = ::WinQueryFocus(HWND_DESKTOP);
 
@@ -492,7 +482,7 @@ wxWindow* wxWindowBase::FindFocus()
         return wxFindWinFromHandle((WXHWND)hWnd);
     }
     return NULL;
         return wxFindWinFromHandle((WXHWND)hWnd);
     }
     return NULL;
-} // wxWindowBase::FindFocus
+} // wxWindowBase::DoFindFocus
 
 bool wxWindowOS2::Enable(
   bool                              bEnable
 
 bool wxWindowOS2::Enable(
   bool                              bEnable
@@ -506,11 +496,19 @@ bool wxWindowOS2::Enable(
     if ( hWnd )
         ::WinEnableWindow(hWnd, (BOOL)bEnable);
 
     if ( hWnd )
         ::WinEnableWindow(hWnd, (BOOL)bEnable);
 
-    wxWindowList::Node*             pNode = GetChildren().GetFirst();
+    //
+    // The logic below doesn't apply to the top level windows -- otherwise
+    // showing a modal dialog would result in total greying out (and ungreying
+    // out later) of everything which would be really ugly
+    //
+    if (IsTopLevel())
+        return TRUE;
 
 
-    while (pNode)
+    wxWindowList::compatibility_iterator     node = GetChildren().GetFirst();
+
+    while (node)
     {
     {
-        wxWindow*                   pChild = pNode->GetData();
+        wxWindow*                   pChild = node->GetData();
 
         if (bEnable)
         {
 
         if (bEnable)
         {
@@ -540,7 +538,7 @@ bool wxWindowOS2::Enable(
                 m_pChildrenDisabled->Append(pChild);
             }
         }
                 m_pChildrenDisabled->Append(pChild);
             }
         }
-        pNode = pNode->GetNext();
+        node = node->GetNext();
     }
     if (bEnable && m_pChildrenDisabled)
     {
     }
     if (bEnable && m_pChildrenDisabled)
     {
@@ -679,81 +677,11 @@ void wxWindowOS2::WarpPointer(
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
 } // end of wxWindowOS2::WarpPointer
 
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
 } // end of wxWindowOS2::WarpPointer
 
-#if WXWIN_COMPATIBILITY
-void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const
-{
-}
-#endif // WXWIN_COMPATIBILITY
 
 // ---------------------------------------------------------------------------
 // scrolling stuff
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // scrolling stuff
 // ---------------------------------------------------------------------------
 
-#if WXWIN_COMPATIBILITY
-void wxWindowOS2::SetScrollRange(
-  int                               nOrient
-, int                               nRange
-, bool                              bRefresh
-)
-{
-    int                             nRange1 = nRange;
-    int                             nPageSize = GetScrollPage(nOrient);
-
-    if (nPpageSize > 1 && nRange > 0)
-    {
-        nRange1 += (nPageSize - 1);
-    }
-
-    if (nOrient == wxHORIZONTAL)
-    {
-        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
-        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
-    }
-    else
-    {
-        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
-        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
-    }
-} // end of wxWindowOS2::SetScrollRange
-
-void wxWindowOS2::SetScrollPage(
-  int                               nOrient
-, int                               nPage
-, bool                              bRefresh
-)
-{
-    if (nOrient == wxHORIZONTAL )
-        m_nXThumbSize = nPage;
-    else
-        m_nYThumbSize = nPage;
-} // end of wxWindowOS2::SetScrollPage
-
-int wxWindowOS2::OldGetScrollRange(
-  int                               nOrient
-) const
-{
-    MRESULT                         mRc;
-    HWND                            hWnd = GetHwnd();
-
-    if (hWnd)
-    {
-        mRc = WinSendMsg(hWnd, SBM_QUERYRANGE, (MPARAM)0L, (MPARAM)0L);
-        return(SHORT2FROMMR(mRc));
-     }
-     return 0;
-} // end of wxWindowOS2::OldGetScrollRange
-
-int  wxWindowOS2::GetScrollPage(
-  int                               nOrient
-) const
-{
-    if (nOrient == wxHORIZONTAL)
-        return m_nXThumbSize;
-    else
-        return m_nYThumbSize;
-} // end of wxWindowOS2::GetScrollPage
-#endif // WXWIN_COMPATIBILITY
-
 int  wxWindowOS2::GetScrollPos(
   int                               nOrient
 ) const
 int  wxWindowOS2::GetScrollPos(
   int                               nOrient
 ) const
@@ -816,7 +744,6 @@ void wxWindowOS2::SetScrollbar(
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     SWP                             vSwp;
     SWP                             vSwpOwner;
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     SWP                             vSwp;
     SWP                             vSwpOwner;
-    RECTL                           vRect;
     HWND                            hWndParent;
     HWND                            hWndClient;
     wxWindow*                       pParent = GetParent();
     HWND                            hWndParent;
     HWND                            hWndClient;
     wxWindow*                       pParent = GetParent();
@@ -1008,20 +935,15 @@ void wxWindowOS2::ScrollWindow(
 )
 {
     RECTL                           vRect;
 )
 {
     RECTL                           vRect;
-    RECTL                           vRectHorz;
-    RECTL                           vRectVert;
-    RECTL                           vRectChild;
 
 
+    ::WinQueryWindowRect(GetHwnd(), &vRect);
+    int                             height = vRect.yTop;
     if (pRect)
     {
         vRect.xLeft   = pRect->x;
     if (pRect)
     {
         vRect.xLeft   = pRect->x;
-        vRect.yTop    = pRect->y + pRect->height;
+        vRect.yTop    = height - pRect->y;
         vRect.xRight  = pRect->x + pRect->width;
         vRect.xRight  = pRect->x + pRect->width;
-        vRect.yBottom = pRect->y;
-    }
-    else
-    {
-        ::WinQueryWindowRect(GetHwnd(), &vRect);
+        vRect.yBottom = vRect.yTop - pRect->height;
     }
     nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
     ::WinScrollWindow( GetHwnd()
     }
     nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
     ::WinScrollWindow( GetHwnd()
@@ -1029,11 +951,10 @@ void wxWindowOS2::ScrollWindow(
                       ,(LONG)nDy
                       ,&vRect
                       ,&vRect
                       ,(LONG)nDy
                       ,&vRect
                       ,&vRect
-                      ,NULLHANDLE
+                      ,NULL
                       ,NULL
                       ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
                      );
                       ,NULL
                       ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
                      );
-    Refresh();
 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
@@ -1160,7 +1081,7 @@ WXDWORD wxWindowOS2::OS2GetStyle(
 } // end of wxWindowMSW::MSWGetStyle
 
 //
 } // end of wxWindowMSW::MSWGetStyle
 
 //
-// Make a Windows extended style from the given wxWindows window style
+// Make a Windows extended style from the given wxWidgets window style
 //
 WXDWORD wxWindowOS2::MakeExtendedStyle(
   long                              lStyle
 //
 WXDWORD wxWindowOS2::MakeExtendedStyle(
   long                              lStyle
@@ -1190,118 +1111,6 @@ WXDWORD wxWindowOS2::MakeExtendedStyle(
     return dwStyle;
 } // end of wxWindowOS2::MakeExtendedStyle
 
     return dwStyle;
 } // 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.
-//
-WXDWORD wxWindowOS2::Determine3DEffects(
-  WXDWORD                           dwDefaultBorderStyle
-, bool*                             pbWant3D
-) const
-{
-    WXDWORD                         dwStyle = 0L;
-
-    //
-    // Native PM does not have any specialize 3D effects like WIN32 does,
-    // so we have to try and invent them.
-    //
-
-    //
-    // If matches certain criteria, then assume no 3D effects
-    // unless specifically requested (dealt with in MakeExtendedStyle)
-    //
-    if (!GetParent()                    ||
-        !IsKindOf(CLASSINFO(wxControl)) ||
-        (m_windowStyle & wxNO_BORDER)
-       )
-    {
-        *pbWant3D = FALSE;
-        return MakeExtendedStyle(m_windowStyle, FALSE);
-    }
-
-    //
-    // 1) App can specify global 3D effects
-    //
-    *pbWant3D = wxTheApp->GetAuto3D();
-
-    //
-    // 2) If the parent is being drawn with user colours, or simple border
-    //    specified, switch effects off.
-    //
-    if (GetParent() &&
-        (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) ||
-        (m_windowStyle & wxSIMPLE_BORDER)
-       )
-        *pbWant3D = FALSE;
-
-    //
-    // 3) Control can override this global setting by defining
-    //    a border style, e.g. wxSUNKEN_BORDER
-    //
-    if ((m_windowStyle & wxDOUBLE_BORDER) ||
-        (m_windowStyle & wxRAISED_BORDER) ||
-        (m_windowStyle & wxSTATIC_BORDER) ||
-        (m_windowStyle & wxSUNKEN_BORDER)
-       )
-        *pbWant3D = TRUE;
-
-    dwStyle = MakeExtendedStyle( m_windowStyle
-                                ,FALSE
-                               );
-
-    //
-    // If we want 3D, but haven't specified a border here,
-    // apply the default border style specified.
-    //
-    if (dwDefaultBorderStyle && (*pbWant3D) &&
-        !((m_windowStyle & wxDOUBLE_BORDER) ||
-          (m_windowStyle & wxRAISED_BORDER) ||
-          (m_windowStyle & wxSTATIC_BORDER) ||
-          (m_windowStyle & wxSIMPLE_BORDER)
-         )
-        )
-        dwStyle |= dwDefaultBorderStyle;
-    return dwStyle;
-} // end of wxWindowOS2::Determine3DEffects
-
-#if WXWIN_COMPATIBILITY
-void wxWindowOS2::OnCommand(
-  wxWindow&                         rWin
-, wxCommandEvent&                   rEvent
-)
-{
-    if (GetEventHandler()->ProcessEvent(rEvent))
-        return;
-    if (m_parent)
-        m_parent->GetEventHandler()->OnCommand( rWin
-                                               ,rEvent
-                                              );
-} // end of wxWindowOS2::OnCommand
-
-wxObject* wxWindowOS2::GetChild(
-  int                               nNumber
-) const
-{
-    //
-    // Return a pointer to the Nth object in the Panel
-    //
-    wxNode*                         pNode = GetChildren().First();
-    int                             n = nNumber;
-
-    while (pNode && n--)
-        pNode = pNode->Next();
-    if (pNode)
-    {
-        wxObject*                   pObj = (wxObject*)pNode->Data();
-        return(pObj);
-    }
-    else
-        return NULL;
-} // end of wxWindowOS2::GetChild
-
-#endif // WXWIN_COMPATIBILITY
-
 //
 // Setup background and foreground colours correctly
 //
 //
 // Setup background and foreground colours correctly
 //
@@ -1337,10 +1146,10 @@ void wxWindowOS2::OnIdle(
             //
             int                     nState = 0;
 
             //
             int                     nState = 0;
 
-            if (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) != 0)
-                nState |= VK_SHIFT;
-            if (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) != 0);
-                nState |= VK_CTRL;
+            if (IsShiftDown())
+                nState |= KC_SHIFT;
+            if (IsCtrlDown())
+                nState |= KC_CTRL;
 
             wxMouseEvent            rEvent(wxEVT_LEAVE_WINDOW);
 
 
             wxMouseEvent            rEvent(wxEVT_LEAVE_WINDOW);
 
@@ -1352,7 +1161,8 @@ void wxWindowOS2::OnIdle(
             (void)GetEventHandler()->ProcessEvent(rEvent);
         }
     }
             (void)GetEventHandler()->ProcessEvent(rEvent);
         }
     }
-    UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
 } // end of wxWindowOS2::OnIdle
 
 //
 } // end of wxWindowOS2::OnIdle
 
 //
@@ -1372,17 +1182,6 @@ bool wxWindowOS2::Reparent(
     return TRUE;
 } // end of wxWindowOS2::Reparent
 
     return TRUE;
 } // end of wxWindowOS2::Reparent
 
-void wxWindowOS2::Clear()
-{
-    wxClientDC                      vDc((wxWindow*)this);
-    wxBrush                         vBrush( GetBackgroundColour()
-                                           ,wxSOLID
-                                          );
-
-    vDc.SetBackground(vBrush);
-    vDc.Clear();
-} // end of wxWindowOS2::Clear
-
 void wxWindowOS2::Update()
 {
     ::WinUpdateWindow(GetHwnd());
 void wxWindowOS2::Update()
 {
     ::WinUpdateWindow(GetHwnd());
@@ -1416,11 +1215,14 @@ void wxWindowOS2::Refresh(
         if (pRect)
         {
             RECTL                   vOs2Rect;
         if (pRect)
         {
             RECTL                   vOs2Rect;
+            int                     height;
 
 
+            ::WinQueryWindowRect(GetHwnd(), &vOs2Rect);
+           height = vOs2Rect.yTop;
             vOs2Rect.xLeft   = pRect->x;
             vOs2Rect.xLeft   = pRect->x;
-            vOs2Rect.yTop    = pRect->y;
+            vOs2Rect.yTop    = height - pRect->y;
             vOs2Rect.xRight  = pRect->x + pRect->width;
             vOs2Rect.xRight  = pRect->x + pRect->width;
-            vOs2Rect.yBottom = pRect->y + pRect->height;
+            vOs2Rect.yBottom = vOs2Rect.yTop - pRect->height;
 
             ::WinInvalidateRect(hWnd, &vOs2Rect, bEraseBack);
         }
 
             ::WinInvalidateRect(hWnd, &vOs2Rect, bEraseBack);
         }
@@ -1442,14 +1244,7 @@ void wxWindowOS2::SetDropTarget(
   wxDropTarget*                     pDropTarget
 )
 {
   wxDropTarget*                     pDropTarget
 )
 {
-    if (m_dropTarget != 0)
-    {
-        m_dropTarget->Revoke(m_hWnd);
-        delete m_dropTarget;
-    }
     m_dropTarget = pDropTarget;
     m_dropTarget = pDropTarget;
-    if (m_dropTarget != 0)
-        m_dropTarget->Register(m_hWnd);
 } // end of wxWindowOS2::SetDropTarget
 #endif
 
 } // end of wxWindowOS2::SetDropTarget
 #endif
 
@@ -1673,9 +1468,18 @@ void wxWindowOS2::DoMoveWindow(
 )
 {
     RECTL                           vRect;
 )
 {
     RECTL                           vRect;
-    HWND                            hParent;
     wxWindow*                       pParent = GetParent();
 
     wxWindow*                       pParent = GetParent();
 
+    /* Due to OS/2's inverted coordinate system, changing the height
+       of a window requires repositioning all it's children, e.g. if
+       you want a child of height 100 to be at the top left corner of
+       the parent you need to position the lower left corner of the
+       child at (0, (height of parent - 100)), so, obviously, if the
+       height of the parent changes, the child needs to be repositioned. */
+    int                         nHeightDelta;
+    GetSize(0, &nHeightDelta);
+    nHeightDelta = nHeight - nHeightDelta;
+
     if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
     {
         int                         nOS2Height = GetOS2ParentHeight(pParent);
     if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
     {
         int                         nOS2Height = GetOS2ParentHeight(pParent);
@@ -1709,7 +1513,6 @@ void wxWindowOS2::DoMoveWindow(
         int                         nHeightFrameDelta = 0;
         int                         nHeightFrame = 0;
         int                         nWidthFrame = 0;
         int                         nHeightFrameDelta = 0;
         int                         nHeightFrame = 0;
         int                         nWidthFrame = 0;
-        ULONG                       ulFLag = SWP_MOVE;
         wxFrame*                    pFrame;
 
         pFrame = wxDynamicCast(this, wxFrame);
         wxFrame*                    pFrame;
 
         pFrame = wxDynamicCast(this, wxFrame);
@@ -1825,6 +1628,7 @@ void wxWindowOS2::DoMoveWindow(
         MoveChildren(nYDiff);
         ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
     }
         MoveChildren(nYDiff);
         ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
     }
+    MoveChildren(nHeightDelta);
 } // end of wxWindowOS2::DoMoveWindow
 
 //
 } // end of wxWindowOS2::DoMoveWindow
 
 //
@@ -1864,7 +1668,6 @@ void wxWindowOS2::DoSetSize(
     // Must convert Y coords to test for equality under OS/2
     //
     int                             nY2 = nY;
     // Must convert Y coords to test for equality under OS/2
     //
     int                             nY2 = nY;
-    wxWindow*                       pParent = (wxWindow*)GetParent();
 
     if (nX == nCurrentX && nY2 == nCurrentY &&
         nWidth == nCurrentWidth && nHeight == nCurrentHeight)
 
     if (nX == nCurrentX && nY2 == nCurrentY &&
         nWidth == nCurrentWidth && nHeight == nCurrentHeight)
@@ -2039,9 +1842,8 @@ void wxWindowOS2::GetTextExtent(
     int                             i;
     int                             l;
     FONTMETRICS                     vFM; // metrics structure
     int                             i;
     int                             l;
     FONTMETRICS                     vFM; // metrics structure
-    BOOL                            bRc;
+    BOOL                            bRc = FALSE;
     char*                           pStr;
     char*                           pStr;
-    ERRORID                         vErrorCode; // last error id code
     HPS                             hPS;
 
 
     HPS                             hPS;
 
 
@@ -2142,89 +1944,11 @@ bool wxWindowOS2::IsMouseInWindow() const
     return hWnd != NULL;
 } // end of wxWindowOS2::IsMouseInWindow
 
     return hWnd != NULL;
 } // end of wxWindowOS2::IsMouseInWindow
 
-#if wxUSE_CARET && WXWIN_COMPATIBILITY
-// ---------------------------------------------------------------------------
-// Caret manipulation
-// ---------------------------------------------------------------------------
-
-void wxWindowOS2::CreateCaret(
-  int                               nWidth
-, int                               nHeight
-)
-{
-    SetCaret(new wxCaret( this
-                         ,nWidth
-                         ,nHeight
-                        ));
-} // end of wxWindowOS2::CreateCaret
-
-void wxWindowOS2::CreateCaret(
-  const wxBitmap*                   pBitmap
-)
-{
-    wxFAIL_MSG("not implemented");
-} // end of wxWindowOS2::CreateCaret
-
-void wxWindowOS2::ShowCaret(
-  bool                              bShow
-)
-{
-    wxCHECK_RET( m_caret, "no caret to show" );
-
-    m_caret->Show(bShow);
-} // end of wxWindowOS2::ShowCaret
-
-void wxWindowOS2::DestroyCaret()
-{
-    SetCaret(NULL);
-} // end of wxWindowOS2::DestroyCaret
-
-void wxWindowOS2::SetCaretPos(
-  int                               nX
-, int                               nY)
-{
-    wxCHECK_RET( m_caret, "no caret to move" );
-
-    m_caret->Move( nX
-                  ,nY
-                 );
-} // end of wxWindowOS2::SetCaretPos
-
-void wxWindowOS2::GetCaretPos(
-  int*                              pX
-, int*                              pY
-) const
-{
-    wxCHECK_RET( m_caret, "no caret to get position of" );
-
-    m_caret->GetPosition( pX
-                         ,pY
-                        );
-} // end of wxWindowOS2::GetCaretPos
-
-#endif //wxUSE_CARET
 
 // ---------------------------------------------------------------------------
 // popup menu
 // ---------------------------------------------------------------------------
 //
 
 // ---------------------------------------------------------------------------
 // popup menu
 // ---------------------------------------------------------------------------
 //
-#if wxUSE_MENUS_NATIVE
-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);
-    }
-}
-#endif // wxUSE_MENUS_NATIVE
-
 #if wxUSE_MENUS_NATIVE
 bool wxWindowOS2::DoPopupMenu(
   wxMenu*                           pMenu
 #if wxUSE_MENUS_NATIVE
 bool wxWindowOS2::DoPopupMenu(
   wxMenu*                           pMenu
@@ -2236,13 +1960,28 @@ bool wxWindowOS2::DoPopupMenu(
     HWND                            hWndParent = GetHwnd();
     HWND                            hMenu = GetHmenuOf(pMenu);
     bool                            bIsWaiting = TRUE;
     HWND                            hWndParent = GetHwnd();
     HWND                            hMenu = GetHmenuOf(pMenu);
     bool                            bIsWaiting = TRUE;
+    int                             nHeight;
+
+    // Protect against recursion
+    if (wxCurrentPopupMenu)
+        return false;
 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();
 
 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();
 
-    DoClientToScreen( &nX
-                     ,&nY
-                    );
+    if ( nX == -1 && nY == -1 )
+    {
+        wxPoint mouse = wxGetMousePosition();
+        nX = mouse.x; nY = mouse.y;
+    }
+    else
+    {
+        DoClientToScreen( &nX
+                         ,&nY
+                        );
+        DoGetSize(0,&nHeight);
+        nY = nHeight - nY;
+    }
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent
@@ -2257,15 +1996,13 @@ bool wxWindowOS2::DoPopupMenu(
     while(bIsWaiting)
     {
         QMSG                            vMsg;
     while(bIsWaiting)
     {
         QMSG                            vMsg;
-        BOOL                            bRc = ::WinGetMsg(vHabmain, &vMsg, HWND(NULL), 0, 0);
 
 
-        if (vMsg.msg == WM_MENUEND || vMsg.msg == WM_COMMAND)
-        {
+        ::WinGetMsg(vHabmain,&vMsg, (HWND)0, 0, 0);
+        if (vMsg.msg == WM_COMMAND)
             bIsWaiting = FALSE;
             bIsWaiting = FALSE;
-        }
         ::WinDispatchMsg(vHabmain, (PQMSG)&vMsg);
         ::WinDispatchMsg(vHabmain, (PQMSG)&vMsg);
-
     }
     }
+
     wxCurrentPopupMenu = NULL;
     pMenu->SetInvokingWindow(NULL);
     return TRUE;
     wxCurrentPopupMenu = NULL;
     pMenu->SetInvokingWindow(NULL);
     return TRUE;
@@ -2415,6 +2152,14 @@ bool wxWindowOS2::OS2ProcessMessage(
                                 pBtn->OS2Command(BN_CLICKED, 0 /* unused */);
                                 return TRUE;
                             }
                                 pBtn->OS2Command(BN_CLICKED, 0 /* unused */);
                                 return TRUE;
                             }
+                            else if (!IsTopLevel())
+                            {
+                                //
+                                // if not a top level window, let parent
+                                // handle it
+                                //
+                                return FALSE;
+                            }
                             // else: but if it does not it makes sense to make
                             //       it work like a TAB - and that's what we do.
                             //       Note that Ctrl-Enter always works this way.
                             // else: but if it does not it makes sense to make
                             //       it work like a TAB - and that's what we do.
                             //       Note that Ctrl-Enter always works this way.
@@ -2546,7 +2291,7 @@ void wxWindowOS2::UnpackMenuSelect(
 } // end of wxWindowOS2::UnpackMenuSelect
 
 // ---------------------------------------------------------------------------
 } // end of wxWindowOS2::UnpackMenuSelect
 
 // ---------------------------------------------------------------------------
-// Main wxWindows window proc and the window proc for wxWindow
+// Main wxWidgets window proc and the window proc for wxWindow
 // ---------------------------------------------------------------------------
 
 //
 // ---------------------------------------------------------------------------
 
 //
@@ -2565,14 +2310,6 @@ MRESULT EXPENTRY wxWndProc(
 , MPARAM                            lParam
 )
 {
 , MPARAM                            lParam
 )
 {
-    //
-    // Trace all ulMsgs - useful for the debugging
-    //
-#ifdef __WXDEBUG__
-    wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
-               wxGetMessageName(ulMsg), wParam, lParam);
-#endif // __WXDEBUG__
-
     wxWindowOS2*                    pWnd = wxFindWinFromHandle((WXHWND)hWnd);
 
     //
     wxWindowOS2*                    pWnd = wxFindWinFromHandle((WXHWND)hWnd);
 
     //
@@ -2794,7 +2531,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
                     bProcessed = HandleMouseEvent( uMsg
                                                   ,nX
                                                   ,nY
                     bProcessed = HandleMouseEvent( uMsg
                                                   ,nX
                                                   ,nY
-                                                  ,(WXUINT)SHORT1FROMMP(wParam)
+                                                  ,(WXUINT)SHORT2FROMMP(lParam)
                                                  );
                 }
                 else
                                                  );
                 }
                 else
@@ -2803,10 +2540,15 @@ MRESULT wxWindowOS2::OS2WindowProc(
                                                                    ,&nX
                                                                    ,&nY
                                                                   );
                                                                    ,&nX
                                                                    ,&nY
                                                                   );
+                    if (!pWin->IsOfStandardClass())
+                    {
+                        if (uMsg == WM_BUTTON1DOWN && pWin->AcceptsFocus() )
+                            pWin->SetFocus();
+                    }
                     bProcessed = pWin->HandleMouseEvent( uMsg
                                                         ,nX
                                                         ,nY
                     bProcessed = pWin->HandleMouseEvent( uMsg
                                                         ,nX
                                                         ,nY
-                                                        ,(WXUINT)SHORT1FROMMP(wParam)
+                                                        ,(WXUINT)SHORT2FROMMP(lParam)
                                                        );
                 }
             }
                                                        );
                 }
             }
@@ -2969,6 +2711,26 @@ MRESULT wxWindowOS2::OS2WindowProc(
         case WM_CONTROL:
             switch(SHORT2FROMMP(wParam))
             {
         case WM_CONTROL:
             switch(SHORT2FROMMP(wParam))
             {
+                case BN_PAINT:
+                    {
+                        HWND                hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam));
+                        wxWindowOS2*        pWin = wxFindWinFromHandle(hWnd);
+
+                        if (!pWin)
+                        {
+                            bProcessed = FALSE;
+                            break;
+                        }
+                        if (pWin->IsKindOf(CLASSINFO(wxBitmapButton)))
+                        {
+                            wxBitmapButton*     pBitmapButton = wxDynamicCast(pWin, wxBitmapButton);
+
+                            pBitmapButton->OS2OnDraw((WXDRAWITEMSTRUCT *)lParam);
+                        }
+                        return 0;
+                    }
+                    break;
+
                 case BKN_PAGESELECTEDPENDING:
                     {
                         PPAGESELECTNOTIFY  pPage = (PPAGESELECTNOTIFY)lParam;
                 case BKN_PAGESELECTEDPENDING:
                     {
                         PPAGESELECTNOTIFY  pPage = (PPAGESELECTNOTIFY)lParam;
@@ -3014,7 +2776,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
                             break;
                         }
                         //
                             break;
                         }
                         //
-                        // Simulate a WM_COMMAND here, as wxWindows expects all control
+                        // Simulate a WM_COMMAND here, as wxWidgets expects all control
                         // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
                         //
                         if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
                         // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
                         //
                         if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
@@ -3074,7 +2836,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
                             break;
                         }
                         //
                             break;
                         }
                         //
-                        // Simulate a WM_COMMAND here, as wxWindows expects all control
+                        // Simulate a WM_COMMAND here, as wxWidgets expects all control
                         // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
                         //
                         if (pWin->IsKindOf(CLASSINFO(wxListBox)))
                         // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
                         //
                         if (pWin->IsKindOf(CLASSINFO(wxListBox)))
@@ -3211,6 +2973,20 @@ MRESULT wxWindowOS2::OS2WindowProc(
                 mResult = (MRESULT)TRUE;
             }
             break;
                 mResult = (MRESULT)TRUE;
             }
             break;
+
+#if wxUSE_MENUS_NATIVE
+         case WM_MENUEND:
+            if (wxCurrentPopupMenu)
+            {
+                if (GetHmenuOf(wxCurrentPopupMenu) == (HWND)lParam)
+                {
+                    // Break out of msg loop in DoPopupMenu
+                    ::WinPostMsg((HWND)lParam,WM_COMMAND,wParam,0);
+                }
+            }
+            break;
+#endif // wxUSE_MENUS_NATIVE
+
     }
     if (!bProcessed)
     {
     }
     if (!bProcessed)
     {
@@ -3228,45 +3004,17 @@ MRESULT wxWindowOS2::OS2WindowProc(
     return mResult;
 } // end of wxWindowOS2::OS2WindowProc
 
     return mResult;
 } // end of wxWindowOS2::OS2WindowProc
 
-#ifndef __EMX__
-// clashes with wxDlgProc in toplevel.cpp?
-//
-// Dialog window proc
-//
-MRESULT wxDlgProc(
-  HWND                              WXUNUSED(hWnd)
-, UINT                              uMsg
-, MPARAM                            WXUNUSED(wParam)
-, MPARAM                            WXUNUSED(lParam))
-{
-    if (uMsg == WM_INITDLG)
-    {
-        //
-        // For this message, returning TRUE tells system to set focus to the
-        // first control in the dialog box
-        //
-        return (MRESULT)TRUE;
-    }
-    else
-    {
-        //
-        // For all the other ones, FALSE means that we didn't process the
-        // message
-        //
-        return (MRESULT)0;
-    }
-} // end of wxDlgProc
-#endif
+// ----------------------------------------------------------------------------
+// wxWindow <-> HWND map
+// ----------------------------------------------------------------------------
+
+wxWinHashTable *wxWinHandleHash = NULL;
 
 wxWindow* wxFindWinFromHandle(
   WXHWND                            hWnd
 )
 {
 
 wxWindow* wxFindWinFromHandle(
   WXHWND                            hWnd
 )
 {
-    wxNode*                         pNode = wxWinHandleList->Find((long)hWnd);
-
-    if (!pNode)
-        return NULL;
-    return (wxWindow *)pNode->Data();
+    return (wxWindow *)wxWinHandleHash->Get((long)hWnd);
 } // end of wxFindWinFromHandle
 
 void wxAssociateWinWithHandle(
 } // end of wxFindWinFromHandle
 
 void wxAssociateWinWithHandle(
@@ -3294,9 +3042,9 @@ void wxAssociateWinWithHandle(
     }
     else if (!pOldWin)
     {
     }
     else if (!pOldWin)
     {
-        wxWinHandleList->Append( (long)hWnd
-                                ,pWin
-                               );
+        wxWinHandleHash->Put( (long)hWnd
+                             ,(wxWindow *)pWin
+                            );
     }
 } // end of wxAssociateWinWithHandle
 
     }
 } // end of wxAssociateWinWithHandle
 
@@ -3304,7 +3052,7 @@ void wxRemoveHandleAssociation(
   wxWindowOS2*                      pWin
 )
 {
   wxWindowOS2*                      pWin
 )
 {
-    wxWinHandleList->DeleteObject(pWin);
+    wxWinHandleHash->Delete((long)pWin->GetHWND());
 } // end of wxRemoveHandleAssociation
 
 //
 } // end of wxRemoveHandleAssociation
 
 //
@@ -3373,9 +3121,6 @@ bool wxWindowOS2::OS2Create(
     int                             nY      = 0L;
     int                             nWidth  = 0L;
     int                             nHeight = 0L;
     int                             nY      = 0L;
     int                             nWidth  = 0L;
     int                             nHeight = 0L;
-    wxWindow*                       pParent = GetParent();
-    HWND                            hWnd = NULLHANDLE;
-    HWND                            hParent;
     long                            lControlId = 0L;
     wxWindowCreationHook            vHook(this);
     wxString                        sClassName((wxChar*)zClass);
     long                            lControlId = 0L;
     wxWindowCreationHook            vHook(this);
     wxString                        sClassName((wxChar*)zClass);
@@ -3401,7 +3146,7 @@ bool wxWindowOS2::OS2Create(
     // which is the same but without CS_[HV]REDRAW class styles so using it
     // ensures that the window is not fully repainted on each resize
     //
     // which is the same but without CS_[HV]REDRAW class styles so using it
     // ensures that the window is not fully repainted on each resize
     //
-    if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE)
+    if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
     {
         sClassName += wxT("NR");
     }
     {
         sClassName += wxT("NR");
     }
@@ -3440,7 +3185,7 @@ bool wxWindowOS2::OS2Create(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
-        wxLogError("Error creating frame. Error: %s\n", sError);
+        wxLogError("Error creating frame. Error: %s\n", sError.c_str());
         return FALSE;
     }
     SetSize( nX
         return FALSE;
     }
     SetSize( nX
@@ -3474,7 +3219,7 @@ bool wxWindowOS2::HandleCreate(
 bool wxWindowOS2::HandleDestroy()
 {
     wxWindowDestroyEvent            vEvent((wxWindow*)this);
 bool wxWindowOS2::HandleDestroy()
 {
     wxWindowDestroyEvent            vEvent((wxWindow*)this);
-
+    vEvent.SetId(GetId());
     (void)GetEventHandler()->ProcessEvent(vEvent);
 
     //
     (void)GetEventHandler()->ProcessEvent(vEvent);
 
     //
@@ -3483,7 +3228,6 @@ bool wxWindowOS2::HandleDestroy()
 #if wxUSE_DRAG_AND_DROP
     if (m_dropTarget != NULL)
     {
 #if wxUSE_DRAG_AND_DROP
     if (m_dropTarget != NULL)
     {
-        m_dropTarget->Revoke(m_hWnd);
         delete m_dropTarget;
         m_dropTarget = NULL;
     }
         delete m_dropTarget;
         m_dropTarget = NULL;
     }
@@ -3614,7 +3358,7 @@ bool wxWindowOS2::HandleShow(
 {
     wxShowEvent                     vEvent(GetId(), bShow);
 
 {
     wxShowEvent                     vEvent(GetId(), bShow);
 
-    vEvent.m_eventObject = this;
+    vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleShow
 
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleShow
 
@@ -3624,7 +3368,7 @@ bool wxWindowOS2::HandleInitDialog(
 {
     wxInitDialogEvent               vEvent(GetId());
 
 {
     wxInitDialogEvent               vEvent(GetId());
 
-    vEvent.m_eventObject = this;
+    vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleInitDialog
 
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleInitDialog
 
@@ -3680,7 +3424,7 @@ bool wxWindowOS2::OS2OnDrawItem(
                   );
         vDc.SetHPS(pMeasureStruct->hps);
         //
                   );
         vDc.SetHPS(pMeasureStruct->hps);
         //
-        // Load the wxWindows Pallete and set to RGB mode
+        // Load the wxWidgets Pallete and set to RGB mode
         //
         if (!::GpiCreateLogColorTable( pMeasureStruct->hps
                                       ,0L
         //
         if (!::GpiCreateLogColorTable( pMeasureStruct->hps
                                       ,0L
@@ -3692,7 +3436,7 @@ bool wxWindowOS2::OS2OnDrawItem(
         {
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
         {
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
-            wxLogError("Unable to set current color table. Error: %s\n", sError);
+            wxLogError("Unable to set current color table. Error: %s\n", sError.c_str());
         }
         //
         // Set the color table to RGB mode
         }
         //
         // Set the color table to RGB mode
@@ -3707,7 +3451,7 @@ bool wxWindowOS2::OS2OnDrawItem(
         {
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
         {
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
-            wxLogError("Unable to set current color table. Error: %s\n", sError);
+            wxLogError("Unable to set current color table. Error: %s\n", sError.c_str());
         }
 
         wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
         }
 
         wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
@@ -3916,23 +3660,23 @@ void wxWindowOS2::OnSysColourChanged(
   wxSysColourChangedEvent&          rEvent
 )
 {
   wxSysColourChangedEvent&          rEvent
 )
 {
-    wxNode*                         pNode = GetChildren().First();
+    wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 
 
-    while (pNode)
+    while (node)
     {
         //
         // Only propagate to non-top-level windows
         //
     {
         //
         // Only propagate to non-top-level windows
         //
-        wxWindow*                   pWin = (wxWindow *)pNode->Data();
+        wxWindow*                   pWin = (wxWindow *)node->GetData();
 
         if (pWin->GetParent())
         {
             wxSysColourChangedEvent vEvent;
 
 
         if (pWin->GetParent())
         {
             wxSysColourChangedEvent vEvent;
 
-            rEvent.m_eventObject = pWin;
+            rEvent.SetEventObject(pWin);
             pWin->GetEventHandler()->ProcessEvent(vEvent);
         }
             pWin->GetEventHandler()->ProcessEvent(vEvent);
         }
-        pNode = pNode->Next();
+        node = node->GetNext();
     }
 } // end of wxWindowOS2::OnSysColourChanged
 
     }
 } // end of wxWindowOS2::OnSysColourChanged
 
@@ -3940,12 +3684,26 @@ void wxWindowOS2::OnSysColourChanged(
 // painting
 // ---------------------------------------------------------------------------
 
 // painting
 // ---------------------------------------------------------------------------
 
+void wxWindow::OnPaint (
+  wxPaintEvent&                     rEvent
+)
+{
+    HDC                             hDC = (HDC)wxPaintDC::FindDCInCache((wxWindow*) rEvent.GetEventObject());
+
+    if (hDC != 0)
+    {
+        OS2DefWindowProc( (WXUINT)WM_PAINT
+                         ,(WXWPARAM)hDC
+                         ,(WXLPARAM)0
+                        );
+    }
+} // end of wxWindow::OnPaint
+
 bool wxWindowOS2::HandlePaint()
 {
     HRGN                            hRgn;
     wxPaintEvent                    vEvent(m_windowId);
     HPS                             hPS;
 bool wxWindowOS2::HandlePaint()
 {
     HRGN                            hRgn;
     wxPaintEvent                    vEvent(m_windowId);
     HPS                             hPS;
-    RECTL                           vRect;
     bool                            bProcessed;
 
     // Create empty region
     bool                            bProcessed;
 
     // Create empty region
@@ -3959,6 +3717,51 @@ bool wxWindowOS2::HandlePaint()
          return FALSE;
     }
 
          return FALSE;
     }
 
+    // Get all the rectangles from the region, convert the individual
+    // rectangles to "the other" coordinate system and reassemble a
+    // region from the rectangles, to be feed into m_updateRegion.
+    //
+    // FIXME: This is a bad hack since OS/2 API specifies that rectangles
+    //         passed into GpiSetRegion must not have Bottom > Top,
+    //          however, at first sight, it _seems_ to work nonetheless.
+    //
+    RGNRECT                     vRgnData;
+    PRECTL                      pUpdateRects = NULL;
+    vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT;
+    if (::GpiQueryRegionRects( hPS          // Pres space
+                              ,hRgn         // Handle of region to query
+                              ,NULL         // Return all RECTs
+                              ,&vRgnData    // Will contain number or RECTs in region
+                              ,NULL         // NULL to return number of RECTs
+                             ))
+    {
+        pUpdateRects = new RECTL[vRgnData.crcReturned];
+        vRgnData.crc = vRgnData.crcReturned;
+        vRgnData.ircStart = 1;
+        if (::GpiQueryRegionRects( hPS      // Pres space of source
+                                  ,hRgn     // Handle of source region
+                                  ,NULL     // Return all RECTs
+                                  ,&vRgnData // Operations set to return rects
+                                  ,pUpdateRects // Will contain the actual RECTS
+                                 ))
+        {
+            int                     height;
+            RECT                    vRect;
+            ::WinQueryWindowRect(GetHwnd(), &vRect);
+            height = vRect.yTop;
+
+            for(size_t i = 0; i < vRgnData.crc; i++)
+            {
+                int                 rectHeight;
+                rectHeight = pUpdateRects[i].yTop - pUpdateRects[i].yBottom;
+                pUpdateRects[i].yTop = height - pUpdateRects[i].yTop;
+                pUpdateRects[i].yBottom = pUpdateRects[i].yTop + rectHeight;
+            }
+            ::GpiSetRegion(hPS, hRgn, vRgnData.crc, pUpdateRects);
+            delete [] pUpdateRects;
+        }
+    }
+
     m_updateRegion = wxRegion(hRgn, hPS);
 
     vEvent.SetEventObject(this);
     m_updateRegion = wxRegion(hRgn, hPS);
 
     vEvent.SetEventObject(this);
@@ -3977,8 +3780,6 @@ bool wxWindowOS2::HandlePaint()
         //
         HPS                         hPS;
         RECTL                       vRect;
         //
         HPS                         hPS;
         RECTL                       vRect;
-        wxFrame*                    pFrame;
-        wxWindow*                   pParent;
 
         hPS = ::WinBeginPaint( GetHwnd()
                               ,NULLHANDLE
 
         hPS = ::WinBeginPaint( GetHwnd()
                               ,NULLHANDLE
@@ -4038,8 +3839,6 @@ bool wxWindowOS2::HandlePaint()
         //
         HPS                         hPS;
         RECTL                       vRect;
         //
         HPS                         hPS;
         RECTL                       vRect;
-        wxFrame*                    pFrame;
-        wxWindow*                   pParent;
 
         hPS = ::WinBeginPaint( GetHwnd()
                               ,NULLHANDLE
 
         hPS = ::WinBeginPaint( GetHwnd()
                               ,NULLHANDLE
@@ -4159,7 +3958,6 @@ bool wxWindowOS2::HandleGetMinMaxInfo(
   PSWP                              pSwp
 )
 {
   PSWP                              pSwp
 )
 {
-    bool                            bRc = FALSE;
     POINTL                          vPoint;
 
     switch(pSwp->fl)
     POINTL                          vPoint;
 
     switch(pSwp->fl)
@@ -4244,15 +4042,22 @@ void wxWindowOS2::InitMouseEvent(
 , WXUINT                            uFlags
 )
 {
 , WXUINT                            uFlags
 )
 {
+    int                                 nHeight;
+    DoGetSize(0, &nHeight);
     rEvent.m_x           = nX;
     rEvent.m_x           = nX;
-    rEvent.m_y           = nY;
-    rEvent.m_shiftDown   = ((uFlags & VK_SHIFT) != 0);
-    rEvent.m_controlDown = ((uFlags & VK_CTRL) != 0);
-    rEvent.m_leftDown    = ((uFlags & VK_BUTTON1) != 0);
-    rEvent.m_middleDown  = ((uFlags & VK_BUTTON3) != 0);
-    rEvent.m_rightDown   = ((uFlags & VK_BUTTON2) != 0);
+    // Convert to wxWidgets standard coordinate system!
+    rEvent.m_y           = nHeight - nY;
+    rEvent.m_shiftDown   = ((uFlags & KC_SHIFT) != 0);
+    rEvent.m_controlDown = ((uFlags & KC_CTRL) != 0);
+    rEvent.m_altDown     = ((uFlags & KC_ALT) != 0);
+    rEvent.m_leftDown    = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) &
+                           0x8000) != 0;
+    rEvent.m_middleDown  = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) &
+                           0x8000) != 0;
+    rEvent.m_rightDown   = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) &
+                           0x8000) != 0;
     rEvent.SetTimestamp(s_currentMsg.time);
     rEvent.SetTimestamp(s_currentMsg.time);
-    rEvent.m_eventObject = this;
+    rEvent.SetEventObject(this);
     rEvent.SetId(GetId());
 
 #if wxUSE_MOUSEEVENT_HACK
     rEvent.SetId(GetId());
 
 #if wxUSE_MOUSEEVENT_HACK
@@ -4273,7 +4078,7 @@ bool wxWindowOS2::HandleMouseEvent(
 
     //
     // The mouse events take consecutive IDs from WM_MOUSEFIRST to
 
     //
     // The mouse events take consecutive IDs from WM_MOUSEFIRST to
-    // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
+    // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
     // from the message id and take the value in the table to get wxWin event
     // id
     //
     // from the message id and take the value in the table to get wxWin event
     // id
     //
@@ -4291,27 +4096,30 @@ bool wxWindowOS2::HandleMouseEvent(
         wxEVT_MIDDLE_DCLICK
     };
 
         wxEVT_MIDDLE_DCLICK
     };
 
-    wxMouseEvent                    vEvent(eventsMouse[uMsg - WM_MOUSEMOVE]);
-
-    InitMouseEvent( vEvent
-                   ,nX
-                   ,nY
-                   ,uFlags
-                  );
-
-    bProcessed = GetEventHandler()->ProcessEvent(vEvent);
-    if (!bProcessed)
+    // Bounds check
+    if ((uMsg >= WM_MOUSEMOVE) && (uMsg <= WM_BUTTON3DBLCLK))
     {
     {
-        HPOINTER                    hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE);
-        HPOINTER                    hCursor = (HPOINTER)GetCursor().GetHCURSOR();
+        wxMouseEvent               vEvent(eventsMouse[uMsg - WM_MOUSEMOVE]);
 
 
-        if (hCursor != NULLHANDLE)
+        InitMouseEvent( vEvent
+                       ,nX
+                       ,nY
+                       ,uFlags
+                       );
+
+        bProcessed = GetEventHandler()->ProcessEvent(vEvent);
+        if (!bProcessed)
         {
         {
-            ::WinSetPointer(HWND_DESKTOP, hCursor);
-            bProcessed = TRUE;
+            HPOINTER               hCursor = (HPOINTER)GetCursor().GetHCURSOR();
+
+            if (hCursor != NULLHANDLE)
+            {
+                ::WinSetPointer(HWND_DESKTOP, hCursor);
+                bProcessed = TRUE;
+            }
         }
     }
         }
     }
-    return GetEventHandler()->ProcessEvent(vEvent);
+    return bProcessed;
 } // end of wxWindowOS2::HandleMouseEvent
 
 bool wxWindowOS2::HandleMouseMove(
 } // end of wxWindowOS2::HandleMouseEvent
 
 bool wxWindowOS2::HandleMouseMove(
@@ -4366,7 +4174,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent(
     vEvent.m_controlDown = IsCtrlDown();
     vEvent.m_altDown     = (HIWORD(lParam) & KC_ALT) == KC_ALT;
 
     vEvent.m_controlDown = IsCtrlDown();
     vEvent.m_altDown     = (HIWORD(lParam) & KC_ALT) == KC_ALT;
 
-    vEvent.m_eventObject = (wxWindow *)this; // const_cast
+    vEvent.SetEventObject((wxWindow *)this); // const_cast
     vEvent.m_keyCode     = nId;
     vEvent.m_rawCode = (wxUint32)wParam;
     vEvent.m_rawFlags = (wxUint32)lParam;
     vEvent.m_keyCode     = nId;
     vEvent.m_rawCode = (wxUint32)wParam;
     vEvent.m_rawFlags = (wxUint32)lParam;
@@ -4555,32 +4363,32 @@ bool wxWindowOS2::OS2OnScroll(
 
     vEvent.SetPosition(wPos);
     vEvent.SetOrientation(nOrientation);
 
     vEvent.SetPosition(wPos);
     vEvent.SetOrientation(nOrientation);
-    vEvent.m_eventObject = this;
+    vEvent.SetEventObject(this);
 
     switch (wParam)
     {
         case SB_LINEUP:
 
     switch (wParam)
     {
         case SB_LINEUP:
-            vEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
+            vEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP);
             break;
 
         case SB_LINEDOWN:
             break;
 
         case SB_LINEDOWN:
-            vEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
+            vEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);
             break;
 
         case SB_PAGEUP:
             break;
 
         case SB_PAGEUP:
-            vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
+            vEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP);
             break;
 
         case SB_PAGEDOWN:
             break;
 
         case SB_PAGEDOWN:
-            vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
+            vEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);
             break;
 
         case SB_SLIDERPOSITION:
             break;
 
         case SB_SLIDERPOSITION:
-            vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBRELEASE;
+            vEvent.SetEventType(wxEVT_SCROLLWIN_THUMBRELEASE);
             break;
 
         case SB_SLIDERTRACK:
             break;
 
         case SB_SLIDERTRACK:
-            vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBTRACK;
+            vEvent.SetEventType(wxEVT_SCROLLWIN_THUMBTRACK);
             break;
 
         default:
             break;
 
         default:
@@ -4593,7 +4401,10 @@ void wxWindowOS2::MoveChildren(
   int                               nDiff
 )
 {
   int                               nDiff
 )
 {
-    if (GetAutoLayout())
+    //
+    // We want to handle top levels ourself, manually
+    //
+    if (!IsTopLevel() && GetAutoLayout())
     {
         Layout();
     }
     {
         Layout();
     }
@@ -4601,11 +4412,11 @@ void wxWindowOS2::MoveChildren(
     {
         SWP                         vSwp;
 
     {
         SWP                         vSwp;
 
-        for (wxWindowList::Node* pNode = GetChildren().GetFirst();
-             pNode;
-             pNode = pNode->GetNext())
+        for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
+             node;
+             node = node->GetNext())
         {
         {
-            wxWindow*               pWin = pNode->GetData();
+            wxWindow*               pWin = node->GetData();
 
             ::WinQueryWindowPos( GetHwndOf(pWin)
                                 ,&vSwp
 
             ::WinQueryWindowPos( GetHwndOf(pWin)
                                 ,&vSwp
@@ -4629,7 +4440,7 @@ void wxWindowOS2::MoveChildren(
                               ,vSwp.y - nDiff
                               ,vSwp.cx
                               ,vSwp.cy
                               ,vSwp.y - nDiff
                               ,vSwp.cx
                               ,vSwp.cy
-                              ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
+                              ,SWP_MOVE
                              );
             ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp());
             if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
                              );
             ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp());
             if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
@@ -4664,7 +4475,7 @@ void wxWindowOS2::MoveChildren(
 //
 //  Getting the Y position for a window, like a control, is a real
 //  pain.  There are three sitatuions we must deal with in determining
 //
 //  Getting the Y position for a window, like a control, is a real
 //  pain.  There are three sitatuions we must deal with in determining
-//  the OS2 to wxWindows Y coordinate.
+//  the OS2 to wxWidgets Y coordinate.
 //
 //  1)  The controls are created in a dialog.
 //      This is the easiest since a dialog is created with its original
 //
 //  1)  The controls are created in a dialog.
 //      This is the easiest since a dialog is created with its original
@@ -4696,8 +4507,6 @@ int wxWindowOS2::GetOS2ParentHeight(
   wxWindowOS2*               pParent
 )
 {
   wxWindowOS2*               pParent
 )
 {
-    wxWindowOS2*             pGrandParent = NULL;
-
     //
     // Case 1
     //
     //
     // Case 1
     //
@@ -5178,7 +4987,7 @@ const char* wxGetMessageName(
         // Beginning of user defined messages
         case 0x1000: return "WM_USER";
 
         // Beginning of user defined messages
         case 0x1000: return "WM_USER";
 
-        // wxWindows user defined types
+        // wxWidgets user defined types
 
         // listview
         // case 0x1000 + 0: return "LVM_GETBKCOLOR";
 
         // listview
         // case 0x1000 + 0: return "LVM_GETBKCOLOR";
@@ -5493,7 +5302,6 @@ wxWindowOS2* FindWindowForMouseEvent(
     POINTL                          vPoint;
     BOOL                            rcEnabled = FALSE;
     BOOL                            rcVisible = FALSE;
     POINTL                          vPoint;
     BOOL                            rcEnabled = FALSE;
     BOOL                            rcVisible = FALSE;
-    HWND                            hWndDesktop = HWND_DESKTOP;
 
     ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
     hWndUnderMouse = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
 
     ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
     hWndUnderMouse = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
@@ -5503,8 +5311,7 @@ wxWindowOS2* FindWindowForMouseEvent(
 
         if (pWinUnderMouse)
         {
 
         if (pWinUnderMouse)
         {
-            wxWindowList::Node*     pCurrent = pWinUnderMouse->GetChildren().GetFirst();
-            wxWindow*               pChild = NULL;
+            wxWindowList::compatibility_iterator current = pWinUnderMouse->GetChildren().GetFirst();
             wxWindow*               pGrandChild = NULL;
             RECTL                   vRect;
             POINTL                  vPoint2;
             wxWindow*               pGrandChild = NULL;
             RECTL                   vRect;
             POINTL                  vPoint2;
@@ -5513,9 +5320,9 @@ wxWindowOS2* FindWindowForMouseEvent(
             //
             // Find a child window mouse might be under
             //
             //
             // Find a child window mouse might be under
             //
-            while (pCurrent)
+            while (current)
             {
             {
-                wxWindow*                   pChild = pCurrent->GetData();
+                wxWindow*                   pChild = current->GetData();
 
                 vPoint2.x = vPoint.x;
                 vPoint2.y = vPoint.y;
 
                 vPoint2.x = vPoint.x;
                 vPoint2.y = vPoint.y;
@@ -5526,11 +5333,11 @@ wxWindowOS2* FindWindowForMouseEvent(
                     if (pChild->IsTopLevel())
                     {
                         POINTL                  vPoint3;
                     if (pChild->IsTopLevel())
                     {
                         POINTL                  vPoint3;
-                        wxWindowList::Node*     pCurrent2 =pChild->GetChildren().GetFirst();
+                        wxWindowList::compatibility_iterator current2 =pChild->GetChildren().GetFirst();
 
 
-                        while (pCurrent2)
+                        while (current2)
                         {
                         {
-                            wxWindow*           pGrandChild = pCurrent2->GetData();
+                            wxWindow*           pGrandChild = current2->GetData();
 
                             vPoint3.x = vPoint2.x;
                             vPoint3.y = vPoint2.y;
 
                             vPoint3.x = vPoint2.x;
                             vPoint3.y = vPoint2.y;
@@ -5546,7 +5353,7 @@ wxWindowOS2* FindWindowForMouseEvent(
                                 pWinUnderMouse = pGrandChild;
                                 break;
                             }
                                 pWinUnderMouse = pGrandChild;
                                 break;
                             }
-                            pCurrent2 = pCurrent2->GetNext();
+                            current2 = current2->GetNext();
                         }
                         if (pGrandChild)
                             break;
                         }
                         if (pGrandChild)
                             break;
@@ -5558,7 +5365,7 @@ wxWindowOS2* FindWindowForMouseEvent(
                     if (rcVisible && rcEnabled)
                         break;
                 }
                     if (rcVisible && rcEnabled)
                         break;
                 }
-                pCurrent = pCurrent->GetNext();
+                current = current->GetNext();
             }
         }
     }
             }
         }
     }
wxWidgets (Impactor)