various splitter fixes:

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

diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index 935143f04077d77beb6ab369b1bf44346b41fd6e..feea40e3c50d37fe8967cf688056b3c3052a5ca5 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


@@ -304,8 +303,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;


@@ -767,6 +769,7 @@ void wxWindowOS2::SetScrollbar(
     SBCDATA                         vInfo;
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     SWP                             vSwp;
     SBCDATA                         vInfo;
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     SWP                             vSwp;

+    SWP                             vSwpOwner;

     RECTL                           vRect;
     HWND                            hWndParent;
     HWND                            hWndClient;
     RECTL                           vRect;
     HWND                            hWndParent;
     HWND                            hWndClient;


@@ -789,6 +792,7 @@ void wxWindowOS2::SetScrollbar(
         hWndClient = hWndParent;
     }
     ::WinQueryWindowPos(hWndClient, &vSwp);
         hWndClient = hWndParent;
     }
     ::WinQueryWindowPos(hWndClient, &vSwp);

+    ::WinQueryWindowPos(hWnd, &vSwpOwner);

 
     if (nPageSize > 1 && nRange > 0)
     {
 
     if (nPageSize > 1 && nRange > 0)
     {


@@ -805,6 +809,18 @@ void wxWindowOS2::SetScrollbar(
         ulStyle |= SBS_HORZ;
         if (m_hWndScrollBarHorz == 0L)
         {
         ulStyle |= SBS_HORZ;
         if (m_hWndScrollBarHorz == 0L)
         {

+            //
+            // 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( hWndParent
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
             m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL


@@ -822,26 +838,42 @@ void wxWindowOS2::SetScrollbar(
         }
         else
         {
         }
         else
         {

-            ::WinSetWindowPos( m_hWndScrollBarHorz
-                              ,HWND_TOP
-                              ,vSwp.x
-                              ,vSwp.y
-                              ,vSwp.cx - 20
-                              ,20
-                              ,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
-                        );
+            //
+            // 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.
+            //
+            if (nRange1 >= nThumbVisible)
+            {
+                ::WinSetWindowPos( m_hWndScrollBarHorz
+                                  ,HWND_TOP
+                                  ,vSwp.x + vSwpOwner.x
+                                  ,(vSwp.y + vSwpOwner.y) - 20
+                                  ,vSwpOwner.cx
+                                  ,20
+                                  ,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
+                            );
+            }
+            else
+                ::WinShowWindow(m_hWndScrollBarHorz, FALSE);

         }
     }
     else
         }
     }
     else


@@ -849,6 +881,18 @@ void wxWindowOS2::SetScrollbar(
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {

+            //
+            // 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
             m_hWndScrollBarVert = ::WinCreateWindow( hWndParent
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL


@@ -866,26 +910,46 @@ void wxWindowOS2::SetScrollbar(
         }
         else
         {
         }
         else
         {

-            ::WinSetWindowPos( m_hWndScrollBarVert
-                              ,HWND_TOP
-                              ,vSwp.x + vSwp.cx - 20
-                              ,vSwp.y + 20
-                              ,20
-                              ,vSwp.cy - 20
-                              ,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
-                        );
+            //
+            // 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.
+            //
+            if (nRange1 >= nThumbVisible)
+            {
+                ::WinSetWindowPos( m_hWndScrollBarVert
+                                  ,HWND_TOP
+                                  ,vSwp.x + vSwpOwner.x + vSwpOwner.cx
+                                  ,vSwp.y + vSwpOwner.y
+                                  ,20
+                                  ,vSwpOwner.cy
+                                  ,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
+                            );
+            }
+            else
+                ::WinShowWindow(m_hWndScrollBarVert, FALSE);

         }
         m_nYThumbSize = nThumbVisible;
     }
         }
         m_nYThumbSize = nThumbVisible;
     }


@@ -923,6 +987,7 @@ void wxWindowOS2::ScrollWindow(
                       ,NULL
                       ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
                      );
                       ,NULL
                       ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
                      );

+    Refresh();

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


@@ -1523,6 +1588,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
 
 //


@@ -2944,37 +3064,6 @@ bool wxWindowOS2::OS2Create(
     {
         sClassName += wxT("NR");
     }
     {
         sClassName += wxT("NR");
     }

-
-    //
-    // If the window being created is a Frame's Statusbar we need to use
-    // the actual Frame's size, not its client
-    //
-    if (pParent)
-    {
-        if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
-             pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
-           )
-        {
-            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);
-        }
-    }
-    else
-    {
-        RECTL                   vRect;
-
-        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
-        nY = vRect.yTop - (nY + nHeight);
-    }

     m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
                                       ,(PSZ)sClassName.c_str()
                                       ,(PSZ)zTitle ? zTitle : ""
     m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
                                       ,(PSZ)sClassName.c_str()
                                       ,(PSZ)zTitle ? zTitle : ""


@@ -2997,6 +3086,22 @@ bool wxWindowOS2::OS2Create(
     }
     SubclassWin(m_hWnd);
     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
     }
     SubclassWin(m_hWnd);
     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));

