]> 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
don't compile this file under wxMSW
[wxWidgets.git] / src / os2 / window.cpp
diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index e9f26646b4ce70a1d6746eb399f53fcfde74bfdc..935143f04077d77beb6ab369b1bf44346b41fd6e 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -759,15 +759,37 @@ 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;
     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);
 
 
-    ::WinQueryWindowRect(hWnd, &vRect);
     if (nPageSize > 1 && nRange > 0)
     {
         nRange1 += (nPageSize - 1);
     if (nPageSize > 1 && nRange > 0)
     {
         nRange1 += (nPageSize - 1);
@@ -783,54 +805,43 @@ void wxWindowOS2::SetScrollbar(
         ulStyle |= SBS_HORZ;
         if (m_hWndScrollBarHorz == 0L)
         {
         ulStyle |= SBS_HORZ;
         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!
-            //
-            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.
-            //
-            ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect2);
-            if (!(vRect2.xLeft == vRect.xLeft     &&
-                  vRect2.xRight == vRect.xRight   &&
-                  vRect2.yBottom == vRect.yBottom &&
-                  vRect2.yTop == vRect.yTop
-                ) )
-            {
-                ::WinSetWindowPos( m_hWndScrollBarHorz
-                                  ,HWND_TOP
-                                  ,vRect.xLeft
-                                  ,vRect.yBottom
-                                  ,vRect.xRight - vRect.xLeft
-                                  ,20
-                                  ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
-                                 );
-            }
-            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
-            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+            ::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
+                        );
         }
     }
     else
         }
     }
     else
@@ -838,49 +849,43 @@ void wxWindowOS2::SetScrollbar(
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {
-            m_hWndScrollBarVert = ::WinCreateWindow( hWnd
+            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.
-            //
-            ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect2);
-            if (!(vRect2.xLeft == vRect.xLeft     &&
-                  vRect2.xRight == vRect.xRight   &&
-                  vRect2.yBottom == vRect.yBottom &&
-                  vRect2.yTop == vRect.yTop
-                ) )
-            {
-                ::WinSetWindowPos( m_hWndScrollBarVert
-                                  ,HWND_TOP
-                                  ,vRect.xRight - 20
-                                  ,vRect.yBottom + 20
-                                  ,20
-                                  ,vRect.yTop - (vRect.yBottom + 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);
+            ::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
+                        );
         }
         m_nYThumbSize = nThumbVisible;
     }
         }
         m_nYThumbSize = nThumbVisible;
     }
@@ -893,86 +898,31 @@ 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
+                     );
 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
@@ -1302,6 +1252,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
 
@@ -2343,7 +2297,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);
     }
@@ -2421,7 +2386,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
             // child controls, so we need to already be sized
             // in order to get the child controls positoned properly.
             //
             // child controls, so we need to already be sized
             // in order to get the child controls positoned properly.
             //
-            if (IsKindOf(CLASSINFO(wxDialog)))
+            if (IsKindOf(CLASSINFO(wxDialog)) || IsKindOf(CLASSINFO(wxFrame)))
             {
                 PSWP                pSwp = (PSWP)PVOIDFROMMP(wParam);
                 PSWP                pSwp2 = pSwp++;
             {
                 PSWP                pSwp = (PSWP)PVOIDFROMMP(wParam);
                 PSWP                pSwp2 = pSwp++;
@@ -2432,6 +2397,16 @@ MRESULT wxWindowOS2::OS2WindowProc(
                                             ,pSwp->cy
                                             ,(WXUINT)lParam
                                            );
                                             ,pSwp->cy
                                             ,(WXUINT)lParam
                                            );
+                if (IsKindOf(CLASSINFO(wxFrame)))
+                {
+                    wxFrame*            pFrame = wxDynamicCast(this, wxFrame);
+
+                    if (pFrame)
+                    {
+                        if (pFrame->GetStatusBar())
+                            pFrame->PositionStatusBar();
+                    }
+                }
             }
             break;
 
             }
             break;
 
@@ -4036,12 +4011,12 @@ void wxWindowOS2::MoveChildren(
             vSwp.x -= pCtrl->GetXComp();
         }
         ::WinSetWindowPos( GetHwndOf(pWin)
             vSwp.x -= pCtrl->GetXComp();
         }
         ::WinSetWindowPos( GetHwndOf(pWin)
-                          ,HWND_TOP
+                          ,HWND_BOTTOM
                           ,vSwp.x
                           ,vSwp.y - nDiff
                           ,vSwp.cx
                           ,vSwp.cy
                           ,vSwp.x
                           ,vSwp.y - nDiff
                           ,vSwp.cx
                           ,vSwp.cy
-                          ,SWP_MOVE
+                          ,SWP_MOVE | SWP_ZORDER
                          );
         if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
         {
                          );
         if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
         {
@@ -4163,6 +4138,115 @@ int wxWindowOS2::GetOS2ParentHeight(
     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.
+//
+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
 )
wxWidgets (Impactor)