]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/window.cpp
New Refresh()/Update() behaviour. As expected, scrolling
[wxWidgets.git] / src / os2 / window.cpp
index 2e09d5932c85d53680f7b4e5ff296ea5cda309f9..681b0b3451b22c8b8ddbb138054f4205c1a45e70 100644 (file)
     #include "wx/listbox.h"
     #include "wx/button.h"
     #include "wx/msgdlg.h"
-
+    #include "wx/scrolwin.h"
+    #include "wx/radiobox.h"
+    #include "wx/slider.h"
+    #include "wx/statusbr.h"
+    #include "wx/toolbar.h"
+    #include "wx/settings.h"
     #include <stdio.h>
 #endif
 
 // ---------------------------------------------------------------------------
 
 //
-// The last Windows message we got (MT-UNSAFE)
+// The last PM message we got (MT-UNSAFE)
 //
 QMSG                      s_currentMsg;
 
+#if wxUSE_MENUS_NATIVE
 wxMenu*                   wxCurrentPopupMenu = NULL;
-extern wxList WXDLLEXPORT wxPendingDelete;
-#if !defined(__VISAGECPP__) || (__IBMCPP__ < 400)
-extern wxChar             wxCanvasClassName[];
-#endif
+#endif // wxUSE_MENUS_NATIVE
+
 wxList*                   wxWinHandleList = NULL;
 
 // ---------------------------------------------------------------------------
@@ -121,9 +125,9 @@ MRESULT EXPENTRY wxWndProc( HWND hWnd
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 
-void      wxRemoveHandleAssociation(wxWindow* pWin);
-void      wxAssociateWinWithHandle( HWND      hWnd
-                                   ,wxWindow* pWin
+void      wxRemoveHandleAssociation(wxWindowOS2* pWin);
+void      wxAssociateWinWithHandle( HWND         hWnd
+                                   ,wxWindowOS2* pWin
                                   );
 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 
@@ -131,24 +135,35 @@ wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 // This magical function is used to translate VK_APPS key presses to right
 // mouse clicks
 //
+// Unused?
+#if 0
 static void TranslateKbdEventToMouse( wxWindow* pWin
                                      ,int*      pX
                                      ,int*      pY
                                      ,MPARAM*   pFlags
                                     );
-
+#endif
 //
 // get the current state of SHIFT/CTRL keys
 //
 static inline bool IsShiftDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000) != 0; }
 static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000) != 0; }
+
+static wxWindow*                    gpWinBeingCreated = NULL;
+
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
 
+// in wxUniv-OS/2 this class is abstract because it doesn't have DoPopupMenu()
+// method
+#ifdef __WXUNIVERSAL__
+    IMPLEMENT_ABSTRACT_CLASS(wxWindowOS2, wxWindowBase)
+#else // __WXPM__
     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
+#endif // __WXUNIVERSAL__/__WXPM__
 
-BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
+BEGIN_EVENT_TABLE(wxWindowOS2, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindowOS2::OnEraseBackground)
     EVT_SYS_COLOUR_CHANGED(wxWindowOS2::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindowOS2::OnInitDialog)
@@ -160,6 +175,10 @@ END_EVENT_TABLE()
 // implementation
 // ===========================================================================
 
+// ---------------------------------------------------------------------------
+// wxWindow utility functions
+// ---------------------------------------------------------------------------
+
 //
 // Find an item given the PM Window id
 //