+
+    m_backgroundColour.Set(wxString("GREY"));
+
+    LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
+
+    if (!::WinSetPresParam( m_hWnd
+                           ,PP_BACKGROUNDCOLOR
+                           ,sizeof(LONG)
+                           ,(PVOID)&lColor
+                          ))
+    {
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+        wxLogError("Error creating frame. Error: %s\n", sError);
+        return FALSE;
+    }

     SetSize( nX
             ,nY
             ,nWidth
     SetSize( nX
             ,nY
             ,nWidth


@@ -3485,7 +3590,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(


@@ -4011,13 +4180,14 @@ void wxWindowOS2::MoveChildren(
             vSwp.x -= pCtrl->GetXComp();
         }
         ::WinSetWindowPos( GetHwndOf(pWin)
             vSwp.x -= pCtrl->GetXComp();
         }
         ::WinSetWindowPos( GetHwndOf(pWin)

-                          ,HWND_BOTTOM
+                          ,HWND_TOP

                           ,vSwp.x
                           ,vSwp.y - nDiff
                           ,vSwp.cx
                           ,vSwp.cy
                           ,vSwp.x
                           ,vSwp.y - nDiff
                           ,vSwp.cx
                           ,vSwp.cy

-                          ,SWP_MOVE | SWP_ZORDER
+                          ,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;


@@ -4043,6 +4213,7 @@ void wxWindowOS2::MoveChildren(
                                       );
         }
     }
                                       );
         }
     }

+    Refresh();

 } // end of wxWindowOS2::MoveChildren
 
 //
 } // end of wxWindowOS2::MoveChildren
 
 //


@@ -4062,6 +4233,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


@@ -4102,38 +4275,15 @@ 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


@@ -4142,111 +4292,6 @@ int wxWindowOS2::GetOS2ParentHeight(
 // OS/2 needs a lot extra manipulation to deal with layouts
 // for canvas windows, particularly scrolled ones.
 //
 // OS/2 needs a lot extra manipulation to deal with layouts
 // for canvas windows, particularly scrolled ones.
 //

-void wxWindowOS2::OS2Layout(
-  int                               nWidth
-, int                               nHeight
-)
-{
-    //
-    // Frames laying out canvas windows need the held.
-    // Dialogs or Frames laying out child controls do not.
-    //
-    if (IsKindOf(CLASSINFO(wxFrame)))
-    {
-        RECTL                       vRectFrame;
-        RECTL                       vRectClient;
-        RECTL                       vRectChild;
-        RECTL                       vRectHorz;
-        RECTL                       vRectVert;
-        SWP                         vSwpFrame;
-        SWP                         vSwpClient;
-        SWP                         vSwpChild;
-        SWP                         vSwpHorz;
-        SWP                         vSwpVert;
-        wxFrame*                    pFrame = wxDynamicCast(this, wxFrame);
-        bool                        bNewYSize = FALSE;
-        bool                        bNewXSize = FALSE;
-
-        ::WinQueryWindowPos(pFrame->GetFrame(), &vSwpFrame);
-        ::WinQueryWindowPos(GetHwnd(), &vSwpClient);
-
-        if (vSwpClient.cy != pFrame->GetSwpClient()->cy)
-            bNewYSize = TRUE;
-        if (vSwpClient.cx != pFrame->GetSwpClient()->cx)
-            bNewXSize = TRUE;
-
-        for (wxWindowList::Node* pNode = GetChildren().GetFirst();
-             pNode;
-             pNode = pNode->GetNext())
-        {
-            wxWindow*               pChild = pNode->GetData();
-            int                     nWidthAdjust = 0;
-            int                     nHeightAdjust = 0;
-
-            if ( pChild->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
-                 pChild->IsKindOf(CLASSINFO(wxScrolledWindow))
-               )
-            {
-                if(bNewYSize)
-                {
-                    //
-                    // This is needed SetSize will mess up the OS/2 child window
-                    // positioning because we position in wxWindows coordinates,
-                    // not OS/2 coordinates.
-                    //
-                    pChild->MoveChildren(pFrame->GetSwpClient()->cy - vSwpClient.cy);
-                    pChild->Refresh();
-                }
-                ::WinQueryWindowPos(pChild->GetHWND(), &vSwpChild);
-
-                //
-                // Reset the child window size to account for scrollbars
-                //
-                if (pChild->GetScrollBarHorz() != NULLHANDLE)
-                    nHeightAdjust = 20;
-                if (pChild->GetScrollBarVert() != NULLHANDLE)
-                    nWidthAdjust = 20;
-                ::WinSetWindowPos( pChild->GetHWND()
-                                  ,HWND_TOP
-                                  ,vSwpChild.x
-                                  ,vSwpChild.y + nHeightAdjust
-                                  ,vSwpChild.cx - nWidthAdjust
-                                  ,vSwpChild.cy - nHeightAdjust
-                                  ,SWP_MOVE | SWP_SIZE
-                                 );
-
-                //
-                // Reset the scrollbar sizes...they will be all messed up after
-                // auto layouts
-                //
-                if (pChild->GetScrollBarHorz() != NULLHANDLE)
-                {
-                    ::WinSetWindowPos( pChild->GetScrollBarHorz()
-                                      ,HWND_TOP
-                                      ,vSwpClient.x + vSwpChild.x
-                                      ,vSwpClient.y + vSwpChild.y
-                                      ,vSwpChild.cx - 20
-                                      ,20
-                                      ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER
-                                     );
-                }
-                if (pChild->GetScrollBarVert() != NULLHANDLE)
-                {
-                    ::WinSetWindowPos( pChild->GetScrollBarVert()
-                                      ,HWND_TOP
-                                      ,vSwpClient.x + vSwpChild.x + vSwpChild.cx - 20
-                                      ,vSwpClient.y + vSwpChild.y  + 20
-                                      ,20
-                                      ,vSwpChild.cy - 20
-                                      ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER
-                                     );
-                }
-            }
-        }
-        ::WinQueryWindowPos(GetHwnd(), pFrame->GetSwpClient());
-    }
-} // end of wxWindowOS2::OS2Layout
-

 wxWindowCreationHook::wxWindowCreationHook(
   wxWindow*                         pWinBeingCreated
 )
 wxWindowCreationHook::wxWindowCreationHook(
   wxWindow*                         pWinBeingCreated
 )