]> 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
ignore clicks on a toolbar but outside any button
[wxWidgets.git] / src / os2 / window.cpp
diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index b9633091a441c03b62d6a87f00beb69f6b842c90..fd71c44b76688b8d61a125ea9d0ff9d59673fb6d 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -1,4 +1,3 @@
-/////////////////////////////////////////////////////////////////////////////
 // Name:        windows.cpp
 // Purpose:     wxWindow
 // Author:      David Webster
 // Name:        windows.cpp
 // Purpose:     wxWindow
 // Author:      David Webster
@@ -34,7 +33,11 @@
     #include "wx/button.h"
     #include "wx/msgdlg.h"
     #include "wx/scrolwin.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
 
     #include <stdio.h>
 #endif
 
@@ -102,9 +105,6 @@ QMSG                      s_currentMsg;
 wxMenu*                   wxCurrentPopupMenu = NULL;
 #endif // wxUSE_MENUS_NATIVE
 
 wxMenu*                   wxCurrentPopupMenu = NULL;
 #endif // wxUSE_MENUS_NATIVE
 
-#if !defined(__VISAGECPP__) || (__IBMCPP__ < 400)
-extern wxChar             wxCanvasClassName[];
-#endif
 wxList*                   wxWinHandleList = NULL;
 
 // ---------------------------------------------------------------------------
 wxList*                   wxWinHandleList = NULL;
 
 // ---------------------------------------------------------------------------
@@ -130,23 +130,14 @@ void      wxAssociateWinWithHandle( HWND         hWnd
                                   );
 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 
                                   );
 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; }
 //
 // 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
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // event tables
 // ---------------------------------------------------------------------------
@@ -300,8 +291,11 @@ void wxWindowOS2::Init()
     m_hWndScrollBarHorz = 0L;
     m_hWndScrollBarVert = 0L;
 
     m_hWndScrollBarHorz = 0L;
     m_hWndScrollBarVert = 0L;
 
+    memset(&m_vWinSwp, '\0', sizeof (SWP));
+
     //
     // Pass WM_GETDLGCODE to DefWindowProc()
     //
     // Pass WM_GETDLGCODE to DefWindowProc()
+    //
     m_lDlgCode = 0;
 
     m_nXThumbSize = 0;
     m_lDlgCode = 0;
 
     m_nXThumbSize = 0;