@@ -167,21 +186,24 @@ wxWindow* wxWindowOS2::FindItem(
   long                              lId
 ) const
 {
-    wxControl*                      pItem = wxDynamicCast( this
-                                                          ,wxControl
-                                                         );
+#if wxUSE_CONTROLS
+    wxControl*                      pItem = wxDynamicCast(this, wxControl);
 
     if (pItem)
     {
         //
         // I it we or one of our "internal" children?
         //
-        if (pItem->GetId() == lId ||
-             (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND))
+        if (pItem->GetId() == lId
+#ifndef __WXUNIVERSAL__
+            || (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND)
+#endif
+            )
         {
             return pItem;
         }
     }
+#endif // wxUSE_CONTROLS
 
     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
 
@@ -220,7 +242,11 @@ wxWindow* wxWindowOS2::FindItemByHWND(
         if (pWnd)
             return(pWnd);
 
-        if (!bControlOnly || pParent->IsKindOf(CLASSINFO(wxControl)))
+        if (!bControlOnly
+#if wxUSE_CONTROLS
+            || pParent->IsKindOf(CLASSINFO(wxControl))
+#endif // wxUSE_CONTROLS
+            )
         {
             wxWindow*               pItem = pCurrent->GetData();
 
@@ -305,7 +331,6 @@ wxWindowOS2::~wxWindowOS2()
 {
     m_isBeingDeleted = TRUE;
 
-    OS2DetachWindowMenu();
     for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
     {
         wxFrame*                    pFrame = wxDynamicCast(pWin, wxFrame);
@@ -316,9 +341,11 @@ wxWindowOS2::~wxWindowOS2()
                 pFrame->SetLastFocus((wxWindow*)NULL);
         }
     }
+
+    DestroyChildren();
+
     if (m_parent)
         m_parent->RemoveChild(this);
-    DestroyChildren();
 
     if (m_hWnd)
     {
@@ -331,6 +358,7 @@ wxWindowOS2::~wxWindowOS2()
     }
 } // end of wxWindowOS2::~wxWindowOS2
 
+// real construction (Init() must have been called before!)
 bool wxWindowOS2::Create(
   wxWindow*                         pParent
 , wxWindowID                        vId
@@ -341,8 +369,8 @@ bool wxWindowOS2::Create(
 )
 {
     HWND                            hParent = NULLHANDLE;
-    wxPoint                         vPos = rPos; // The OS/2 position
-    ULONG                           ulCreateFlags = 0L;
+    ULONG                           ulCreateFlags = 0;
+    WXDWORD                         dwExStyle = 0;
 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 
@@ -362,37 +390,12 @@ bool wxWindowOS2::Create(
 
         pParent->AddChild(this);
         hParent = GetWinHwnd(pParent);
-        //
-        // OS2 uses normal coordinates, no bassackwards Windows ones
-        //
-        if (pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
-            pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
-           )
-        {
-            wxWindow*               pGrandParent = NULL;
 
-            pGrandParent = pParent->GetParent();
-            if (pGrandParent)
-                nTempy = pGrandParent->GetSize().y - (vPos.y + rSize.y);
-            else
-                nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
-        }
-        else
-            nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
-        vPos.y = nTempy;
         if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
              pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
            )
             ulCreateFlags |= WS_CLIPSIBLINGS;
     }
-    else
-    {
-        RECTL                   vRect;
-
-        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
-        hParent = HWND_DESKTOP;
-        vPos.y = vRect.yTop - (vPos.y + rSize.y);
-    }
 
     //
     // Most wxSTYLES are really PM Class specific styles and will be
@@ -402,6 +405,10 @@ bool wxWindowOS2::Create(
     ulCreateFlags |=  WS_VISIBLE;
 
 
+#ifdef __WXUNIVERSAL__
+    // no 3d effects, we draw them ourselves
+    WXDWORD exStyle = 0;
+#else // !wxUniversal
     if (lStyle & wxCLIP_SIBLINGS)
         ulCreateFlags |= WS_CLIPSIBLINGS;
 
@@ -412,9 +419,9 @@ bool wxWindowOS2::Create(
     //
     //
     bool                            bWant3D;
-    WXDWORD                         dwExStyle = Determine3DEffects( WS_EX_CLIENTEDGE
-                                                                   ,&bWant3D
-                                                                  );
+    dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
+
+#endif
 
     //
     // Add the simple border style as we'll use this to draw borders
@@ -422,24 +429,29 @@ bool wxWindowOS2::Create(
     if (lStyle & wxSIMPLE_BORDER)
         dwExStyle |= wxSIMPLE_BORDER;
 
+    if (lStyle & wxPOPUP_WINDOW)
+    {
+        // a popup window floats on top of everything
+//TODO: fix this...
+//        exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
+
+        // it is also created hidden as other top level windows
+        ulCreateFlags &= ~WS_VISIBLE;
+        m_isShown = FALSE;
+    }
+
     //
-    // Generic OS/2 Windows are created with no owner, no Z Order, no Control data,
-    // and no presentation parameters
+    // Generic OS/2 Windows have no Control Data but other classes
+    // that call OS2Create may have some.
     //
-    OS2Create( hParent
-              ,(PSZ)wxCanvasClassName
+    OS2Create( (PSZ)wxCanvasClassName
               ,rName.c_str()
               ,ulCreateFlags
-              ,vPos.x
-              ,vPos.y
-              ,WidthDefault(rSize.x)
-              ,HeightDefault(rSize.y)
-              ,NULLHANDLE
-              ,NULLHANDLE
-              ,m_windowId
-              ,NULL
-              ,NULL
+              ,rPos
+              ,rSize
+              ,NULL         // Control Data
               ,dwExStyle
+              ,TRUE         // Child
              );
 
     return(TRUE);
@@ -452,6 +464,7 @@ bool wxWindowOS2::Create(
 void wxWindowOS2::SetFocus()
 {
     HWND                            hWnd = GetHwnd();
+    wxCHECK_RET( hWnd, _T("can't set focus to invalid window") );
 
     if (hWnd)
         ::WinSetFocus(HWND_DESKTOP, hWnd);
@@ -489,7 +502,7 @@ bool wxWindowOS2::Enable(
         pChild->Enable(bEnable);
         pNode = pNode->GetNext();
     }
-    return(TRUE);
+    return TRUE;
 } // end of wxWindowOS2::Enable
 
 bool wxWindowOS2::Show(
@@ -507,7 +520,7 @@ bool wxWindowOS2::Show(
     {
         ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
     }
-    return(TRUE);
+    return TRUE;
 } // end of wxWindowOS2::Show
 
 void wxWindowOS2::Raise()
@@ -532,7 +545,7 @@ wxString wxWindowOS2::GetTitle() const
     return wxGetWindowText(GetHWND());
 } // end of wxWindowOS2::GetTitle
 
-void wxWindowOS2::CaptureMouse()
+void wxWindowOS2::DoCaptureMouse()
 {
     HWND                            hWnd = GetHwnd();
 
@@ -543,7 +556,7 @@ void wxWindowOS2::CaptureMouse()
     }
 } // end of wxWindowOS2::GetTitle
 
-void wxWindowOS2::ReleaseMouse()
+void wxWindowOS2::DoReleaseMouse()
 {
     if (m_bWinCaptured)
     {
@@ -570,15 +583,11 @@ bool wxWindowOS2::SetFont(
 
     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));
-    }
+    wxOS2SetFont( hWnd
+                 ,rFont
+                );
     return(TRUE);
-}
+} // end of wxWindowOS2::SetFont
 
 bool wxWindowOS2::SetCursor(
   const wxCursor&                   rCursor
@@ -590,25 +599,18 @@ bool wxWindowOS2::SetCursor(
         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;
+    if ( m_cursor.Ok() ) {
+        HWND                            hWnd = GetHwnd();
+        POINTL                          vPoint;
+        RECTL                           vRect;
 
-    hPS = ::WinGetPS(hWnd);
-
-    ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
-    ::WinQueryWindowRect(hWnd, &vRect);
-
-    hRGN = ::GpiCreateRegion(hPS, 1L, &vRect);
+        ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
+        ::WinQueryWindowRect(hWnd, &vRect);
 
-    if ((::GpiPtInRegion(hPS, hRGN, &vPoint) == PRGN_INSIDE) && !wxIsBusy())
-    {
-        ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
+        if (::WinPtInRect(vHabmain, &vRect, &vPoint) && !wxIsBusy())
+        {
+            ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
+        }
     }
     return TRUE;
 } // end of wxWindowOS2::SetCursor
@@ -740,21 +742,21 @@ int wxWindowOS2::GetScrollThumb(
 void wxWindowOS2::SetScrollPos(
   int                               nOrient
 , int                               nPos
-, bool                              bRefresh
+, bool                              WXUNUSED(bRefresh)
 )
 {
     if (nOrient == wxHORIZONTAL )
         ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
     else
         ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
-} // end of wxWindowOS2::SetScrollPos(
+} // end of wxWindowOS2::SetScrollPos
 
 void wxWindowOS2::SetScrollbar(
   int                               nOrient
 , int                               nPos
 , int                               nThumbVisible
 , int                               nRange
-, bool                              bRefresh
+, bool                              WXUNUSED(bRefresh)
 )
 {
     int                             nOldRange = nRange - nThumbVisible;
@@ -762,7 +764,7 @@ void wxWindowOS2::SetScrollbar(
     int                             nPageSize = nThumbVisible;
     SBCDATA                         vInfo;
     HWND                            hWnd = GetHwnd();
-    ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
+    ULONG                           ulStyle = WS_VISIBLE;
     RECTL                           vRect;
 
     ::WinQueryWindowRect(hWnd, &vRect);
@@ -796,7 +798,7 @@ void wxWindowOS2::SetScrollbar(
                                                     ,20
                                                     ,hWnd
                                                     ,HWND_TOP
-                                                    ,FID_HORZSCROLL
+                                                    ,60000
                                                     ,&vInfo
                                                     ,NULL
                                                    );
@@ -846,7 +848,7 @@ void wxWindowOS2::SetScrollbar(
                                                     ,vRect.yTop - (vRect.yBottom + 20)
                                                     ,hWnd
                                                     ,HWND_TOP
-                                                    ,FID_VERTSCROLL
+                                                    ,60001
                                                     ,&vInfo
                                                     ,NULL
                                                    );
@@ -890,10 +892,13 @@ void wxWindowOS2::ScrollWindow(
 , const wxRect*                     pRect
 )
 {
+    nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
     RECTL                           vRect;
     RECTL                           vRect2;
+    RECTL                           vRectHorz;
+    RECTL                           vRectVert;
+    RECTL                           vRectChild;
 
-    nDy *= -1; // flip the sign of Dy as OS/2 is opposite wxWin.
     if (pRect)
     {
         vRect2.xLeft   = pRect->x;
@@ -903,36 +908,28 @@ void wxWindowOS2::ScrollWindow(
     }
     else
     {
-        ::WinQueryWindowRect(GetHwnd(), &vRect2);
-        ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect);
+        ::WinQueryWindowRect(GetHwnd(), &vRect);
+        ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRectHorz);
         vRect2.yBottom += vRect.yTop - vRect.yBottom;
-        ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect);
+        ::WinQueryWindowRect(m_hWndScrollBarVert, &vRectVert);
         vRect2.xRight -= vRect.xRight - vRect.xLeft;
 
     }
-    if (pRect)
-        ::WinScrollWindow( GetHwnd()
-                          ,(LONG)nDx
-                          ,(LONG)nDy
-                          ,&vRect2
-                          ,NULL
-                          ,NULLHANDLE
-                          ,NULL
-                          ,SW_INVALIDATERGN
-                         );
-    else
-        ::WinScrollWindow( GetHwnd()
-                          ,nDx
-                          ,nDy
-                          ,NULL
-                          ,NULL
-                          ,NULLHANDLE
-                          ,NULL
-                          ,SW_INVALIDATERGN
-                         );
+    ::WinScrollWindow( GetHwnd()
+                      ,(LONG)nDx
+                      ,(LONG)nDy
+                      ,&vRect
+                      ,NULL
+                      ,NULLHANDLE
+                      ,NULL
+                      ,SW_INVALIDATERGN
+                     );
+    ::WinInvalidateRect(m_hWndScrollBarHorz, &vRectHorz, FALSE);
+    ::WinInvalidateRect(m_hWndScrollBarVert, &vRectVert, FALSE);
 
     //
     // Move the children
+    //
     wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
     SWP                             vSwp;
 
@@ -943,31 +940,53 @@ void wxWindowOS2::ScrollWindow(
         if (pChildWin->GetHWND() != NULLHANDLE)
         {
             ::WinQueryWindowPos(pChildWin->GetHWND(), &vSwp);
-            ::WinQueryWindowRect(pChildWin->GetHWND(), &vRect);
-            if (pChildWin->GetHWND() == m_hWndScrollBarVert ||
-                pChildWin->GetHWND() == m_hWndScrollBarHorz)
+            ::WinQueryWindowRect(pChildWin->GetHWND(), &vRectChild);
+            if (pChildWin->IsKindOf(CLASSINFO(wxControl)))
             {
-                ::WinSetWindowPos( pChildWin->GetHWND()
-                                  ,HWND_TOP
-                                  ,vSwp.x + nDx
-                                  ,vSwp.y + nDy
-                                  ,0
-                                  ,0
-                                  ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
-                                 );
+                wxControl*          pCtrl;
+
+                //
+                // Must deal with controls that have margins like ENTRYFIELD.  The SWP
+                // struct of such a control will have and origin offset from its intended
+                // position by the width of the margins.
+                //
+                pCtrl = wxDynamicCast(pChildWin, wxControl);
+                vSwp.y -= pCtrl->GetYComp();
+                vSwp.x -= pCtrl->GetXComp();
             }
-            else
+            ::WinSetWindowPos( pChildWin->GetHWND()
+                              ,HWND_BOTTOM
+                              ,vSwp.x + nDx
+                              ,vSwp.y + nDy
+                              ,0
+                              ,0
+                              ,SWP_MOVE | SWP_ZORDER
+                             );
+            if (pChildWin->IsKindOf(CLASSINFO(wxRadioBox)))
             {
-                ::WinSetWindowPos( pChildWin->GetHWND()
-                                  ,HWND_BOTTOM
-                                  ,vSwp.x + nDx
-                                  ,vSwp.y + nDy
-                                  ,0
-                                  ,0
-                                  ,SWP_MOVE | SWP_ZORDER
-                                 );
-                ::WinInvalidateRect(pChildWin->GetHWND(), &vRect, FALSE);
+                wxRadioBox*         pRadioBox;
+
+                pRadioBox = wxDynamicCast(pChildWin, wxRadioBox);
+                pRadioBox->AdjustButtons( (int)vSwp.x + nDx
+                                         ,(int)vSwp.y + nDy
+                                         ,(int)vSwp.cx
+                                         ,(int)vSwp.cy
+                                         ,pRadioBox->GetSizeFlags()
+                                        );
             }
+            if (pChildWin->IsKindOf(CLASSINFO(wxSlider)))
+            {
+                wxSlider*           pSlider;
+
+                pSlider = wxDynamicCast(pChildWin, wxSlider);
+                pSlider->AdjustSubControls( (int)vSwp.x + nDx
+                                           ,(int)vSwp.y + nDy
+                                           ,(int)vSwp.cx
+                                           ,(int)vSwp.cy
+                                           ,pSlider->GetSizeFlags()
+                                          );
+            }
+            ::WinInvalidateRect(pChildWin->GetHWND(), &vRectChild, FALSE);
         }
         pCurrent = pCurrent->GetNext();
     }
@@ -983,9 +1002,20 @@ void wxWindowOS2::SubclassWin(
 {
     HWND                            hwnd = (HWND)hWnd;
 
-    wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
-    m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
+    wxAssociateWinWithHandle( hWnd
+                             ,(wxWindow*)this
+                            );
+    if (!wxCheckWindowWndProc( hWnd
+                              ,(WXFARPROC)wxWndProc
+                             ))
+    {
+        m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
+    }
+    else
+    {
+        m_fnOldWndProc = (WXFARPROC)NULL;
+    }
 } // end of wxWindowOS2::SubclassWin
 
 void wxWindowOS2::UnsubclassWin()
@@ -1009,6 +1039,19 @@ void wxWindowOS2::UnsubclassWin()
     }
 } // end of wxWindowOS2::UnsubclassWin
 
+bool wxCheckWindowWndProc(
+  WXHWND                            hWnd
+, WXFARPROC                         fnWndProc
+)
+{
+    static char                     zBuffer[512];
+    CLASSINFO                       vCls;
+
+    ::WinQueryClassName((HWND)hWnd, (LONG)512, (PCH)zBuffer);
+    ::WinQueryClassInfo(wxGetInstance(), (PSZ)zBuffer, &vCls);
+    return(fnWndProc == (WXFARPROC)vCls.pfnWindowProc);
+} // end of WinGuiBase_CheckWindowWndProc
+
 //
 // Make a Windows extended style from the given wxWindows window style
 //
@@ -1162,7 +1205,7 @@ void wxWindowOS2::SetupColours()
 } // end of wxWindowOS2::SetupColours
 
 void wxWindowOS2::OnIdle(
-  wxIdleEvent&                      rEvent
+  wxIdleEvent&                      WXUNUSED(rEvent)
 )
 {
     //
@@ -1224,7 +1267,7 @@ bool wxWindowOS2::Reparent(
 
 void wxWindowOS2::Clear()
 {
-    wxClientDC                      vDc(this);
+    wxClientDC                      vDc((wxWindow*)this);
     wxBrush                         vBrush( GetBackgroundColour()
                                            ,wxSOLID
                                           );
@@ -1233,6 +1276,27 @@ void wxWindowOS2::Clear()
     vDc.Clear();
 } // end of wxWindowOS2::Clear
 
+void wxWindowOS2::Update()
+{
+    ::WinUpdateWindow(GetHwnd());
+} // end of wxWindowOS2::Update
+
+void wxWindowOS2::Freeze()
+{
+   ::WinSendMsg(GetHwnd(), WM_VRNDISABLED, (MPARAM)0, (MPARAM)0);
+} // end of wxWindowOS2::Freeze
+
+void wxWindowOS2::Thaw()
+{
+   ::WinSendMsg(GetHwnd(), WM_VRNENABLED, (MPARAM)TRUE, (MPARAM)0);
+
+    //
+    // We need to refresh everything or otherwise he invalidated area is not
+    // repainted.
+    //
+    Refresh();
+} // end of wxWindowOS2::Thaw
+
 void wxWindowOS2::Refresh(
   bool                              bEraseBack
 , const wxRect*                     pRect
@@ -1320,9 +1384,17 @@ void wxWindowOS2::DoGetSize(
 , int*                              pHeight
 ) const
 {
-    HWND                            hWnd = GetHwnd();
+    HWND                            hWnd;
     RECTL                           vRect;
 
+    if (IsKindOf(CLASSINFO(wxFrame)))
+    {
+        wxFrame*                    pFrame = wxDynamicCast(this, wxFrame);
+        hWnd = pFrame->GetFrame();
+    }
+    else
+        hWnd = GetHwnd();
+
     ::WinQueryWindowRect(hWnd, &vRect);
 
     if (pWidth)
@@ -1338,43 +1410,32 @@ void wxWindowOS2::DoGetPosition(
 ) const
 {
     HWND                            hWnd = GetHwnd();
-    RECT                            vRect;
+    SWP                             vSwp;
     POINTL                          vPoint;
+    wxWindow*                       pParent = GetParent();
 
-    ::WinQueryWindowRect(hWnd, &vRect);
+    //
+    // It would seem that WinQueryWindowRect would be the correlary to
+    // the WIN32 WinGetRect, but unlike WinGetRect which returns the window
+    // origin position in screen coordinates, WinQueryWindowRect returns it
+    // relative to itself, i.e. (0,0).  To get the same under PM we must
+    // us WinQueryWindowPos.  This call, unlike the WIN32 call, however,
+    // returns a position relative to it's parent, so no parent adujstments
+    // are needed under OS/2.  Also, windows should be created using
+    // wxWindow coordinates, i.e 0,0 is the TOP left so vSwp will already
+    // reflect that.
+    //
+    ::WinQueryWindowPos(hWnd, &vSwp);
 
-    vPoint.x = vRect.xLeft;
-    vPoint.y = vRect.yBottom;
+    vPoint.x = vSwp.x;
+    vPoint.y = vSwp.y;
 
     //
-    // We do the adjustments with respect to the parent only for the "real"
-    // children, not for the dialogs/frames
+    // We may be faking the client origin. So a window that's really at (0,
+    // 30) may appear (to wxWin apps) to be at (0, 0).
     //
-    if (!IsTopLevel())
+    if (pParent)
     {
-        HWND                        hParentWnd = 0;
-        wxWindow*                   pParent = GetParent();
-
-        if (pParent)
-            hParentWnd = GetWinHwnd(pParent);
-
-        //
-        // Since we now have the absolute screen coords, if there's a parent we
-        // must subtract its bottom left corner
-        //
-        if (hParentWnd)
-        {
-            RECTL                   vRect2;
-
-            ::WinQueryWindowRect(hParentWnd, &vRect2);
-            vPoint.x -= vRect.xLeft;
-            vPoint.y -= vRect.yBottom;
-        }
-
-        //
-        // We may be faking the client origin. So a window that's really at (0,
-        // 30) may appear (to wxWin apps) to be at (0, 0).
-        //
         wxPoint                     vPt(pParent->GetClientAreaOrigin());
 
         vPoint.x -= vPt.x;
@@ -1398,9 +1459,9 @@ void wxWindowOS2::DoScreenToClient(
     ::WinQueryWindowPos(hWnd, &vSwp);
 
     if (pX)
-        *pX -= vSwp.x;
+        *pX += vSwp.x;
     if (pY)
-        *pY -= vSwp.y;
+        *pY += vSwp.y;
 } // end of wxWindowOS2::DoScreenToClient
 
 void wxWindowOS2::DoClientToScreen(
@@ -1429,22 +1490,68 @@ void wxWindowOS2::DoGetClientSize(
 ) const
 {
     HWND                            hWnd = GetHwnd();
-    HWND                            hWndClient;
     RECTL                           vRect;
 
-    if (IsKindOf(CLASSINFO(wxFrame)))
-        hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
-    else
-        hWndClient = NULLHANDLE;
-    if( hWndClient == NULLHANDLE)
-       ::WinQueryWindowRect(GetHwnd(), &vRect);
-    else
-       ::WinQueryWindowRect(hWndClient, &vRect);
+   ::WinQueryWindowRect(hWnd, &vRect);
+    if (IsKindOf(CLASSINFO(wxDialog)))
+    {
+        RECTL                       vTitle;
+        HWND                        hWndTitle;
+        //
+        // For a Dialog we have to explicitly request the client portion.
+        // For a Frame the hWnd IS the client window
+        //
+        hWndTitle = ::WinWindowFromID(hWnd, FID_TITLEBAR);
+        if (::WinQueryWindowRect(hWndTitle, &vTitle))
+        {
+            if (vTitle.yTop - vTitle.yBottom == 0)
+            {
+                //
+                // Dialog has not been created yet, use a default
+                //
+                vTitle.yTop = 20;
+            }
+            vRect.yTop -= (vTitle.yTop - vTitle.yBottom);
+        }
 
+        ULONG                       uStyle = ::WinQueryWindowULong(hWnd, QWL_STYLE);
+
+        //
+        // Deal with borders
+        //
+        if (uStyle & FCF_DLGBORDER)
+        {
+            vRect.xLeft += 4;
+            vRect.xRight -= 4;
+            vRect.yTop -= 4;
+            vRect.yBottom += 4;
+        }
+        else if (uStyle & FCF_SIZEBORDER)
+        {
+            vRect.xLeft += 4;
+            vRect.xRight -= 4;
+            vRect.yTop -= 4;
+            vRect.yBottom += 4;
+        }
+        else if (uStyle & FCF_BORDER)
+        {
+            vRect.xLeft += 2;
+            vRect.xRight -= 2;
+            vRect.yTop -= 2;
+            vRect.yBottom += 2;
+        }
+        else // make some kind of adjustment or top sizers ram into the titlebar!
+        {
+            vRect.xLeft += 3;
+            vRect.xRight -= 3;
+            vRect.yTop -= 3;
+            vRect.yBottom += 3;
+        }
+    }
     if (pWidth)
-        *pWidth  = vRect.xRight;
+        *pWidth  = vRect.xRight - vRect.xLeft;
     if (pHeight)
-        *pHeight = vRect.yTop;
+        *pHeight = vRect.yTop - vRect.yBottom;
 } // end of wxWindowOS2::DoGetClientSize
 
 void wxWindowOS2::DoMoveWindow(
@@ -1454,29 +1561,31 @@ void wxWindowOS2::DoMoveWindow(
 , int                               nHeight
 )
 {
-#if 0 // x and y coords should already be in os2 coordinates
     RECTL                           vRect;
     HWND                            hParent;
     wxWindow*                       pParent = GetParent();
 
-    if (pParent)
-        hParent = GetWinHwnd(pParent);
+    if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
+    {
+        int                         nOS2Height = GetOS2ParentHeight(pParent);
+
+        nY = nOS2Height - (nY + nHeight);
+    }
     else
-        hParent = HWND_DESKTOP;
-    ::WinQueryWindowRect(hParent, &vRect);
-    nY = vRect.yTop - (nY + nHeight);
-#endif
-    if ( !::WinSetWindowPos( GetHwnd()
-                            ,HWND_TOP
-                            ,(LONG)nX
-                            ,(LONG)nY
-                            ,(LONG)nWidth
-                            ,(LONG)nHeight
-                            ,SWP_SIZE | SWP_MOVE
-                           ))
     {
-        wxLogLastError("MoveWindow");
+        RECTL                       vRect;
+
+        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
+        nY = vRect.yTop - (nY + nHeight);
     }
+    ::WinSetWindowPos( GetHwnd()
+                      ,HWND_TOP
+                      ,(LONG)nX
+                      ,(LONG)nY
+                      ,(LONG)nWidth
+                      ,(LONG)nHeight
+                      ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW
+                     );
 } // end of wxWindowOS2::DoMoveWindow
 
 //
@@ -1506,21 +1615,33 @@ void wxWindowOS2::DoSetSize(
     int                             nCurrentHeight;
     wxSize                          vSize(-1, -1);
 
-    GetPosition( &nCurrentX
-                ,&nCurrentY
-               );
-    GetSize( &nCurrentWidth
-            ,&nCurrentHeight
-           );
+    GetPosition(&nCurrentX, &nCurrentY);
+    GetSize(&nCurrentWidth, &nCurrentHeight);
 
     //
     // ... and don't do anything (avoiding flicker) if it's already ok
     //
-    if ( nX == nCurrentX &&
-         nY == nCurrentY &&
-         nWidth == nCurrentWidth &&
-         nHeight == nCurrentHeight
-       )
+    //
+    // Must convert Y coords to test for equality under OS/2
+    //
+    int                             nY2 = nY;
+    wxWindow*                       pParent = (wxWindow*)GetParent();
+
+    if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
+    {
+        int                         nOS2Height = GetOS2ParentHeight(pParent);
+
+        nY2 = nOS2Height - (nY2 + nHeight);
+    }
+    else
+    {
+        RECTL                       vRect;
+
+        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
+        nY2 = vRect.yTop - (nY2 + nHeight);
+    }
+    if (nX == nCurrentX && nY2 == nCurrentY &&
+        nWidth == nCurrentWidth && nHeight == nCurrentHeight)
     {
         return;
     }
@@ -1530,10 +1651,7 @@ void wxWindowOS2::DoSetSize(
     if (nY == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE))
         nY = nCurrentY;
 
-    AdjustForParentClientOrigin( nX
-                                ,nY
-                                ,nSizeFlags
-                               );
+    AdjustForParentClientOrigin(nX, nY, nSizeFlags);
 
     if (nWidth == -1)
     {
@@ -1583,33 +1701,20 @@ void wxWindowOS2::DoSetClientSize(
     wxWindow*                       pParent = GetParent();
     HWND                            hWnd = GetHwnd();
     HWND                            hParentWnd = (HWND)0;
-    HWND                            hClientWnd = (HWND)0;
+    POINTL                          vPoint;
     RECTL                           vRect;
-    RECT                            vRect2;
-    RECT                            vRect3;
+    RECTL                           vRect2;
+    RECTL                           vRect3;
+    HWND                            hClientWnd = (HWND)0;
 
-    hClientWnd = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
+    hClientWnd = ::WinWindowFromID(hWnd, FID_CLIENT);
     ::WinQueryWindowRect(hClientWnd, &vRect2);
-
-    if (pParent)
-        hParentWnd = (HWND) pParent->GetHWND();
-
     ::WinQueryWindowRect(hWnd, &vRect);
     ::WinQueryWindowRect(hParentWnd, &vRect3);
-    //
-    // Find the difference between the entire window (title bar and all)
-    // and the client area; add this to the new client size to move the
-    // window. OS/2 is backward from windows on height
-    //
+
     int                             nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
     int                             nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight;
 
-    //
-    // If there's a parent, must subtract the parent's bottom left corner
-    // since MoveWindow moves relative to the parent
-    //
-    POINTL                          vPoint;
-
     vPoint.x = vRect2.xLeft;
     vPoint.y = vRect2.yBottom;
     if (pParent)
@@ -1618,18 +1723,9 @@ void wxWindowOS2::DoSetClientSize(
         vPoint.y -= vRect3.yBottom;
     }
 
-    DoMoveWindow( vPoint.x
-                 ,vPoint.y
-                 ,nActualWidth
-                 ,nActualHeight
-                );
-
-    wxSizeEvent                     vEvent( wxSize( nWidth
-                                                  ,nHeight
-                                                 )
-                                           ,m_windowId
-                                          );
+    DoMoveWindow(vPoint.x, vPoint.y, nActualWidth, nActualHeight);
 
+    wxSizeEvent                     vEvent(wxSize(nWidth, nHeight), m_windowId);
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::DoSetClientSize
@@ -1639,29 +1735,6 @@ wxPoint wxWindowOS2::GetClientAreaOrigin() const
     return wxPoint(0, 0);
 } // end of wxWindowOS2::GetClientAreaOrigin
 
-void wxWindowOS2::AdjustForParentClientOrigin(
-  int&                              rX
-, int&                              rY
-, int                               nSizeFlags
-)
-{
-    //
-    // Don't do it for the dialogs/frames - they float independently of their
-    // parent
-    //
-    if (!IsTopLevel())
-    {
-        wxWindow*                   pParent = GetParent();
-
-        if (!(nSizeFlags & wxSIZE_NO_ADJUSTMENTS) && pParent)
-        {
-            wxPoint                 vPoint(pParent->GetClientAreaOrigin());
-            rX += vPoint.x;
-            rY += vPoint.y;
-        }
-    }
-} // end of wxWindowOS2::AdjustForParentClientOrigin
-
 // ---------------------------------------------------------------------------
 // text metrics
 // ---------------------------------------------------------------------------
@@ -1670,7 +1743,6 @@ int wxWindowOS2::GetCharHeight() const
 {
     HPS                             hPs;
     FONTMETRICS                     vFontMetrics;
-    BOOL                            bRc;
 
     hPs = ::WinGetPS(GetHwnd());
 
@@ -1708,48 +1780,114 @@ void wxWindowOS2::GetTextExtent(
 , const wxFont*                     pTheFont
 ) const
 {
-    const wxFont*                   pFontToUse = pTheFont;
-    HPS                             hPs;
+    POINTL                          avPoint[TXTBOX_COUNT];
+    POINTL                          vPtMin;
+    POINTL                          vPtMax;
+    int                             i;
+    int                             l;
+    FONTMETRICS                     vFM; // metrics structure
+    BOOL                            bRc;
+    char*                           pStr;
+    ERRORID                         vErrorCode; // last error id code
+    HPS                             hPS;
 
-    hPs = ::WinGetPS(GetHwnd());
-/*
-// TODO: Will have to play with fonts later
 
-    if (!pFontToUse)
-        pFontToUse = &m_font;
+    hPS = ::WinGetPS(GetHwnd());
 
-    HFONT                           hFnt = 0;
-    HFONT                           hFfontOld = 0;
+    l = rString.Length();
+    if (l > 0L)
+    {
+        pStr = (PCH)rString.c_str();
 
-    if (pFontToUse && pFontToUse->Ok())
+        //
+        // In world coordinates.
+        //
+        bRc = ::GpiQueryTextBox( hPS
+                                ,l
+                                ,pStr
+                                ,TXTBOX_COUNT // return maximum information
+                                ,avPoint      // array of coordinates points
+                               );
+        if (bRc)
+        {
+            vPtMin.x = avPoint[0].x;
+            vPtMax.x = avPoint[0].x;
+            vPtMin.y = avPoint[0].y;
+            vPtMax.y = avPoint[0].y;
+            for (i = 1; i < 4; i++)
+            {
+                if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
+                if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
+                if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
+                if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
+            }
+            bRc = ::GpiQueryFontMetrics( hPS
+                                        ,sizeof(FONTMETRICS)
+                                        ,&vFM
+                                       );
+            if (!bRc)
+            {
+                vPtMin.x = 0;
+                vPtMin.y = 0;
+                vPtMax.x = 0;
+                vPtMax.y = 0;
+            }
+        }
+        else
+        {
+            vPtMin.x = 0;
+            vPtMin.y = 0;
+            vPtMax.x = 0;
+            vPtMax.y = 0;
+        }
+    }
+    else
     {
-        ::GpiCreateLog
-        hFnt = (HFONT)((wxFont *)pFontToUse)->GetResourceHandle(); // const_cast
-        if (hFnt)
-            hFontOld = (HFONT)SelectObject(dc,fnt);
+        vPtMin.x = 0;
+        vPtMin.y = 0;
+        vPtMax.x = 0;
+        vPtMax.y = 0;
+    }
+    if (pX)
+        *pX = (vPtMax.x - vPtMin.x + 1);
+    if (pY)
+        *pY = (vPtMax.y - vPtMin.y + 1);
+    if (pDescent)
+    {
+        if (bRc)
+            *pDescent = vFM.lMaxDescender;
+        else
+            *pDescent = 0;
+    }
+    if (pExternalLeading)
+    {
+        if (bRc)
+            *pExternalLeading = vFM.lExternalLeading;
+        else
+            *pExternalLeading = 0;
     }
+    ::WinReleasePS(hPS);
+} // end of wxWindow::GetTextExtent
 
-    SIZE sizeRect;
-    TEXTMETRIC tm;
-    GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
-    GetTextMetrics(dc, &tm);
-
-    if ( fontToUse && fnt && hfontOld )
-        SelectObject(dc, hfontOld);
-
-    ReleaseDC(hWnd, dc);
-
-    if ( x )
-        *x = sizeRect.cx;
-    if ( y )
-        *y = sizeRect.cy;
-    if ( descent )
-        *descent = tm.tmDescent;
-    if ( externalLeading )
-        *externalLeading = tm.tmExternalLeading;
-*/
-    ::WinReleasePS(hPs);
-}
+bool wxWindowOS2::IsMouseInWindow() const
+{
+    //
+    // Get the mouse position
+    POINTL                          vPt;
+
+    ::WinQueryPointerPos(HWND_DESKTOP, &vPt);
+
+    //
+    // Find the window which currently has the cursor and go up the window
+    // chain until we find this window - or exhaust it
+    //
+    HWND                            hWnd = ::WinWindowFromPoint(HWND_DESKTOP, &vPt, TRUE);
+
+    while (hWnd && (hWnd != GetHwnd()))
+        hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
+
+    return hWnd != NULL;
+} // end of wxWindowOS2::IsMouseInWindow
 
 #if wxUSE_CARET && WXWIN_COMPATIBILITY
 // ---------------------------------------------------------------------------
@@ -1816,7 +1954,8 @@ void wxWindowOS2::GetCaretPos(
 // ---------------------------------------------------------------------------
 // popup menu
 // ---------------------------------------------------------------------------
-
+//
+#if wxUSE_MENUS_NATIVE
 static void wxYieldForCommandsOnly()
 {
     //
@@ -1825,27 +1964,25 @@ static void wxYieldForCommandsOnly()
     //
     QMSG                            vMsg;
 
-    while (::WinPeekMsg( vHabmain
-                        ,&vMsg
-                        ,(HWND)0
-                        ,WM_COMMAND
-                        ,WM_COMMAND
-                        ,PM_REMOVE
-                       ) && vMsg.msg != WM_QUIT)
+    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
 , int                               nX
 , int                               nY
 )
 {
-    HWND                            hWnd = GetHwnd();
-    HWND                            hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
+    HWND                            hWndOwner = GetHwnd();
+    HWND                            hWndParent = GetHwnd();
     HWND                            hMenu = GetHmenuOf(pMenu);
+    bool                            bIsWaiting = TRUE;
 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();
@@ -1856,26 +1993,31 @@ bool wxWindowOS2::DoPopupMenu(
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent
-                   ,hWnd
+                   ,hWndOwner
                    ,hMenu
                    ,nX
                    ,nY
                    ,0L
-                   ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD
+                   ,PU_HCONSTRAIN | PU_VCONSTRAIN | PU_MOUSEBUTTON1 | PU_KEYBOARD
                   );
-    // we need to do it righ now as otherwise the events are never going to be
-    // sent to wxCurrentPopupMenu from HandleCommand()
-    //
-    // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
-    // help and we'd still need wxYieldForCommandsOnly() as the menu may be
-    // destroyed as soon as we return (it can be a local variable in the caller
-    // for example) and so we do need to process the event immediately
-    wxYieldForCommandsOnly();
-    wxCurrentPopupMenu = NULL;
 
+    while(bIsWaiting)
+    {
+        QMSG                            vMsg;
+        BOOL                            bRc = ::WinGetMsg(vHabmain, &vMsg, HWND(NULL), 0, 0);
+
+        if (vMsg.msg == WM_MENUEND || vMsg.msg == WM_COMMAND)
+        {
+            bIsWaiting = FALSE;
+        }
+        ::WinDispatchMsg(vHabmain, (PQMSG)&vMsg);
+
+    }
+    wxCurrentPopupMenu = NULL;
     pMenu->SetInvokingWindow(NULL);
     return TRUE;
 } // end of wxWindowOS2::DoPopupMenu
+#endif // wxUSE_MENUS_NATIVE
 
 // ===========================================================================
 // pre/post message processing
@@ -1888,15 +2030,17 @@ MRESULT wxWindowOS2::OS2DefWindowProc(
 )
 {
     if (m_fnOldWndProc)
-        return (MRESULT)m_fnOldWndProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
+        return (MRESULT)m_fnOldWndProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam);
     else
-        return ::WinDefWindowProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
+        return ::WinDefWindowProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam);
 } // end of wxWindowOS2::OS2DefWindowProc
 
 bool wxWindowOS2::OS2ProcessMessage(
   WXMSG*                            pMsg
 )
 {
+// wxUniversal implements tab traversal itself
+#ifndef __WXUNIVERSAL__
     QMSG*                           pQMsg = (QMSG*)pMsg;
 
     if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL))
@@ -2005,18 +2149,10 @@ bool wxWindowOS2::OS2ProcessMessage(
                             bProcess = FALSE;
                         }
                         else
-                        {
-                            wxPanel*    pPanel = wxDynamicCast(this, wxPanel);
-                            wxButton*   pBtn = NULL;
-
-                            if (pPanel)
-                            {
-                                //
-                                // Panel may have a default button which should
-                                // be activated by Enter
-                                //
-                                pBtn = pPanel->GetDefaultItem();
-                            }
+                        {
+                            wxButton*   pBtn = wxDynamicCast( GetDefaultItem()
+                                                             ,wxButton
+                                                            );
 
                             if (pBtn && pBtn->IsEnabled())
                             {
@@ -2066,6 +2202,9 @@ bool wxWindowOS2::OS2ProcessMessage(
         if (::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0));
             return TRUE;
     }
+#else
+    pMsg = pMsg; // just shut up the compiler
+#endif // __WXUNIVERSAL__
 
 #if wxUSE_TOOLTIPS
     if ( m_tooltip )
@@ -2085,13 +2224,22 @@ bool wxWindowOS2::OS2TranslateMessage(
   WXMSG*                            pMsg
 )
 {
-#if wxUSE_ACCEL
+#if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
   return m_acceleratorTable.Translate(m_hWnd, pMsg);
 #else
+  pMsg = pMsg;
   return FALSE;
 #endif //wxUSE_ACCEL
 } // end of wxWindowOS2::OS2TranslateMessage
 
+bool wxWindowOS2::OS2ShouldPreProcessMessage(
+  WXMSG*                            pMsg
+)
+{
+    // preprocess all messages by default
+    return TRUE;
+} // end of wxWindowOS2::OS2ShouldPreProcessMessage
+
 // ---------------------------------------------------------------------------
 // message params unpackers
 // ---------------------------------------------------------------------------
@@ -2163,7 +2311,7 @@ void wxWindowOS2::UnpackMenuSelect(
 // Hook for new window just as it's being created, when the window isn't yet
 // associated with the handle
 //
-wxWindow*                           wxWndHook = NULL;
+wxWindowOS2*                         wxWndHook = NULL;
 
 //
 // Main window proc
@@ -2183,7 +2331,7 @@ MRESULT EXPENTRY wxWndProc(
                wxGetMessageName(ulMsg), wParam, lParam);
 #endif // __WXDEBUG__
 
-    wxWindow*                       pWnd = wxFindWinFromHandle((WXHWND)hWnd);
+    wxWindowOS2*                    pWnd = wxFindWinFromHandle((WXHWND)hWnd);
 
     //
     // When we get the first message for the HWND we just created, we associate
@@ -2234,10 +2382,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
     // Did we process the uMsg?
     //
     bool                            bProcessed = FALSE;
-    bool                            bAllow;
     MRESULT                         mResult;
-    WXHICON                         hIcon;
-    WXHBRUSH                        hBrush;
 
     //
     // For most messages we should return 0 when we do process the message
@@ -2281,6 +2426,42 @@ MRESULT wxWindowOS2::OS2WindowProc(
                                    );
             break;
 
+        case WM_WINDOWPOSCHANGED:
+
+            //
+            // Dialogs under OS/2 do not get WM_SIZE events at all.
+            // Instead they get this, which can function much like WM_SIZE
+            // PSWP contains the new sizes and positioning, PSWP+1 the old
+            // We use this because ADJUSTWINDOWPOS comes BEFORE the new
+            // position is added and our auto layout does a WinQueryWindowRect
+            // to get the CURRENT client size.  That is the size used to position
+            // child controls, so we need to already be sized
+            // in order to get the child controls positoned properly.
+            //
+            if (IsKindOf(CLASSINFO(wxDialog)) || IsKindOf(CLASSINFO(wxFrame)))
+            {
+                PSWP                pSwp = (PSWP)PVOIDFROMMP(wParam);
+                PSWP                pSwp2 = pSwp++;
+
+                if (!(pSwp->cx == pSwp2->cx &&
+                      pSwp->cy == pSwp2->cy))
+                    bProcessed = HandleSize( pSwp->cx
+                                            ,pSwp->cy
+                                            ,(WXUINT)lParam
+                                           );
+                if (IsKindOf(CLASSINFO(wxFrame)))
+                {
+                    wxFrame*            pFrame = wxDynamicCast(this, wxFrame);
+
+                    if (pFrame)
+                    {
+                        if (pFrame->GetStatusBar())
+                            pFrame->PositionStatusBar();
+                    }
+                }
+            }
+            break;
+
         case WM_ACTIVATE:
             {
                 WXWORD              wState;
@@ -2344,8 +2525,8 @@ MRESULT wxWindowOS2::OS2WindowProc(
         case WM_BUTTON3MOTIONEND:
         case WM_BUTTON3MOTIONSTART:
             {
-                short x = LOWORD(lParam);
-                short y = HIWORD(lParam);
+                short x = LOWORD(wParam);
+                short y = HIWORD(wParam);
 
                 bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam);
             }
@@ -2409,6 +2590,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
 
                 if (uKeyFlags & KC_KEYUP)
                 {
+                    //TODO: check if the cast to WXWORD isn't causing trouble
                     bProcessed = HandleKeyUp((WXDWORD)wParam, lParam);
                     break;
                 }
@@ -2487,6 +2669,48 @@ MRESULT wxWindowOS2::OS2WindowProc(
             }
             break;
 
+        case WM_CONTROL:
+            switch(SHORT2FROMMP(wParam))
+            {
+                case SPBN_UPARROW:
+                case SPBN_DOWNARROW:
+                case SPBN_CHANGE:
+                    {
+                        char        zVal[10];
+                        long        lVal;
+
+                        ::WinSendMsg( HWNDFROMMP(lParam)
+                                     ,SPBM_QUERYVALUE
+                                     ,&zVal
+                                     ,MPFROM2SHORT( (USHORT)10
+                                                   ,(USHORT)SPBQ_UPDATEIFVALID
+                                                  )
+                                    );
+                        lVal = atol(zVal);
+                        bProcessed = OS2OnScroll( wxVERTICAL
+                                                 ,(int)SHORT2FROMMP(wParam)
+                                                 ,(int)lVal
+                                                 ,HWNDFROMMP(lParam)
+                                                );
+                    }
+                    break;
+
+                case SLN_SLIDERTRACK:
+                    {
+                        HWND                hWnd = ::WinWindowFromID(GetHWND(), SHORT1FROMMP(wParam));
+                        wxWindowOS2*        pChild = wxFindWinFromHandle(hWnd);
+
+                        if (pChild->IsKindOf(CLASSINFO(wxSlider)))
+                            bProcessed = OS2OnScroll( wxVERTICAL
+                                                     ,(int)SHORT2FROMMP(wParam)
+                                                     ,(int)LONGFROMMP(lParam)
+                                                     ,hWnd
+                                                    );
+                    }
+                    break;
+            }
+            break;
+
 #if defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
         case WM_CTLCOLORCHANGE:
             {
@@ -2503,20 +2727,6 @@ MRESULT wxWindowOS2::OS2WindowProc(
             mResult = (MRESULT)(FALSE);
             break;
 
-        //
-        // Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to
-        // things such as colors and fonts and such
-        //
-        case WM_QUERYWINDOWPARAMS:
-            {
-                PWNDPARAMS          pWndParams = (PWNDPARAMS)wParam;
-
-                bProcessed = HandleWindowParams( pWndParams
-                                                ,lParam
-                                               );
-            }
-            break;
-
             // the return value for this message is ignored
         case WM_SYSCOLORCHANGE:
             bProcessed = HandleSysColorChange();
@@ -2526,11 +2736,6 @@ MRESULT wxWindowOS2::OS2WindowProc(
             bProcessed = HandlePaletteChanged();
             break;
 
-        case WM_PRESPARAMCHANGED:
-            bProcessed = HandlePresParamChanged(wParam);
-            break;
-
-
         // move all drag and drops to wxDrg
         case WM_ENDDRAG:
             bProcessed = HandleEndDrag(wParam);
@@ -2582,20 +2787,24 @@ MRESULT wxWindowOS2::OS2WindowProc(
 #endif // __WXDEBUG__
         if (IsKindOf(CLASSINFO(wxFrame)))
             mResult = ::WinDefWindowProc(m_hWnd, uMsg, wParam, lParam);
+        else if (IsKindOf(CLASSINFO(wxDialog)))
+            mResult = ::WinDefDlgProc( m_hWnd, uMsg, wParam, lParam);
         else
             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
     }
     return mResult;
 } // end of wxWindowOS2::OS2WindowProc
 
+#ifndef __EMX__
+// clashes with wxDlgProc in toplevel.cpp?
 //
 // Dialog window proc
 //
 MRESULT wxDlgProc(
-  HWND                              hWnd
+  HWND                              WXUNUSED(hWnd)
 , UINT                              uMsg
-, MPARAM                            wParam
-, MPARAM                            lParam)
+, MPARAM                            WXUNUSED(wParam)
+, MPARAM                            WXUNUSED(lParam))
 {
     if (uMsg == WM_INITDLG)
     {
@@ -2614,6 +2823,7 @@ MRESULT wxDlgProc(
         return (MRESULT)0;
     }
 } // end of wxDlgProc
+#endif
 
 wxWindow* wxFindWinFromHandle(
   WXHWND                            hWnd
@@ -2628,7 +2838,7 @@ wxWindow* wxFindWinFromHandle(
 
 void wxAssociateWinWithHandle(
   HWND                              hWnd
-, wxWindow*                         pWin
+, wxWindowOS2*                      pWin
 )
 {
     //
@@ -2658,7 +2868,7 @@ void wxAssociateWinWithHandle(
 } // end of wxAssociateWinWithHandle
 
 void wxRemoveHandleAssociation(
-  wxWindow*                         pWin
+  wxWindowOS2*                      pWin
 )
 {
     wxWinHandleList->DeleteObject(pWin);
@@ -2672,175 +2882,180 @@ void wxWindowOS2::OS2DestroyWindow()
 {
 }
 
-void wxWindowOS2::OS2DetachWindowMenu()
+bool wxWindowOS2::OS2GetCreateWindowCoords(
+  const wxPoint&                    rPos
+, const wxSize&                     rSize
+, int&                              rnX
+, int&                              rnY
+, int&                              rnWidth
+, int&                              rnHeight
+) const
 {
-    if (m_hMenu)
-    {
-        HMENU                       hMenu = (HMENU)m_hMenu;
-
-        int                         nN = (int)::WinSendMsg(hMenu, MM_QUERYITEMCOUNT, 0, 0);
-        int                         i;
-
-        for (i = 0; i < nN; i++)
-        {
-            wxChar                   zBuf[100];
-            int                      nChars = (int)::WinSendMsg( hMenu
-                                                                ,MM_QUERYITEMTEXT
-                                                                ,MPFROM2SHORT(i, nN)
-                                                                ,zBuf
-                                                               );
-            if (!nChars)
-            {
-                wxLogLastError(wxT("GetMenuString"));
-                continue;
-            }
+    bool                            bNonDefault = FALSE;
 
-            if (wxStrcmp(zBuf, wxT("&Window")) == 0)
-            {
-                ::WinSendMsg(hMenu, MM_DELETEITEM, MPFROM2SHORT(i, TRUE), 0);
-                break;
-            }
-        }
+    if (rPos.x == -1)
+    {
+        //
+        // If set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
+        // just as well set it to CW_USEDEFAULT as well
+        rnX = rnY = CW_USEDEFAULT;
+    }
+    else
+    {
+        rnX = rPos.x;
+        rnY = rPos.y == -1 ? CW_USEDEFAULT : rPos.y;
+        bNonDefault = TRUE;
+    }
+    if (rSize.x == -1)
+    {
+        //
+        // As abobe, h is not used at all in this case anyhow
+        //
+        rnWidth = rnHeight = CW_USEDEFAULT;
+    }
+    else
+    {
+        rnWidth  = rSize.x;
+        rnHeight = rSize.y == -1 ? CW_USEDEFAULT : rSize.y;
+        bNonDefault = TRUE;
     }
-} // end of wxWindowOS2::OS2DetachWindowMenu
+    return bNonDefault;
+} // end of wxWindowOS2::OS2GetCreateWindowCoords
 
 bool wxWindowOS2::OS2Create(
-  WXHWND                            hParent
-, PSZ                               zClass
-, const wxChar*                     zTitle
+  PSZ                               zClass
+, const char*                       zTitle
 , WXDWORD                           dwStyle
-, long                              lX
-, long                              lY
-, long                              lWidth
-, long                              lHeight
-, WXHWND                            hOwner
-, WXHWND                            hZOrder
-, unsigned long                     ulId
+, const wxPoint&                    rPos
+, const wxSize&                     rSize
 , void*                             pCtlData
-, void*                             pPresParams
 , WXDWORD                           dwExStyle
+, bool                              bIsChild
 )
 {
     ERRORID                         vError;
     wxString                        sError;
-    long                            lX1      = 0L;
-    long                            lY1      = 0L;
-    long                            lWidth1  = 20L;
-    long                            lHeight1 = 20L;
-    int                             nControlId = 0;
-    int                             nNeedsubclass = 0;
-    PCSZ                            pszClass = zClass;
-
-    //
-    // Find parent's size, if it exists, to set up a possible default
-    // panel size the size of the parent window
-    //
-    RECTL                           vParentRect;
-    HWND                            hWndClient;
-
-    lX1 = lX;
-    lY1 = lY;
-    if (lWidth > -1L)
-        lWidth1 = lWidth;
-    if (lHeight > -1L)
-        lHeight1 = lHeight;
-
-    wxWndHook = this;
+    int                             nX      = 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);
+
+    OS2GetCreateWindowCoords( rPos
+                             ,rSize
+                             ,nX
+                             ,nY
+                             ,nWidth
+                             ,nHeight
+                            );
 
-    //
-    // check to see if the new window is a standard control
-    //
-    if ((ULONG)zClass == (ULONG)WC_BUTTON ||
-        (ULONG)zClass == (ULONG)WC_COMBOBOX ||
-        (ULONG)zClass == (ULONG)WC_CONTAINER ||
-        (ULONG)zClass == (ULONG)WC_ENTRYFIELD ||
-        (ULONG)zClass == (ULONG)WC_FRAME ||
-        (ULONG)zClass == (ULONG)WC_LISTBOX ||
-        (ULONG)zClass == (ULONG)WC_MENU ||
-        (ULONG)zClass == (ULONG)WC_NOTEBOOK ||
-        (ULONG)zClass == (ULONG)WC_SCROLLBAR ||
-        (ULONG)zClass == (ULONG)WC_SPINBUTTON ||
-        (ULONG)zClass == (ULONG)WC_STATIC ||
-        (ULONG)zClass == (ULONG)WC_TITLEBAR ||
-        (ULONG)zClass == (ULONG)WC_VALUESET
-       )
-    {
-            nControlId = ulId;
-    }
+    if (GetWindowStyleFlag() & wxPOPUP_WINDOW)
+        hParent = HWND_DESKTOP;
     else
     {
-        // no standard controls
-        if(wxString (wxT("wxFrameClass")) == wxString(zClass) )
+        if ((bIsChild || HasFlag(wxFRAME_TOOL_WINDOW)) && pParent )
         {
-            pszClass =  WC_FRAME;
-            nNeedsubclass = 1;
+            //
+            // This is either a normal child window or a top level window with
+            // wxFRAME_TOOL_WINDOW style (see below)
+            //
+            hParent = GetHwndOf(pParent);
         }
         else
         {
-            nControlId = ulId;
-            if(nControlId < 0)
-                nControlId = FID_CLIENT;
+            //
+            // This is either a window for which no parent was specified (not
+            // much we can do then) or a frame without wxFRAME_TOOL_WINDOW
+            // style: we should use NULL parent HWND for it or it would be
+            // always on top of its parent which is not what we usually want
+            // (in fact, we only want it for frames with the special
+            // wxFRAME_TOOL_WINDOW as above)
+            //
+            hParent = NULL;
+        }
+    }
+    if (bIsChild)
+    {
+        lControlId = GetId();
+        if (GetWindowStyleFlag() & wxCLIP_SIBLINGS)
+        {
+            dwStyle |= WS_CLIPSIBLINGS;
         }
     }
-
     //
-    // We will either have a registered class via string name or a standard PM Class via a long
+    // For each class "Foo" we have we also have "FooNR" ("no repaint") class
+    // 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
     //
-    m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
-                                       ,zClass
-                                       ,(PSZ)zTitle ? zTitle : wxT("")
-                                       ,(ULONG)dwStyle
-                                       ,(LONG)lX1
-                                       ,(LONG)lY1
-                                       ,(LONG)lWidth
-                                       ,(LONG)lHeight
-                                       ,hOwner
-                                       ,HWND_TOP
-                                       ,(ULONG)nControlId
-                                       ,pCtlData
-                                       ,pPresParams
-                                      );
-    if (!m_hWnd)
+    if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE)
     {
-        vError = ::WinGetLastError(vHabmain);
-        sError = wxPMErrorToStr(vError);
-        wxLogError("Can't create window of class %s!. Error: %s\n", zClass, sError);
-        return FALSE;
+        sClassName += wxT("NR");
     }
-    m_dwExStyle = dwExStyle;
-    ::WinSetWindowULong(m_hWnd, QWL_USER, (ULONG) this);
-    wxWndHook = NULL;
 
-#ifdef __WXDEBUG__
-    wxNode*                         pNode = wxWinHandleList->Member(this);
-
-    if (pNode)
+    //
+    // If the window being created is a Frame's Statusbar we need to use
+    // the actual Frame's size, not its client
+    //
+    if (pParent)
     {
-        HWND                        hWnd = (HWND)pNode->GetKeyInteger();
-
-        if (hWnd != (HWND)m_hWnd)
-
+        if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+             pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+           )
         {
-            wxLogError("A second HWND association is being added for the same window!");
+            if (IsKindOf(CLASSINFO(wxStatusBar)) &&
+                pParent->IsKindOf(CLASSINFO(wxFrame)))
+            {
+                RECTL               vRect;
+                wxFrame*            pFrame = wxDynamicCast(pParent, wxFrame);
+
+                ::WinQueryWindowRect((HWND)pFrame->GetFrame(), &vRect);
+                nY = vRect.yTop - (nY + nHeight);
+            }
+            else
+                nY = pParent->GetSize().y - (nY + nHeight);
         }
     }
-#endif
-    wxAssociateWinWithHandle((HWND)m_hWnd
-                             ,this
-                            );
-    //
-    // Now need to subclass window.
-    //
-    if(!nNeedsubclass)
+    else
     {
-         wxAssociateWinWithHandle((HWND)m_hWnd,this);
+        RECTL                   vRect;
+
+        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
+        nY = vRect.yTop - (nY + nHeight);
     }
-    else
+    m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
+                                      ,(PSZ)sClassName.c_str()
+                                      ,(PSZ)zTitle ? zTitle : ""
+                                      ,(ULONG)dwStyle
+                                      ,(LONG)0L
+                                      ,(LONG)0L
+                                      ,(LONG)0L
+                                      ,(LONG)0L
+                                      ,NULLHANDLE
+                                      ,HWND_TOP
+                                      ,(ULONG)lControlId
+                                      ,pCtlData
+                                      ,NULL
+                                     );
+    if (!m_hWnd)
     {
-        SubclassWin(GetHWND());
+        vError = ::WinGetLastError(wxGetInstance());
+        sError = wxPMErrorToStr(vError);
+        return FALSE;
     }
+    SubclassWin(m_hWnd);
+    SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
+    SetSize( nX
+            ,nY
+            ,nWidth
+            ,nHeight
+           );
     return TRUE;
-} // end of wxWindowOS2::OS2Create
+} // end of WinGuiBase_Window::OS2Create
 
 // ===========================================================================
 // OS2 PM message handlers
@@ -2851,11 +3066,11 @@ bool wxWindowOS2::OS2Create(
 // ---------------------------------------------------------------------------
 
 bool wxWindowOS2::HandleCreate(
-  WXLPCREATESTRUCT                  vCs
+  WXLPCREATESTRUCT                  WXUNUSED(vCs)
 , bool*                             pbMayCreate
 )
 {
-    wxWindowCreateEvent             vEvent(this);
+    wxWindowCreateEvent             vEvent((wxWindow*)this);
 
     (void)GetEventHandler()->ProcessEvent(vEvent);
     *pbMayCreate = TRUE;
@@ -2864,7 +3079,7 @@ bool wxWindowOS2::HandleCreate(
 
 bool wxWindowOS2::HandleDestroy()
 {
-    wxWindowDestroyEvent            vEvent(this);
+    wxWindowDestroyEvent            vEvent((wxWindow*)this);
 
     (void)GetEventHandler()->ProcessEvent(vEvent);
 
@@ -2893,32 +3108,6 @@ void wxWindowOS2::OnSetFocus(
   wxFocusEvent&                     rEvent
 )
 {
-    //
-    // Panel wants to track the window which was the last to have focus in it,
-    // so we want to set ourselves as the window which last had focus
-    //
-    // Notice that it's also important to do it upwards the tree becaus
-    // otherwise when the top level panel gets focus, it won't set it back to
-    // us, but to some other sibling
-    //
-    wxWindow*                       pWin = this;
-
-    while (pWin)
-    {
-        wxWindow*                   pParent = pWin->GetParent();
-        wxPanel*                    pPanel = wxDynamicCast( pParent
-                                                           ,wxPanel
-                                                          );
-        if (pPanel)
-        {
-            pPanel->SetLastFocus(pWin);
-        }
-        pWin = pParent;
-    }
-
-    wxLogTrace(_T("focus"), _T("%s (0x%08x) gets focus"),
-               GetClassInfo()->GetClassName(), GetHandle());
-
     rEvent.Skip();
 } // end of wxWindowOS2::OnSetFocus
 
@@ -2939,6 +3128,13 @@ bool wxWindowOS2::HandleSetFocus(
   WXHWND                            WXUNUSED(hWnd)
 )
 {
+    //
+    // Notify the parent keeping track of focus for the kbd navigation
+    // purposes that we got it
+    //
+    wxChildFocusEvent               vEventFocus((wxWindow *)this);
+    (void)GetEventHandler()->ProcessEvent(vEventFocus);
+
 #if wxUSE_CARET
     //
     // Deal with caret
@@ -2949,16 +3145,14 @@ bool wxWindowOS2::HandleSetFocus(
     }
 #endif // wxUSE_CARET
 
-    //
-    // Panel wants to track the window which was the last to have focus in it
-    //
-    wxPanel*                        pPanel = wxDynamicCast( GetParent()
-                                                           ,wxPanel
-                                                          );
-    if (pPanel)
+#if wxUSE_TEXTCTRL
+    // If it's a wxTextCtrl don't send the event as it will be done
+    // after the control gets to process it from EN_FOCUS handler
+    if ( wxDynamicCastThis(wxTextCtrl) )
     {
-        pPanel->SetLastFocus(this);
+        return FALSE;
     }
+#endif // wxUSE_TEXTCTRL
 
     wxFocusEvent                    vEvent(wxEVT_SET_FOCUS, m_windowId);
 
@@ -2994,12 +3188,10 @@ bool wxWindowOS2::HandleKillFocus(
 
 bool wxWindowOS2::HandleShow(
   bool                              bShow
-, int                               nStatus
+, int                               WXUNUSED(nStatus)
 )
 {
-    wxShowEvent                     vEvent( GetId()
-                                           ,bShow
-                                          );
+    wxShowEvent                     vEvent(GetId(), bShow);
 
     vEvent.m_eventObject = this;
     return GetEventHandler()->ProcessEvent(vEvent);
@@ -3015,14 +3207,14 @@ bool wxWindowOS2::HandleInitDialog(
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleInitDialog
 
-bool wxWindowOS2::HandleEndDrag(WXWPARAM wParam)
+bool wxWindowOS2::HandleEndDrag(WXWPARAM WXUNUSED(wParam))
 {
    // TODO: We'll handle drag and drop later
     return FALSE;
 }
 
 bool wxWindowOS2::HandleSetCursor(
-  USHORT                            vId
+  USHORT                            WXUNUSED(vId)
 , WXHWND                            hPointer
 )
 {
@@ -3042,9 +3234,10 @@ bool wxWindowOS2::OS2OnDrawItem(
 , WXDRAWITEMSTRUCT*                 pItemStruct
 )
 {
+#if wxUSE_OWNER_DRAWN
     wxDC                            vDc;
 
-#if wxUSE_OWNER_DRAWN
+#if wxUSE_MENUS_NATIVE
     //
     // Is it a menu item?
     //
@@ -3179,6 +3372,7 @@ bool wxWindowOS2::OS2OnDrawItem(
         // otherwise, we'd have to do it ourselves.
         //
     }
+#endif // wxUSE_MENUS_NATIVE
 
     wxWindow*                       pItem = FindItem(vId);
 
@@ -3186,6 +3380,9 @@ bool wxWindowOS2::OS2OnDrawItem(
     {
         return ((wxControl *)pItem)->OS2OnDraw(pItemStruct);
     }
+#else
+    vId = vId;
+    pItemStruct = pItemStruct;
 #endif
     return FALSE;
 } // end of wxWindowOS2::OS2OnDrawItem
@@ -3195,6 +3392,7 @@ bool wxWindowOS2::OS2OnMeasureItem(
 , WXMEASUREITEMSTRUCT*              pItemStruct
 )
 {
+#if wxUSE_OWNER_DRAWN
     //
     // Is it a menu item?
     //
@@ -3230,6 +3428,10 @@ bool wxWindowOS2::OS2OnMeasureItem(
     {
         return ((wxControl *)pItem)->OS2OnMeasure(pItemStruct);
     }
+#else
+    lId = lId;
+    pItemStruct = pItemStruct;
+#endif // wxUSE_OWNER_DRAWN
     return FALSE;
 }
 
@@ -3246,7 +3448,7 @@ bool wxWindowOS2::HandleSysColorChange()
 } // end of wxWindowOS2::HandleSysColorChange
 
 bool wxWindowOS2::HandleCtlColor(
-  WXHBRUSH*                         phBrush
+  WXHBRUSH*                         WXUNUSED(phBrush)
 )
 {
     //
@@ -3255,22 +3457,14 @@ bool wxWindowOS2::HandleCtlColor(
     return TRUE;
 } // end of wxWindowOS2::HandleCtlColor
 
-bool wxWindowOS2::HandleWindowParams(
-  PWNDPARAMS                        pWndParams
-, WXLPARAM                          lParam
-)
-{
-// TODO: I'll do something here, just not sure what yet
-    return TRUE;
-}
 
 // Define for each class of dialog and control
-WXHBRUSH wxWindowOS2::OnCtlColor(WXHDC hDC,
-                              WXHWND hWnd,
-                              WXUINT nCtlColor,
-                              WXUINT message,
-                              WXWPARAM wParam,
-                              WXLPARAM lParam)
+WXHBRUSH wxWindowOS2::OnCtlColor(WXHDC WXUNUSED(hDC),
+                                 WXHWND WXUNUSED(hWnd),
+                                 WXUINT WXUNUSED(nCtlColor),
+                                 WXUINT WXUNUSED(message),
+                                 WXWPARAM WXUNUSED(wParam),
+                                 WXLPARAM WXUNUSED(lParam))
 {
     return (WXHBRUSH)0;
 }
@@ -3288,21 +3482,6 @@ bool wxWindowOS2::HandlePaletteChanged()
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandlePaletteChanged
 
-bool wxWindowOS2::HandlePresParamChanged(
-  WXWPARAM                          wParam
-)
-{
-    //
-    // TODO:  Once again I'll do something here when I need it
-    //
-    //wxQueryNewPaletteEvent event(GetId());
-    //event.SetEventObject(this);
-    // if the background is erased
-//            bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
-
-    return FALSE; //GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
-}
-
 //
 // Responds to colour changes: passes event on to children.
 //
@@ -3336,73 +3515,29 @@ void wxWindowOS2::OnSysColourChanged(
 
 bool wxWindowOS2::HandlePaint()
 {
-    HRGN                            hRgn = NULLHANDLE;
-    wxPaintEvent                    vEvent;
+    HRGN                            hRgn;
+    wxPaintEvent                    vEvent(m_windowId);
     HPS                             hPS;
     RECTL                           vRect;
+    bool                            bProcessed;
+
+    // Create empty region
+    // TODO: get HPS somewhere else if possible
+    hPS  = ::WinGetPS(GetHwnd());
+    hRgn = ::GpiCreateRegion(hPS, 0, NULL);
 
-    if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_NULL)
+    if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_ERROR)
     {
          wxLogLastError("CreateRectRgn");
          return FALSE;
     }
 
-    m_updateRegion = wxRegion(hRgn);
-    vEvent.SetEventObject(this);
-    if (!GetEventHandler()->ProcessEvent(vEvent))
-    {
-        HPS                         hPS;
-
-        hPS = ::WinBeginPaint( GetHwnd()
-                              ,NULLHANDLE
-                              ,&vRect
-                             );
-        if(hPS)
-        {
-            ::GpiCreateLogColorTable( hPS
-                                     ,0L
-                                     ,LCOLF_CONSECRGB
-                                     ,0L
-                                     ,(LONG)wxTheColourDatabase->m_nSize
-                                     ,(PLONG)wxTheColourDatabase->m_palTable
-                                    );
-            ::GpiCreateLogColorTable( hPS
-                                     ,0L
-                                     ,LCOLF_RGB
-                                     ,0L
-                                     ,0L
-                                     ,NULL
-                                    );
+    m_updateRegion = wxRegion(hRgn, hPS);
 
-            ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
+    vEvent.SetEventObject(this);
+    bProcessed = GetEventHandler()->ProcessEvent(vEvent);
 
-            if (m_dwExStyle)
-            {
-                LINEBUNDLE                      vLineBundle;
-
-                vLineBundle.lColor     = 0x00000000; // Black
-                vLineBundle.usMixMode  = FM_OVERPAINT;
-                vLineBundle.fxWidth    = 1;
-                vLineBundle.lGeomWidth = 1;
-                vLineBundle.usType     = LINETYPE_SOLID;
-                vLineBundle.usEnd      = 0;
-                vLineBundle.usJoin     = 0;
-                ::GpiSetAttrs( hPS
-                              ,PRIM_LINE
-                              ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
-                              ,0L
-                              ,&vLineBundle
-                             );
-                ::WinQueryWindowRect(GetHwnd(), &vRect);
-                wxDrawBorder( hPS
-                             ,vRect
-                             ,m_dwExStyle
-                            );
-            }
-            ::WinEndPaint(hPS);
-        }
-    }
-    return (GetEventHandler()->ProcessEvent(vEvent));
+    return GetEventHandler()->ProcessEvent(vEvent); //bProcessed;
 } // end of wxWindowOS2::HandlePaint
 
 bool wxWindowOS2::HandleEraseBkgnd(
@@ -3410,6 +3545,7 @@ bool wxWindowOS2::HandleEraseBkgnd(
 )
 {
     SWP                             vSwp;
+    bool                            rc;
 
     ::WinQueryWindowPos(GetHwnd(), &vSwp);
     if (vSwp.fl & SWP_MINIMIZE)
@@ -3418,14 +3554,14 @@ bool wxWindowOS2::HandleEraseBkgnd(
     wxDC                            vDC;
 
     vDC.m_hPS = (HPS)hDC; // this is really a PS
-    vDC.SetWindow(this);
+    vDC.SetWindow((wxWindow*)this);
     vDC.BeginDrawing();
 
     wxEraseEvent                    vEvent(m_windowId, &vDC);
 
     vEvent.SetEventObject(this);
 
-    bool                            rc = GetEventHandler()->ProcessEvent(vEvent);
+    rc = GetEventHandler()->ProcessEvent(vEvent);
 
     vDC.EndDrawing();
     vDC.m_hPS = NULLHANDLE;
@@ -3438,9 +3574,11 @@ void wxWindowOS2::OnEraseBackground(
 {
     RECTL                           vRect;
     HPS                             hPS = rEvent.m_dc->m_hPS;
+    APIRET                          rc;
+    LONG                            lColor = m_backgroundColour.GetPixel();
 
-    ::WinQueryWindowRect(GetHwnd(), &vRect);
-    ::WinFillRect(hPS, &vRect,  m_backgroundColour.GetPixel());
+    rc = ::WinQueryWindowRect(GetHwnd(), &vRect);
+    rc = ::WinFillRect(hPS, &vRect, lColor);
 }  // end of wxWindowOS2::OnEraseBackground
 
 // ---------------------------------------------------------------------------
@@ -3468,11 +3606,7 @@ bool wxWindowOS2::HandleMove(
 , int                               nY
 )
 {
-    wxMoveEvent                     vEvent( wxPoint( nX
-                                                    ,nY
-                                                   )
-                                           ,m_windowId
-                                          );
+    wxMoveEvent                     vEvent(wxPoint(nX, nY), m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
@@ -3484,11 +3618,7 @@ bool wxWindowOS2::HandleSize(
 , WXUINT                            WXUNUSED(nFlag)
 )
 {
-    wxSizeEvent                     vEvent( wxSize( nWidth
-                                                   ,nHeight
-                                                  )
-                                           ,m_windowId
-                                          );
+    wxSizeEvent                     vEvent(wxSize(nWidth, nHeight), m_windowId);
 
     vEvent.SetEventObject(this);
     return GetEventHandler()->ProcessEvent(vEvent);
@@ -3530,6 +3660,7 @@ bool wxWindowOS2::HandleCommand(
 , WXHWND                            hControl
 )
 {
+#if wxUSE_MENUS_NATIVE
     if (wxCurrentPopupMenu)
     {
         wxMenu*                     pPopupMenu = wxCurrentPopupMenu;
@@ -3537,6 +3668,7 @@ bool wxWindowOS2::HandleCommand(
         wxCurrentPopupMenu = NULL;
         return pPopupMenu->OS2Command(wCmd, wId);
     }
+#endif // wxUSE_MENUS_NATIVE
 
     wxWindow*                       pWin = FindItem(wId);
 
@@ -3546,15 +3678,14 @@ bool wxWindowOS2::HandleCommand(
     }
 
     if (pWin)
-        return pWin->OS2Command( wCmd
-                                ,wId
-                               );
+        return pWin->OS2Command(wCmd, wId);
+
     return FALSE;
 } // end of wxWindowOS2::HandleCommand
 
 bool wxWindowOS2::HandleSysCommand(
   WXWPARAM                          wParam
-, WXLPARAM                          lParam
+, WXLPARAM                          WXUNUSED(lParam)
 )
 {
     //
@@ -3574,7 +3705,7 @@ bool wxWindowOS2::HandleSysCommand(
 // ---------------------------------------------------------------------------
 // mouse events
 // ---------------------------------------------------------------------------
-
+//TODO!!! check against MSW
 void wxWindowOS2::InitMouseEvent(
   wxMouseEvent&                     rEvent
 , int                               nX
@@ -3717,7 +3848,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent(
 // WM_KEYDOWN one
 //
 bool wxWindowOS2::HandleChar(
-  WXWORD                            wParam
+  WXDWORD                           wParam
 , WXLPARAM                          lParam
 , bool                              isASCII
 )
@@ -3811,7 +3942,7 @@ bool wxWindowOS2::HandleKeyDown(
 } // end of wxWindowOS2::HandleKeyDown
 
 bool wxWindowOS2::HandleKeyUp(
-  WXWORD                            wParam
+  WXDWORD                           wParam
 , WXLPARAM                          lParam
 )
 {
@@ -3903,6 +4034,174 @@ bool wxWindowOS2::OS2OnScroll(
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::OS2OnScroll
 
+void wxWindowOS2::MoveChildren(
+  int                               nDiff
+)
+{
+    SWP                                 vSwp;
+
+    for (wxWindowList::Node* pNode = GetChildren().GetFirst();
+         pNode;
+         pNode = pNode->GetNext())
+    {
+        wxWindow*                   pWin = pNode->GetData();
+
+        ::WinQueryWindowPos( GetHwndOf(pWin)
+                            ,&vSwp
+                           );
+        if (pWin->IsKindOf(CLASSINFO(wxControl)))
+        {
+            wxControl*          pCtrl;
+
+            //
+            // Must deal with controls that have margins like ENTRYFIELD.  The SWP
+            // struct of such a control will have and origin offset from its intended
+            // position by the width of the margins.
+            //
+            pCtrl = wxDynamicCast(pWin, wxControl);
+            vSwp.y -= pCtrl->GetYComp();
+            vSwp.x -= pCtrl->GetXComp();
+        }
+        ::WinSetWindowPos( GetHwndOf(pWin)
+                          ,HWND_TOP
+                          ,vSwp.x
+                          ,vSwp.y - nDiff
+                          ,vSwp.cx
+                          ,vSwp.cy
+                          ,SWP_MOVE
+                         );
+        if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
+        {
+            wxRadioBox*     pRadioBox;
+
+            pRadioBox = wxDynamicCast(pWin, wxRadioBox);
+            pRadioBox->AdjustButtons( (int)vSwp.x
+                                     ,(int)vSwp.y - nDiff
+                                     ,(int)vSwp.cx
+                                     ,(int)vSwp.cy
+                                     ,pRadioBox->GetSizeFlags()
+                                    );
+        }
+        if (pWin->IsKindOf(CLASSINFO(wxSlider)))
+        {
+            wxSlider*           pSlider;
+
+            pSlider = wxDynamicCast(pWin, wxSlider);
+            pSlider->AdjustSubControls( (int)vSwp.x
+                                       ,(int)vSwp.y - nDiff
+                                       ,(int)vSwp.cx
+                                       ,(int)vSwp.cy
+                                       ,(int)pSlider->GetSizeFlags()
+                                      );
+        }
+    }
+} // end of 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
+//  the OS2 to wxWindows Y coordinate.
+//
+//  1)  The controls are created in a dialog.
+//      This is the easiest since a dialog is created with its original
+//      size so the standard: Y = ParentHeight - (Y + ControlHeight);
+//
+//  2)  The controls are direct children of a frame
+//      In this instance the controls are actually children of the Frame's
+//      client.  During creation the frame's client resizes several times
+//      during creation of the status bar and toolbars.  The CFrame class
+//      will take care of this using its AlterChildPos proc.
+//
+//  3)  The controls are children of a panel, which in turn is a child of
+//      a frame.
+//      This is the nastiest case.  A panel is created as the only child of
+//      the frame and as such, when a frame has only one child, the child is
+//      expanded to fit the entire client area of the frame.  Because the
+//      controls are created BEFORE this occurs their positions are totally
+//      whacked and any call to WinQueryWindowPos will return invalid
+//      coordinates.  So for this situation we have to compare the size of
+//      the panel at control creation time with that of the frame client.  If
+//      they are the same we can use the standard Y position equation.  If
+//      not, then we must use the Frame Client's dimensions to position them
+//      as that will be the eventual size of the panel after the frame resizes
+//      it!
+//
+int wxWindowOS2::GetOS2ParentHeight(
+  wxWindowOS2*               pParent
+)
+{
+    wxWindowOS2*             pGrandParent = NULL;
+
+    //
+    // Case 1
+    //
+    if (pParent->IsKindOf(CLASSINFO(wxDialog)))
+        return(pParent->GetClientSize().y);
+
+    //
+    // Case 2 -- if we are one of the separately built standard Frame
+    //           children, like a statusbar, menubar, or toolbar we want to
+    //           use the frame, itself, for positioning.  Otherwise we are
+    //           child window and want to use the Frame's client.
+    //
+    else if (pParent->IsKindOf(CLASSINFO(wxFrame)))
+    {
+        if (IsKindOf(CLASSINFO(wxStatusBar)) ||
+            IsKindOf(CLASSINFO(wxMenuBar))   ||
+            IsKindOf(CLASSINFO(wxToolBar))
+           )
+            return(pParent->GetSize().y);
+        else
+            return(pParent->GetClientSize().y);
+    }
+
+    //
+    // Case 3 -- this is for any window that is the sole child of a Frame.
+    //           The grandparent must exist and it must be of type CFrame
+    //           and it's height must be different. Otherwise the standard
+    //           applies.
+    //
+    else
+    {
+        pGrandParent = pParent->GetParent();
+        if (pGrandParent &&
+            pGrandParent->IsKindOf(CLASSINFO(wxFrame)) &&
+            pGrandParent->GetClientSize().y != pParent->GetSize().y
+           )
+        {
+            int                     nParentHeight = 0L;
+            int                     nStatusBarHeight = 0L;
+            wxFrame*                pFrame = wxDynamicCast(pGrandParent, wxFrame);
+            wxStatusBar*            pStatbar = pFrame->GetStatusBar();
+
+            nParentHeight = pGrandParent->GetClientSize().y;
+            if (pStatbar)
+                nStatusBarHeight = pStatbar->GetSize().y;
+            nParentHeight -= nStatusBarHeight;
+            return(nParentHeight);
+        }
+        else
+            //
+            // Panel is a child of some other kind of window so we'll
+            // just use it's original size
+            //
+            return(pParent->GetClientSize().y);
+    }
+    return(0L);
+} // end of wxWindowOS2::GetOS2ParentHeight
+
+wxWindowCreationHook::wxWindowCreationHook(
+  wxWindow*                         pWinBeingCreated
+)
+{
+    gpWinBeingCreated = pWinBeingCreated;
+} // end of wxWindowCreationHook::wxWindowCreationHook
+
+wxWindowCreationHook::~wxWindowCreationHook()
+{
+    gpWinBeingCreated = NULL;
+} // end of wxWindowCreationHook::~wxWindowCreationHook
+
 // ===========================================================================
 // global functions
 // ===========================================================================
@@ -3911,10 +4210,31 @@ void wxGetCharSize(
   WXHWND                            hWnd
 , int*                              pX
 , int*                              pY
-,wxFont*                            pTheFont
+,wxFont*                            WXUNUSED(pTheFont)
 )
 {
-  // TODO: we'll do this later
+    FONTMETRICS                     vFM;
+    HPS                             hPS;
+    BOOL                            rc;
+
+    hPS =::WinGetPS(hWnd);
+
+    rc = ::GpiQueryFontMetrics(hPS, sizeof(FONTMETRICS), &vFM);
+    if (rc)
+    {
+        if (pX)
+            *pX = vFM.lAveCharWidth;
+        if (pY)
+            *pY = vFM.lEmHeight + vFM.lExternalLeading;
+    }
+    else
+    {
+        if (pX)
+            *pX = 10;
+        if (pY)
+            *pY = 15;
+    }
+    ::WinReleasePS(hPS);
 } // end of wxGetCharSize
 
 //
@@ -4517,6 +4837,8 @@ const char* wxGetMessageName(
 
 #endif // __WXDEBUG__
 
+// Unused?
+#if 0
 static void TranslateKbdEventToMouse(
   wxWindow*                         pWin
 , int*                              pX
@@ -4545,11 +4867,12 @@ static void TranslateKbdEventToMouse(
 
     pWin->ScreenToClient(pX, pY);
 } // end of TranslateKbdEventToMouse
+#endif
 
 // Find the wxWindow at the current mouse position, returning the mouse
 // position.
 wxWindow* wxFindWindowAtPointer(
-  wxPoint&                          rPt
+  wxPoint&                          WXUNUSED(rPt)
 )
 {
     return wxFindWindowAtPoint(wxGetMousePosition());