@@ -327,7 +321,6 @@ wxWindowOS2::~wxWindowOS2()
 {
     m_isBeingDeleted = TRUE;
 
 {
     m_isBeingDeleted = TRUE;
 
-    OS2DetachWindowMenu();
     for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
     {
         wxFrame*                    pFrame = wxDynamicCast(pWin, wxFrame);
     for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
     {
         wxFrame*                    pFrame = wxDynamicCast(pWin, wxFrame);
@@ -366,12 +359,24 @@ bool wxWindowOS2::Create(
 )
 {
     HWND                            hParent = NULLHANDLE;
 )
 {
     HWND                            hParent = NULLHANDLE;
-    wxPoint                         vPos = rPos; // The OS/2 position
     ULONG                           ulCreateFlags = 0;
     WXDWORD                         dwExStyle = 0;
 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 
     ULONG                           ulCreateFlags = 0;
     WXDWORD                         dwExStyle = 0;
 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 
+#if wxUSE_STATBOX
+    //
+    // wxGTK doesn't allow to create controls with static box as the parent so
+    // this will result in a crash when the program is ported to wxGTK - warn
+    // about it
+    //
+    // the correct solution is to create the controls as siblings of the
+    // static box
+    //
+    wxASSERT_MSG( !wxDynamicCast(pParent, wxStaticBox),
+                  _T("wxStaticBox can't be used as a window parent!") );
+#endif // wxUSE_STATBOX
+
     if ( !CreateBase( pParent
                      ,vId
                      ,rPos
     if ( !CreateBase( pParent
                      ,vId
                      ,rPos
@@ -400,62 +405,33 @@ bool wxWindowOS2::Create(
     // set in those class create procs.  PM's basic windows styles are
     // very limited.
     //
     // set in those class create procs.  PM's basic windows styles are
     // very limited.
     //
-    ulCreateFlags |=  WS_VISIBLE;
+    ulCreateFlags |=  WS_VISIBLE | OS2GetCreateWindowFlags(&dwExStyle);
 
 
 #ifdef __WXUNIVERSAL__
     // no 3d effects, we draw them ourselves
     WXDWORD exStyle = 0;
 
 
 #ifdef __WXUNIVERSAL__
     // no 3d effects, we draw them ourselves
     WXDWORD exStyle = 0;
-#else // !wxUniversal
-    if (lStyle & wxCLIP_SIBLINGS)
-        ulCreateFlags |= WS_CLIPSIBLINGS;
-
-    if (lStyle & wxCLIP_CHILDREN )
-        ulCreateFlags |= WS_CLIPCHILDREN;
-
-    //
-    //
-    //
-    bool                            bWant3D;
-    dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
-
-#endif
-
-    //
-    // Add the simple border style as we'll use this to draw borders
-    //
-    if (lStyle & wxSIMPLE_BORDER)
-        dwExStyle |= wxSIMPLE_BORDER;
-
+#endif // !wxUniversal
     if (lStyle & wxPOPUP_WINDOW)
     {
         // a popup window floats on top of everything
     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;
     }
 
     //
         // 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
               ,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
               ,dwExStyle
+              ,TRUE         // Child
              );
 
     return(TRUE);
              );
 
     return(TRUE);
@@ -549,7 +525,7 @@ wxString wxWindowOS2::GetTitle() const
     return wxGetWindowText(GetHWND());
 } // end of wxWindowOS2::GetTitle
 
     return wxGetWindowText(GetHWND());
 } // end of wxWindowOS2::GetTitle
 
-void wxWindowOS2::CaptureMouse()
+void wxWindowOS2::DoCaptureMouse()
 {
     HWND                            hWnd = GetHwnd();
 
 {
     HWND                            hWnd = GetHwnd();
 
@@ -560,7 +536,7 @@ void wxWindowOS2::CaptureMouse()
     }
 } // end of wxWindowOS2::GetTitle
 
     }
 } // end of wxWindowOS2::GetTitle
 
-void wxWindowOS2::ReleaseMouse()
+void wxWindowOS2::DoReleaseMouse()
 {
     if (m_bWinCaptured)
     {
 {
     if (m_bWinCaptured)
     {
@@ -587,77 +563,11 @@ bool wxWindowOS2::SetFont(
 
     HWND                            hWnd = GetHwnd();
 
 
     HWND                            hWnd = GetHwnd();
 
-    if (hWnd != 0)
-    {
-        char                        zFont[128];
-        char                        zFacename[30];
-        char                        zWeight[30];
-        char                        zStyle[30];
-
-        //
-        // The fonts available for Presentation Params are just three
-        // outline fonts, the rest are available to the GPI, so we must
-        // map the families to one of these three
-        //
-        switch(rFont.GetFamily())
-        {
-            case wxSCRIPT:
-            case wxDECORATIVE:
-            case wxROMAN:
-                strcpy(zFacename,"Times New Roman");
-                break;
-
-            case wxTELETYPE:
-            case wxMODERN:
-                strcpy(zFacename, "Courier");
-                break;
-
-            case wxSWISS:
-            case wxDEFAULT:
-            default:
-                strcpy(zFacename, "Helvetica");
-                break;
-        }
-
-        switch(rFont.GetWeight())
-        {
-            default:
-            case wxNORMAL:
-            case wxLIGHT:
-                zWeight[0] = '\0';
-                break;
-
-            case wxBOLD:
-            case wxFONTWEIGHT_MAX:
-                strcpy(zWeight, "Bold");
-                break;
-        }
-        switch(rFont.GetStyle())
-        {
-            case wxITALIC:
-            case wxSLANT:
-                strcpy(zStyle, "Italic");
-                break;
-
-            default:
-                zStyle[0] = '\0';
-                break;
-        }
-        sprintf(zFont, "%d.%s", rFont.GetPointSize(), zFacename);
-        if (zWeight[0] != '\0')
-        {
-            strcat(zFont, " ");
-            strcat(zFont, zWeight);
-        }
-        if (zStyle[0] != '\0')
-        {
-            strcat(zFont, " ");
-            strcat(zFont, zStyle);
-        }
-        ::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont) + 1, (PVOID)zFont);
-    }
+    wxOS2SetFont( hWnd
+                 ,rFont
+                );
     return(TRUE);
     return(TRUE);
-}
+} // end of wxWindowOS2::SetFont
 
 bool wxWindowOS2::SetCursor(
   const wxCursor&                   rCursor
 
 bool wxWindowOS2::SetCursor(
   const wxCursor&                   rCursor
@@ -829,15 +739,39 @@ void wxWindowOS2::SetScrollbar(
 , bool                              WXUNUSED(bRefresh)
 )
 {
 , bool                              WXUNUSED(bRefresh)
 )
 {
+    HWND                            hWnd = GetHwnd();
     int                             nOldRange = nRange - nThumbVisible;
     int                             nRange1 = nOldRange;
     int                             nPageSize = nThumbVisible;
     int                             nOldRange = nRange - nThumbVisible;
     int                             nRange1 = nOldRange;
     int                             nPageSize = nThumbVisible;
+
     SBCDATA                         vInfo;
     SBCDATA                         vInfo;
-    HWND                            hWnd = GetHwnd();
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
+    SWP                             vSwp;
+    SWP                             vSwpOwner;
     RECTL                           vRect;
     RECTL                           vRect;
+    HWND                            hWndParent;
+    HWND                            hWndClient;
+    wxWindow*                       pParent = GetParent();
+
+    if (pParent && pParent->IsKindOf(CLASSINFO(wxFrame)))
+    {
+        wxFrame*                    pFrame;
+
+        pFrame = wxDynamicCast(pParent, wxFrame);
+        hWndParent = pFrame->GetFrame();
+        hWndClient = GetHwndOf(pParent);
+    }
+    else
+    {
+        if (pParent)
+            hWndParent = GetHwndOf(pParent);
+        else
+            hWndParent = GetHwnd();
+        hWndClient = hWndParent;
+    }
+    ::WinQueryWindowPos(hWndClient, &vSwp);
+    ::WinQueryWindowPos(hWnd, &vSwpOwner);
 
 
-    ::WinQueryWindowRect(hWnd, &vRect);
     if (nPageSize > 1 && nRange > 0)
     {
         nRange1 += (nPageSize - 1);
     if (nPageSize > 1 && nRange > 0)
     {
         nRange1 += (nPageSize - 1);
@@ -854,53 +788,70 @@ void wxWindowOS2::SetScrollbar(
         if (m_hWndScrollBarHorz == 0L)
         {
             //
         if (m_hWndScrollBarHorz == 0L)
         {
             //
-            // We create the scrollbars with the desktop so that they are not
-            // registered as child windows of the window in order that child
-            // windows may be scrolled without scrolling the scrollbars themselves!
+            // Since the scrollbars are usually created before the owner is
+            // sized either via an OnSize event directly or via sizers or
+            // layout constraints, we will initially just use the coords of
+            // the parent window (this is usually a frame client window). But
+            // the bars themselves, are children of the parent frame (i.e
+            // siblings of the frame client.  The owner, however is the actual
+            // window being scrolled (or at least the one responsible for
+            // handling the scroll events). The owner will be resized later,
+            // as it is usually a child of a top level window, and when that
+            // is done its scrollbars will be resized and repositioned as well.
             //
             //
-            m_hWndScrollBarHorz = ::WinCreateWindow( hWnd
+            m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle
-                                                    ,vRect.xLeft
-                                                    ,vRect.yBottom
-                                                    ,vRect.xRight - vRect.xLeft
+                                                    ,vSwp.x
+                                                    ,vSwp.y
+                                                    ,vSwp.cx - 20
                                                     ,20
                                                     ,hWnd
                                                     ,HWND_TOP
                                                     ,20
                                                     ,hWnd
                                                     ,HWND_TOP
-                                                    ,FID_HORZSCROLL
+                                                    ,60000
                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {
                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {
-            RECTL                   vRect2;
-
             //
             //
-            // Only want to resize the scrollbar if it changes, otherwise
-            // we'd probably end up in a recursive loop until we crash the call stack
-            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
-            // generates those events.
+            // The owner (the scrolled window) is a child of the Frame's
+            // client window, usually.  The scrollbars are children of the
+            // frame, itself, and thus are positioned relative to the frame's
+            // origin, not the frame's client window origin.
+            // The starting x position is the same as the starting x position
+            // of the owner, but in terms of the parent frame.
+            // The starting y position is 20 pels below the origin of the
+            // owner in terms of the parent frame.
+            // The horz bar is the same width as the owner and 20 pels high.
             //
             //
-            ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect2);
-            if (!(vRect2.xLeft == vRect.xLeft     &&
-                  vRect2.xRight == vRect.xRight   &&
-                  vRect2.yBottom == vRect.yBottom &&
-                  vRect2.yTop == vRect.yTop
-                ) )
+            if (nRange1 >= nThumbVisible)
             {
                 ::WinSetWindowPos( m_hWndScrollBarHorz
                                   ,HWND_TOP
             {
                 ::WinSetWindowPos( m_hWndScrollBarHorz
                                   ,HWND_TOP
-                                  ,vRect.xLeft
-                                  ,vRect.yBottom
-                                  ,vRect.xRight - vRect.xLeft
+                                  ,vSwp.x + vSwpOwner.x
+                                  ,(vSwp.y + vSwpOwner.y) - 20
+                                  ,vSwpOwner.cx
                                   ,20
                                   ,20
-                                  ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
+                                  ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER
                                  );
                                  );
+                ::WinSendMsg( m_hWndScrollBarHorz
+                             ,SBM_SETSCROLLBAR
+                             ,(MPARAM)nPos
+                             ,MPFROM2SHORT(0, (SHORT)nRange1)
+                            );
+                ::WinSendMsg( m_hWndScrollBarHorz
+                             ,SBM_SETTHUMBSIZE
+                             ,MPFROM2SHORT( (SHORT)nThumbVisible
+                                           ,(SHORT)nRange1
+                                          )
+                             ,(MPARAM)0
+                            );
             }
             }
-            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
-            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+            else
+                ::WinShowWindow(m_hWndScrollBarHorz, FALSE);
         }
     }
     else
         }
     }
     else
@@ -908,49 +859,75 @@ void wxWindowOS2::SetScrollbar(
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {
-            m_hWndScrollBarVert = ::WinCreateWindow( hWnd
+            //
+            // Since the scrollbars are usually created before the owner is
+            // sized either via an OnSize event directly or via sizers or
+            // layout constraints, we will initially just use the coords of
+            // the parent window (this is usually a frame client window). But
+            // the bars themselves, are children of the parent frame (i.e
+            // siblings of the frame client.  The owner, however is the actual
+            // window being scrolled (or at least the one responsible for
+            // handling the scroll events). The owner will be resized later,
+            // as it is usually a child of a top level window, and when that
+            // is done its scrollbars will be resized and repositioned as well.
+            //
+            m_hWndScrollBarVert = ::WinCreateWindow( hWndParent
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle
-                                                    ,vRect.xRight - 20
-                                                    ,vRect.yBottom + 20
+                                                    ,vSwp.x + vSwp.cx - 20
+                                                    ,vSwp.y + 20
                                                     ,20
                                                     ,20
-                                                    ,vRect.yTop - (vRect.yBottom + 20)
+                                                    ,vSwp.cy - 20
                                                     ,hWnd
                                                     ,HWND_TOP
                                                     ,hWnd
                                                     ,HWND_TOP
-                                                    ,FID_VERTSCROLL
+                                                    ,60001
                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {
                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {
-            RECTL                   vRect2;
-
             //
             //
-            // Only want to resize the scrollbar if it changes, otherwise
-            // we'd probably end up in a recursive loop until we crash the call stack
-            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
-            // generates those events.
+            // The owner (the scrolled window) is a child of the Frame's
+            // client window, usually.  The scrollbars are children of the
+            // frame, itself and thus are positioned relative to the frame's
+            // origin, not the frame's client window's origin.
+            // Thus, the x position will be frame client's x (usually a few
+            // pels inside the parent frame, plus the width of the owner.
+            // Since we may be using sizers or layout constraints for multiple
+            // child scrolled windows, the y position will be the frame client's
+            // y pos plus the scrolled windows y position, yielding the y
+            // position of the scrollbar relative to the parent frame (the vert
+            // scrollbar is on the right and starts at the bottom of the
+            // owner window).
+            // It is 20 pels wide and the same height as the owner.
             //
             //
-            ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect2);
-            if (!(vRect2.xLeft == vRect.xLeft     &&
-                  vRect2.xRight == vRect.xRight   &&
-                  vRect2.yBottom == vRect.yBottom &&
-                  vRect2.yTop == vRect.yTop
-                ) )
+            if (nRange1 >= nThumbVisible)
             {
                 ::WinSetWindowPos( m_hWndScrollBarVert
                                   ,HWND_TOP
             {
                 ::WinSetWindowPos( m_hWndScrollBarVert
                                   ,HWND_TOP
-                                  ,vRect.xRight - 20
-                                  ,vRect.yBottom + 20
+                                  ,vSwp.x + vSwpOwner.x + vSwpOwner.cx
+                                  ,vSwp.y + vSwpOwner.y
                                   ,20
                                   ,20
-                                  ,vRect.yTop - (vRect.yBottom + 20)
+                                  ,vSwpOwner.cy
                                   ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
                                  );
                                   ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
                                  );
+                ::WinSendMsg( m_hWndScrollBarVert
+                             ,SBM_SETSCROLLBAR
+                             ,(MPARAM)nPos
+                             ,MPFROM2SHORT(0, (SHORT)nRange1)
+                            );
+                ::WinSendMsg( m_hWndScrollBarVert
+                             ,SBM_SETTHUMBSIZE
+                             ,MPFROM2SHORT( (SHORT)nThumbVisible
+                                           ,(SHORT)nRange1
+                                          )
+                             ,(MPARAM)0
+                            );
             }
             }
-            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
-            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+            else
+                ::WinShowWindow(m_hWndScrollBarVert, FALSE);
         }
         m_nYThumbSize = nThumbVisible;
     }
         }
         m_nYThumbSize = nThumbVisible;
     }
@@ -963,86 +940,32 @@ void wxWindowOS2::ScrollWindow(
 )
 {
     RECTL                           vRect;
 )
 {
     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)
     {
     if (pRect)
     {
-        vRect2.xLeft   = pRect->x;
-        vRect2.yTop    = pRect->y + pRect->height;
-        vRect2.xRight  = pRect->x + pRect->width;
-        vRect2.yBottom = pRect->y;
+        vRect.xLeft   = pRect->x;
+        vRect.yTop    = pRect->y + pRect->height;
+        vRect.xRight  = pRect->x + pRect->width;
+        vRect.yBottom = pRect->y;
     }
     else
     {
     }
     else
     {
-        ::WinQueryWindowRect(GetHwnd(), &vRect2);
-        ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect);
-        vRect2.yBottom += vRect.yTop - vRect.yBottom;
-        ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect);
-        vRect2.xRight -= vRect.xRight - vRect.xLeft;
-
-    }
-    if (pRect)
-        ::WinScrollWindow( GetHwnd()
-                          ,(LONG)nDx
-                          ,(LONG)nDy
-                          ,&vRect2
-                          ,NULL
-                          ,NULLHANDLE
-                          ,NULL
-                          ,SW_INVALIDATERGN
-                         );
-    else
-        ::WinScrollWindow( GetHwnd()
-                          ,nDx
-                          ,nDy
-                          ,NULL
-                          ,NULL
-                          ,NULLHANDLE
-                          ,NULL
-                          ,SW_INVALIDATERGN
-                         );
-
-    //
-    // Move the children
-    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
-    SWP                             vSwp;
-
-    while (pCurrent)
-    {
-        wxWindow*                   pChildWin = pCurrent->GetData();
-
-        if (pChildWin->GetHWND() != NULLHANDLE)
-        {
-            ::WinQueryWindowPos(pChildWin->GetHWND(), &vSwp);
-            ::WinQueryWindowRect(pChildWin->GetHWND(), &vRect);
-            if (pChildWin->GetHWND() == m_hWndScrollBarVert ||
-                pChildWin->GetHWND() == m_hWndScrollBarHorz)
-            {
-                ::WinSetWindowPos( pChildWin->GetHWND()
-                                  ,HWND_TOP
-                                  ,vSwp.x + nDx
-                                  ,vSwp.y + nDy
-                                  ,0
-                                  ,0
-                                  ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
-                                 );
-            }
-            else
-            {
-                ::WinSetWindowPos( pChildWin->GetHWND()
-                                  ,HWND_BOTTOM
-                                  ,vSwp.x + nDx
-                                  ,vSwp.y + nDy
-                                  ,0
-                                  ,0
-                                  ,SWP_MOVE | SWP_ZORDER
-                                 );
-                ::WinInvalidateRect(pChildWin->GetHWND(), &vRect, FALSE);
-            }
-        }
-        pCurrent = pCurrent->GetNext();
+        ::WinQueryWindowRect(GetHwnd(), &vRect);
     }
     }
+    nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
+    ::WinScrollWindow( GetHwnd()
+                      ,(LONG)nDx
+                      ,(LONG)nDy
+                      ,&vRect
+                      ,&vRect
+                      ,NULLHANDLE
+                      ,NULL
+                      ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
+                     );
+    Refresh();
 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
@@ -1055,9 +978,20 @@ void wxWindowOS2::SubclassWin(
 {
     HWND                            hwnd = (HWND)hWnd;
 
 {
     HWND                            hwnd = (HWND)hWnd;
 
-    wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
     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()
 } // end of wxWindowOS2::SubclassWin
 
 void wxWindowOS2::UnsubclassWin()
@@ -1081,6 +1015,82 @@ void wxWindowOS2::UnsubclassWin()
     }
 } // end of 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
+
+void wxWindowOS2::SetWindowStyleFlag(
+  long                              lFlags
+)
+{
+    long                            lFlagsOld = GetWindowStyleFlag();
+
+    if (lFlags == lFlagsOld)
+        return;
+
+    //
+    // Update the internal variable
+    //
+    wxWindowBase::SetWindowStyleFlag(lFlags);
+
+    //
+    // Now update the Windows style as well if needed - and if the window had
+    // been already created
+    //
+    if (!GetHwnd())
+        return;
+
+    WXDWORD                         dwExstyle;
+    WXDWORD                         dwExstyleOld;
+    long                            lStyle = OS2GetStyle( lFlags
+                                                         ,&dwExstyle
+                                                        );
+    long                            lStyleOld = OS2GetStyle( lFlagsOld
+                                                            ,&dwExstyleOld
+                                                           );
+
+    if (lStyle != lStyleOld)
+    {
+        //
+        // Some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
+        // this function so instead of simply setting the style to the new
+        // value we clear the bits which were set in styleOld but are set in
+        // the new one and set the ones which were not set before
+        //
+        long                        lStyleReal = ::WinQueryWindowULong(GetHwnd(), QWL_STYLE);
+
+        lStyleReal &= ~lStyleOld;
+        lStyleReal |= lStyle;
+
+        ::WinSetWindowULong(GetHwnd(), QWL_STYLE, lStyleReal);
+    }
+} // end of wxWindowOS2::SetWindowStyleFlag
+
+WXDWORD wxWindowOS2::OS2GetStyle(
+  long                              lFlags
+, WXDWORD*                          pdwExstyle
+) const
+{
+    WXDWORD                         dwStyle = 0L;
+
+    if (lFlags & wxCLIP_CHILDREN )
+        dwStyle |= WS_CLIPCHILDREN;
+
+    if (lFlags & wxCLIP_SIBLINGS )
+        dwStyle |= WS_CLIPSIBLINGS;
+
+    return dwStyle;
+} // end of wxWindowMSW::MSWGetStyle
+
 //
 // Make a Windows extended style from the given wxWindows window style
 //
 //
 // Make a Windows extended style from the given wxWindows window style
 //
@@ -1305,6 +1315,27 @@ void wxWindowOS2::Clear()
     vDc.Clear();
 } // end of 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
 void wxWindowOS2::Refresh(
   bool                              bEraseBack
 , const wxRect*                     pRect
@@ -1327,6 +1358,10 @@ void wxWindowOS2::Refresh(
         }
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
         }
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
+        if (m_hWndScrollBarHorz != NULLHANDLE)
+            ::WinInvalidateRect(m_hWndScrollBarHorz, NULL, TRUE);
+        if (m_hWndScrollBarVert != NULLHANDLE)
+            ::WinInvalidateRect(m_hWndScrollBarVert, NULL, TRUE);
     }
 } // end of wxWindowOS2::Refresh
 
     }
 } // end of wxWindowOS2::Refresh
 
@@ -1392,9 +1427,17 @@ void wxWindowOS2::DoGetSize(
 , int*                              pHeight
 ) const
 {
 , int*                              pHeight
 ) const
 {
-    HWND                            hWnd = GetHwnd();
+    HWND                            hWnd;
     RECTL                           vRect;
 
     RECTL                           vRect;
 
+    if (IsKindOf(CLASSINFO(wxFrame)))
+    {
+        wxFrame*                    pFrame = wxDynamicCast(this, wxFrame);
+        hWnd = pFrame->GetFrame();
+    }
+    else
+        hWnd = GetHwnd();
+
     ::WinQueryWindowRect(hWnd, &vRect);
 
     if (pWidth)
     ::WinQueryWindowRect(hWnd, &vRect);
 
     if (pWidth)
@@ -1490,22 +1533,68 @@ void wxWindowOS2::DoGetClientSize(
 ) const
 {
     HWND                            hWnd = GetHwnd();
 ) const
 {
     HWND                            hWnd = GetHwnd();
-    HWND                            hWndClient;
     RECTL                           vRect;
 
     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)
     if (pWidth)
-        *pWidth  = vRect.xRight;
+        *pWidth  = vRect.xRight - vRect.xLeft;
     if (pHeight)
     if (pHeight)
-        *pHeight = vRect.yTop;
+        *pHeight = vRect.yTop - vRect.yBottom;
 } // end of wxWindowOS2::DoGetClientSize
 
 void wxWindowOS2::DoMoveWindow(
 } // end of wxWindowOS2::DoGetClientSize
 
 void wxWindowOS2::DoMoveWindow(
@@ -1519,7 +1608,7 @@ void wxWindowOS2::DoMoveWindow(
     HWND                            hParent;
     wxWindow*                       pParent = GetParent();
 
     HWND                            hParent;
     wxWindow*                       pParent = GetParent();
 
-    if (pParent)
+    if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
     {
         int                         nOS2Height = GetOS2ParentHeight(pParent);
 
     {
         int                         nOS2Height = GetOS2ParentHeight(pParent);
 
@@ -1540,6 +1629,61 @@ void wxWindowOS2::DoMoveWindow(
                       ,(LONG)nHeight
                       ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW
                      );
                       ,(LONG)nHeight
                       ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW
                      );
+    if (m_vWinSwp.cx == 0 && m_vWinSwp.cy == 0 && m_vWinSwp.fl == 0)
+        //
+        // Uninitialized
+        //
+        ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
+    else
+    {
+        int                         nYDiff = m_vWinSwp.cy - nHeight;
+
+        //
+        // Handle resizing of scrolled windows.  The target or window to
+        // be scrolled is the owner (gets the scroll notificaitons).  The
+        // parent is usually the parent frame of the scrolled panel window.
+        // In order to show the scrollbars the target window will be shrunk
+        // by the size of the scroll bar widths (20) and moved in the X and Y
+        // directon.  That value will be computed as part of the diff for
+        // moving the children.  Everytime the window is sized the
+        // toplevel OnSize is going to resize the panel to fit the client
+        // or the whole sizer and will need to me resized. This will send
+        // a WM_SIZE out which will be intercepted by the ScrollHelper
+        // which will cause the scrollbars to be displayed via the SetScrollbar
+        // call in CWindow.
+        //
+        if ( IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+             IsKindOf(CLASSINFO(wxScrolledWindow))
+           )
+        {
+            int                     nAdjustWidth  = 0;
+            int                     nAdjustHeight = 0;
+            SWP                     vSwpScroll;
+
+            if (GetScrollBarHorz() == NULLHANDLE ||
+                !WinIsWindowShowing(GetScrollBarHorz()))
+                nAdjustHeight = 0L;
+            else
+                nAdjustHeight = 20L;
+            if (GetScrollBarVert() == NULLHANDLE ||
+                !WinIsWindowShowing(GetScrollBarVert()))
+                nAdjustWidth = 0L;
+            else
+                nAdjustWidth = 20L;
+            ::WinQueryWindowPos(GetHWND(), &vSwpScroll);
+            ::WinSetWindowPos( GetHWND()
+                              ,HWND_TOP
+                              ,vSwpScroll.x
+                              ,vSwpScroll.y + nAdjustHeight
+                              ,vSwpScroll.cx - nAdjustWidth
+                              ,vSwpScroll.cy - nAdjustHeight
+                              ,SWP_MOVE | SWP_SIZE
+                             );
+            nYDiff += nAdjustHeight;
+        }
+        MoveChildren(nYDiff);
+        ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
+    }
 } // end of wxWindowOS2::DoMoveWindow
 
 //
 } // end of wxWindowOS2::DoMoveWindow
 
 //
@@ -1572,8 +1716,29 @@ void wxWindowOS2::DoSetSize(
     GetPosition(&nCurrentX, &nCurrentY);
     GetSize(&nCurrentWidth, &nCurrentHeight);
 
     GetPosition(&nCurrentX, &nCurrentY);
     GetSize(&nCurrentWidth, &nCurrentHeight);
 
+    //
     // ... and don't do anything (avoiding flicker) if it's already ok
     // ... and don't do anything (avoiding flicker) if it's already ok
-    if (nX == nCurrentX && nY == nCurrentY &&
+    //
+    //
+    // 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;
         nWidth == nCurrentWidth && nHeight == nCurrentHeight)
     {
         return;
@@ -1897,8 +2062,8 @@ static void wxYieldForCommandsOnly()
     //
     QMSG                            vMsg;
 
     //
     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);
     }
     {
         wxTheApp->DoMessage((WXMSG*)&vMsg);
     }
@@ -1912,9 +2077,10 @@ bool wxWindowOS2::DoPopupMenu(
 , int                               nY
 )
 {
 , int                               nY
 )
 {
-    HWND                            hWnd = GetHwnd();
-    HWND                            hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
+    HWND                            hWndOwner = GetHwnd();
+    HWND                            hWndParent = GetHwnd();
     HWND                            hMenu = GetHmenuOf(pMenu);
     HWND                            hMenu = GetHmenuOf(pMenu);
+    bool                            bIsWaiting = TRUE;
 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();
 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();
@@ -1925,23 +2091,27 @@ bool wxWindowOS2::DoPopupMenu(
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent
-                   ,hWnd
+                   ,hWndOwner
                    ,hMenu
                    ,nX
                    ,nY
                    ,0L
                    ,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 ;()
-    //
-    // 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
     pMenu->SetInvokingWindow(NULL);
     return TRUE;
 } // end of wxWindowOS2::DoPopupMenu
@@ -2160,6 +2330,14 @@ bool wxWindowOS2::OS2TranslateMessage(
 #endif //wxUSE_ACCEL
 } // end of wxWindowOS2::OS2TranslateMessage
 
 #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
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // message params unpackers
 // ---------------------------------------------------------------------------
@@ -2280,7 +2458,18 @@ MRESULT EXPENTRY wxWndProc(
     else
     {
         if (pWnd)
     else
     {
         if (pWnd)
+        {
             rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
             rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
+            if ( (pWnd->GetScrollBarHorz() != NULLHANDLE ||
+                  pWnd->GetScrollBarVert() != NULLHANDLE) &&
+                  ulMsg == WM_PAINT)
+            {
+                if (pWnd->GetScrollBarHorz() != NULLHANDLE)
+                    ::WinInvalidateRect(pWnd->GetScrollBarHorz(), NULL, TRUE);
+                if (pWnd->GetScrollBarVert() != NULLHANDLE)
+                    ::WinInvalidateRect(pWnd->GetScrollBarVert(), NULL, TRUE);
+            }
+        }
         else
             rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
     }
         else
             rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
     }
@@ -2346,6 +2535,42 @@ MRESULT wxWindowOS2::OS2WindowProc(
                                    );
             break;
 
                                    );
             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;
         case WM_ACTIVATE:
             {
                 WXWORD              wState;
@@ -2409,8 +2634,8 @@ MRESULT wxWindowOS2::OS2WindowProc(
         case WM_BUTTON3MOTIONEND:
         case WM_BUTTON3MOTIONSTART:
             {
         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);
             }
 
                 bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam);
             }
@@ -2671,12 +2896,16 @@ MRESULT wxWindowOS2::OS2WindowProc(
 #endif // __WXDEBUG__
         if (IsKindOf(CLASSINFO(wxFrame)))
             mResult = ::WinDefWindowProc(m_hWnd, uMsg, wParam, lParam);
 #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
 
         else
             mResult = OS2DefWindowProc(uMsg, wParam, lParam);
     }
     return mResult;
 } // end of wxWindowOS2::OS2WindowProc
 
+#ifndef __EMX__
+// clashes with wxDlgProc in toplevel.cpp?
 //
 // Dialog window proc
 //
 //
 // Dialog window proc
 //
@@ -2703,6 +2932,7 @@ MRESULT wxDlgProc(
         return (MRESULT)0;
     }
 } // end of wxDlgProc
         return (MRESULT)0;
     }
 } // end of wxDlgProc
+#endif
 
 wxWindow* wxFindWinFromHandle(
   WXHWND                            hWnd
 
 wxWindow* wxFindWinFromHandle(
   WXHWND                            hWnd
@@ -2761,40 +2991,6 @@ void wxWindowOS2::OS2DestroyWindow()
 {
 }
 
 {
 }
 
-void wxWindowOS2::OS2DetachWindowMenu()
-{
-#ifndef __WXUNIVERSAL__
-    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;
-            }
-
-            if (wxStrcmp(zBuf, wxT("&Window")) == 0)
-            {
-                ::WinSendMsg(hMenu, MM_DELETEITEM, MPFROM2SHORT(i, TRUE), 0);
-                break;
-            }
-        }
-    }
-#endif // __WXUNIVERSAL__
-} // end of wxWindowOS2::OS2DetachWindowMenu
-
 bool wxWindowOS2::OS2GetCreateWindowCoords(
   const wxPoint&                    rPos
 , const wxSize&                     rSize
 bool wxWindowOS2::OS2GetCreateWindowCoords(
   const wxPoint&                    rPos
 , const wxSize&                     rSize
@@ -2836,148 +3032,124 @@ bool wxWindowOS2::OS2GetCreateWindowCoords(
 } // end of wxWindowOS2::OS2GetCreateWindowCoords
 
 bool wxWindowOS2::OS2Create(
 } // end of wxWindowOS2::OS2GetCreateWindowCoords
 
 bool wxWindowOS2::OS2Create(
-  WXHWND                            hParent
-, PSZ                               zClass
-, const wxChar*                     zTitle
+  PSZ                               zClass
+, const char*                       zTitle
 , WXDWORD                           dwStyle
 , WXDWORD                           dwStyle
-, long                              lX
-, long                              lY
-, long                              lWidth
-, long                              lHeight
-, WXHWND                            hOwner
-, WXHWND                            WXUNUSED(hZOrder)
-, unsigned long                     ulId
+, const wxPoint&                    rPos
+, const wxSize&                     rSize
 , void*                             pCtlData
 , void*                             pCtlData
-, void*                             pPresParams
 , WXDWORD                           dwExStyle
 , WXDWORD                           dwExStyle
+, bool                              bIsChild
 )
 {
     ERRORID                         vError;
     wxString                        sError;
 )
 {
     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
-    //
-    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
     {
     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
         {
         }
         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;
         }
     }
         }
     }
-
-   HWND parent;
-   if ( GetWindowStyleFlag() & wxPOPUP_WINDOW )
-   {
-       // popup windows should have desktop as parent because they shouldn't
-       // be limited to the parents client area as child windows usually are
-       parent = HWND_DESKTOP;
-   }
-   else if ( hParent )
-   {
-       parent = hParent;
-   }
-   else
-   {
-       // top level window
-       parent = NULL;
-   }
-
     //
     //
-    // 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(parent, zClass,
-                                       (PSZ)zTitle ? zTitle : wxT(""),
-                                       dwStyle, lX1, lY1, lWidth, lHeight,
-                                       hOwner, HWND_TOP, (ULONG)nControlId,
-                                       pCtlData, pPresParams);
-
+    if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE)
+    {
+        sClassName += wxT("NR");
+    }
+    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)
     {
     if (!m_hWnd)
     {
-        vError = ::WinGetLastError(vHabmain);
+        vError = ::WinGetLastError(wxGetInstance());
         sError = wxPMErrorToStr(vError);
         sError = wxPMErrorToStr(vError);
-        wxLogError("Can't create window of class %s!. Error: %s\n", zClass, sError);
         return FALSE;
     }
         return FALSE;
     }
-    m_dwExStyle = dwExStyle;
-    ::WinSetWindowULong(m_hWnd, QWL_USER, (ULONG) this);
-    wxWndHook = NULL;
+    SubclassWin(m_hWnd);
+    SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 
 
-#ifdef __WXDEBUG__
-    wxNode*                         pNode = wxWinHandleList->Member(this);
-
-    if (pNode)
-    {
-        HWND                        hWnd = (HWND)pNode->GetKeyInteger();
+    m_backgroundColour.Set(wxString("GREY"));
 
 
-        if (hWnd != (HWND)m_hWnd)
+    LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 
 
-        {
-            wxLogError("A second HWND association is being added for the same window!");
-        }
-    }
-#endif
-    wxAssociateWinWithHandle((HWND)m_hWnd
-                             ,this
-                            );
-    //
-    // Now need to subclass window.
-    //
-    if(!nNeedsubclass)
-    {
-         wxAssociateWinWithHandle((HWND)m_hWnd,this);
-    }
-    else
+    if (!::WinSetPresParam( m_hWnd
+                           ,PP_BACKGROUNDCOLOR
+                           ,sizeof(LONG)
+                           ,(PVOID)&lColor
+                          ))
     {
     {
-        SubclassWin(GetHWND());
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+        wxLogError("Error creating frame. Error: %s\n", sError);
+        return FALSE;
     }
     }
+    SetSize( nX
+            ,nY
+            ,nWidth
+            ,nHeight
+           );
     return TRUE;
     return TRUE;
-} // end of wxWindowOS2::OS2Create
+} // end of WinGuiBase_Window::OS2Create
 
 // ===========================================================================
 // OS2 PM message handlers
 
 // ===========================================================================
 // OS2 PM message handlers
@@ -3050,6 +3222,13 @@ bool wxWindowOS2::HandleSetFocus(
   WXHWND                            WXUNUSED(hWnd)
 )
 {
   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
 #if wxUSE_CARET
     //
     // Deal with caret
@@ -3452,7 +3631,71 @@ bool wxWindowOS2::HandlePaint()
     vEvent.SetEventObject(this);
     bProcessed = GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     bProcessed = GetEventHandler()->ProcessEvent(vEvent);
 
-    return GetEventHandler()->ProcessEvent(vEvent); //bProcessed;
+    if (!bProcessed &&
+         IsKindOf(CLASSINFO(wxPanel)) &&
+         GetChildren().GetCount() == 0
+       )
+    {
+        //
+        // OS/2 needs to process this right here, not by the default proc
+        // Window's default proc correctly paints everything, OS/2 does not!
+        //
+        HPS                         hPS;
+        RECTL                       vRect;
+        wxFrame*                    pFrame;
+        wxWindow*                   pParent;
+
+        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
+                                    );
+
+            ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
+            if (m_dwExStyle)
+            {
+                LINEBUNDLE                      vLineBundle;
+
+                vLineBundle.lColor     = 0x00000000; // Black
+                vLineBundle.usMixMode  = FM_OVERPAINT;
+                vLineBundle.fxWidth    = 1;
+                vLineBundle.lGeomWidth = 1;
+                vLineBundle.usType     = LINETYPE_SOLID;
+                vLineBundle.usEnd      = 0;
+                vLineBundle.usJoin     = 0;
+                ::GpiSetAttrs( hPS
+                              ,PRIM_LINE
+                              ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
+                              ,0L
+                              ,&vLineBundle
+                             );
+                ::WinQueryWindowRect(GetHwnd(), &vRect);
+                wxDrawBorder( hPS
+                             ,vRect
+                             ,m_dwExStyle
+                            );
+            }
+            ::WinEndPaint(hPS);
+        }
+        bProcessed = TRUE;
+    }
+
+    return bProcessed;
 } // end of wxWindowOS2::HandlePaint
 
 bool wxWindowOS2::HandleEraseBkgnd(
 } // end of wxWindowOS2::HandlePaint
 
 bool wxWindowOS2::HandleEraseBkgnd(
@@ -3983,8 +4226,9 @@ void wxWindowOS2::MoveChildren(
                           ,vSwp.y - nDiff
                           ,vSwp.cx
                           ,vSwp.cy
                           ,vSwp.y - nDiff
                           ,vSwp.cx
                           ,vSwp.cy
-                          ,SWP_MOVE
+                          ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
                          );
                          );
+        ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp());
         if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
         {
             wxRadioBox*     pRadioBox;
         if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
         {
             wxRadioBox*     pRadioBox;
@@ -4010,6 +4254,7 @@ void wxWindowOS2::MoveChildren(
                                       );
         }
     }
                                       );
         }
     }
+    Refresh();
 } // end of wxWindowOS2::MoveChildren
 
 //
 } // end of wxWindowOS2::MoveChildren
 
 //
@@ -4029,6 +4274,8 @@ void wxWindowOS2::MoveChildren(
 //
 //  3)  The controls are children of a panel, which in turn is a child of
 //      a frame.
 //
 //  3)  The controls are children of a panel, which in turn is a child of
 //      a frame.
+//      The panel may be one of many, in which case the same treatment
+//      as 1 applies. It may be the only child, though.
 //      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
 //      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
@@ -4051,7 +4298,7 @@ int wxWindowOS2::GetOS2ParentHeight(
     // Case 1
     //
     if (pParent->IsKindOf(CLASSINFO(wxDialog)))
     // Case 1
     //
     if (pParent->IsKindOf(CLASSINFO(wxDialog)))
-        return(pParent->GetSize().y);
+        return(pParent->GetClientSize().y);
 
     //
     // Case 2 -- if we are one of the separately built standard Frame
 
     //
     // Case 2 -- if we are one of the separately built standard Frame
@@ -4069,42 +4316,35 @@ int wxWindowOS2::GetOS2ParentHeight(
         else
             return(pParent->GetClientSize().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.
+    // Case -- 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
     {
     //
     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(pParent->GetClientSize().y);
     }
     return(0L);
 } // end of wxWindowOS2::GetOS2ParentHeight
 
     }
     return(0L);
 } // end of wxWindowOS2::GetOS2ParentHeight
 
+//
+// OS/2 needs a lot extra manipulation to deal with layouts
+// for canvas windows, particularly scrolled ones.
+//
+wxWindowCreationHook::wxWindowCreationHook(
+  wxWindow*                         pWinBeingCreated
+)
+{
+    gpWinBeingCreated = pWinBeingCreated;
+} // end of wxWindowCreationHook::wxWindowCreationHook
+
+wxWindowCreationHook::~wxWindowCreationHook()
+{
+    gpWinBeingCreated = NULL;
+} // end of wxWindowCreationHook::~wxWindowCreationHook
+
 // ===========================================================================
 // global functions
 // ===========================================================================
 // ===========================================================================
 // global functions
 // ===========================================================================
wxWidgets (Impactor)