X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a3bf7524f394af039efe196a186f7969cbabcc19..1b14412585d582acde42d422c8cd5d23d4daef14:/src/generic/scrlwing.cpp

diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp
index 8dab9a85f1..c78ebc0fa7 100644
--- a/src/generic/scrlwing.cpp
+++ b/src/generic/scrlwing.cpp
@@ -6,7 +6,7 @@
 //              Ron Lee on 10.4.02:  virtual size / auto scrollbars et al.
 // Created:     01/02/97
 // RCS-ID:      $Id$
-// Copyright:   (c) wxWindows team
+// Copyright:   (c) wxWidgets team
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -65,8 +65,8 @@
 IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
 
 /*
-	TODO PROPERTIES
-		style wxHSCROLL | wxVSCROLL
+    TODO PROPERTIES
+        style wxHSCROLL | wxVSCROLL
 */
 
 // ----------------------------------------------------------------------------
@@ -84,7 +84,7 @@ public:
 
     virtual bool ProcessEvent(wxEvent& event);
 
-    void ResetDrawnFlag() { m_hasDrawnWindow = FALSE; }
+    void ResetDrawnFlag() { m_hasDrawnWindow = false; }
 
 private:
     wxScrollHelper *m_scrollHelper;
@@ -205,7 +205,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     // anything in the window. We set it to true here but reset it to false in
     // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the
     // user code defined OnPaint() in the derived class)
-    m_hasDrawnWindow = TRUE;
+    m_hasDrawnWindow = true;
 
     // pass it on to the real handler
     bool processed = wxEvtHandler::ProcessEvent(event);
@@ -221,7 +221,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     {
         m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
 
-        return TRUE;
+        return true;
     }
 
     if ( processed )
@@ -231,18 +231,18 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
         // OnDraw() below (from HandleOnPaint)
         if ( m_hasDrawnWindow )
         {
-            return TRUE;
+            return true;
         }
     }
 
-    // reset the skipped flag to FALSE as it might have been set to TRUE in
+    // reset the skipped flag to false as it might have been set to true in
     // ProcessEvent() above
-    event.Skip(FALSE);
+    event.Skip(false);
 
     if ( evType == wxEVT_PAINT )
     {
         m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
-        return TRUE;
+        return true;
     }
 
     if ( evType == wxEVT_SCROLLWIN_TOP ||
@@ -278,7 +278,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
         return !event.GetSkipped();
     }
 
-    return FALSE;
+    return false;
 }
 
 // ----------------------------------------------------------------------------
@@ -297,7 +297,7 @@ wxScrollHelper::wxScrollHelper(wxWindow *win)
     m_yScrollLinesPerPage = 0;
 
     m_xScrollingEnabled =
-    m_yScrollingEnabled = TRUE;
+    m_yScrollingEnabled = true;
 
     m_scaleX =
     m_scaleY = 1.0;
@@ -360,15 +360,14 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
     // For better backward compatibility we set persisting limits
     // here not just the size.  It makes SetScrollbars 'sticky'
     // emulating the old non-autoscroll behaviour.
-
-    m_targetWindow->SetVirtualSizeHints( w, h );
+    //   m_targetWindow->SetVirtualSizeHints( w, h );
 
     // The above should arguably be deprecated, this however we still need.
 
     m_targetWindow->SetVirtualSize( w, h );
 
     if (do_refresh && !noRefresh)
-        m_targetWindow->Refresh(TRUE, GetScrollRect());
+        m_targetWindow->Refresh(true, GetScrollRect());
 
 #ifndef __WXUNIVERSAL__
     // If the target is not the same as the window with the scrollbars,
@@ -383,9 +382,6 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
     else
     {
         // otherwise this has been done by AdjustScrollbars, above
-#ifdef __WXMAC__
-        m_targetWindow->Update() ;
-#endif
     }
 #endif // !__WXUNIVERSAL__
 }
@@ -479,7 +475,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
         m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition);
     }
 
-    bool needsRefresh = FALSE;
+    bool needsRefresh = false;
     int dx = 0,
         dy = 0;
     if (orient == wxHORIZONTAL)
@@ -490,7 +486,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
        }
        else
        {
-           needsRefresh = TRUE;
+           needsRefresh = true;
        }
     }
     else
@@ -501,22 +497,18 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
         }
         else
         {
-            needsRefresh = TRUE;
+            needsRefresh = true;
         }
     }
 
     if ( needsRefresh )
     {
-        m_targetWindow->Refresh(TRUE, GetScrollRect());
+        m_targetWindow->Refresh(true, GetScrollRect());
     }
     else
     {
         m_targetWindow->ScrollWindow(dx, dy, GetScrollRect());
     }
-
-#ifdef __WXMAC__
-    m_targetWindow->Update() ;
-#endif
 }
 
 int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
@@ -574,21 +566,23 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
     {
         if (m_xScrollPixelsPerLine > 0)
         {
-            int w, h;
-            GetTargetSize(&w, &h);
-
-            int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
-            int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 );
-            if (noPositions < 0)
-                noPositions = 0;
-
-            if ( (m_xScrollPosition + nScrollInc) < 0 )
-                nScrollInc = -m_xScrollPosition; // As -ve as we can go
-            else if ( (m_xScrollPosition + nScrollInc) > noPositions )
-                nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
+            if ( m_xScrollPosition + nScrollInc < 0 )
+            {
+                // As -ve as we can go
+                nScrollInc = -m_xScrollPosition;
+            }
+            else // check for the other bound
+            {
+                const int posMax = m_xScrollLines - m_xScrollLinesPerPage;
+                if ( m_xScrollPosition + nScrollInc > posMax )
+                {
+                    // As +ve as we can go
+                    nScrollInc = posMax - m_xScrollPosition;
+                }
+            }
         }
         else
-            m_targetWindow->Refresh(TRUE, GetScrollRect());
+            m_targetWindow->Refresh(true, GetScrollRect());
     }
     else
     {
@@ -612,7 +606,7 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
         else
         {
             // VZ: why do we do this? (FIXME)
-            m_targetWindow->Refresh(TRUE, GetScrollRect());
+            m_targetWindow->Refresh(true, GetScrollRect());
         }
     }
 
@@ -635,10 +629,6 @@ void wxScrollHelper::AdjustScrollbars()
         return;
     }
 
-#ifdef __WXMAC__
-    m_targetWindow->Update();
-#endif
-
     int w = 0, h = 0;
     int oldw, oldh;
 
@@ -655,37 +645,59 @@ void wxScrollHelper::AdjustScrollbars()
     {
         GetTargetSize(&w, 0);
 
-        if (m_xScrollPixelsPerLine == 0)
+        // scroll lines per page: if 0, no scrolling is needed
+        int linesPerPage;
+
+        if ( m_xScrollPixelsPerLine == 0 )
         {
+            // scrolling is disabled
             m_xScrollLines = 0;
             m_xScrollPosition = 0;
-            m_win->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
+            linesPerPage = 0;
         }
-        else
+        else // might need scrolling
         {
-            m_xScrollLines = m_targetWindow->GetVirtualSize().GetWidth() / m_xScrollPixelsPerLine;
+            // Round up integer division to catch any "leftover" client space.
+            const int wVirt = m_targetWindow->GetVirtualSize().GetWidth();
+            m_xScrollLines = (wVirt + m_xScrollPixelsPerLine - 1) / m_xScrollPixelsPerLine;
 
             // Calculate page size i.e. number of scroll units you get on the
-            // current client window
-            int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
-            if (noPagePositions < 1) noPagePositions = 1;
-            if ( noPagePositions > m_xScrollLines )
-                noPagePositions = m_xScrollLines;
-
-            // Correct position if greater than extent of canvas minus
-            // the visible portion of it or if below zero
-            m_xScrollPosition = wxMin( m_xScrollLines - noPagePositions, m_xScrollPosition);
-            m_xScrollPosition = wxMax( 0, m_xScrollPosition );
-
-            m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
-            // The amount by which we scroll when paging
-            SetScrollPageSize(wxHORIZONTAL, noPagePositions);
+            // current client window.
+            linesPerPage = w / m_xScrollPixelsPerLine;
+
+            // Special case. When client and virtual size are very close but
+            // the client is big enough, kill scrollbar.
+            if ((linesPerPage < m_xScrollLines) && (w >= wVirt)) ++linesPerPage;
+
+            if (linesPerPage >= m_xScrollLines)
+            {
+                // we're big enough to not need scrolling
+                linesPerPage =
+                m_xScrollLines =
+                m_xScrollPosition = 0;
+            }
+            else // we do need a scrollbar
+            {
+                if ( linesPerPage < 1 )
+                    linesPerPage = 1;
+
+                // Correct position if greater than extent of canvas minus
+                // the visible portion of it or if below zero
+                const int posMax = m_xScrollLines - linesPerPage;
+                if ( m_xScrollPosition > posMax )
+                    m_xScrollPosition = posMax;
+                else if ( m_xScrollPosition < 0 )
+                    m_xScrollPosition = 0;
+            }
         }
 
-        GetTargetSize(0, &h);
+        m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition,
+                            linesPerPage, m_xScrollLines);
 
-        // scroll lines per page: if 0, no scrolling is needed
-        int linesPerPage;
+        // The amount by which we scroll when paging
+        SetScrollPageSize(wxHORIZONTAL, linesPerPage);
+
+        GetTargetSize(0, &h);
 
         if ( m_yScrollPixelsPerLine == 0 )
         {
@@ -696,13 +708,19 @@ void wxScrollHelper::AdjustScrollbars()
         }
         else // might need scrolling
         {
-            int hVirt = m_targetWindow->GetVirtualSize().GetHeight();
-            m_yScrollLines = hVirt / m_yScrollPixelsPerLine;
+            // Round up integer division to catch any "leftover" client space.
+            const int hVirt = m_targetWindow->GetVirtualSize().GetHeight();
+            m_yScrollLines = ( hVirt + m_yScrollPixelsPerLine - 1 ) / m_yScrollPixelsPerLine;
 
             // Calculate page size i.e. number of scroll units you get on the
-            // current client window
+            // current client window.
             linesPerPage = h / m_yScrollPixelsPerLine;
-            if ( linesPerPage >= m_yScrollLines )
+
+            // Special case. When client and virtual size are very close but
+            // the client is big enough, kill scrollbar.
+            if ((linesPerPage < m_yScrollLines) && (h >= hVirt)) ++linesPerPage;
+
+            if (linesPerPage >= m_yScrollLines)
             {
                 // we're big enough to not need scrolling
                 linesPerPage =
@@ -777,7 +795,7 @@ void wxScrollHelper::AdjustScrollbars()
             m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0,
                                           GetScrollRect() );
        else
-            m_targetWindow->Refresh(TRUE, GetScrollRect());
+            m_targetWindow->Refresh(true, GetScrollRect());
     }
 
     if (oldYScroll != m_yScrollPosition)
@@ -786,12 +804,8 @@ void wxScrollHelper::AdjustScrollbars()
             m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
                                           GetScrollRect() );
         else
-            m_targetWindow->Refresh(TRUE, GetScrollRect());
+            m_targetWindow->Refresh(true, GetScrollRect());
     }
-
-#ifdef __WXMAC__
-    m_targetWindow->Update();
-#endif
 }
 
 void wxScrollHelper::DoPrepareDC(wxDC& dc)
@@ -855,10 +869,6 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos )
     if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
         ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
 
-#ifdef __WXMAC__
-    m_targetWindow->Update();
-#endif
-
     int w, h;
     GetTargetSize(&w, &h);
 
@@ -904,11 +914,6 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos )
                                           GetScrollRect() );
         }
     }
-
-#ifdef __WXMAC__
-    m_targetWindow->Update();
-#endif
-
 }
 
 void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll)
@@ -926,6 +931,15 @@ void wxScrollHelper::GetViewStart (int *x, int *y) const
         *y = m_yScrollPosition;
 }
 
+#if WXWIN_COMPATIBILITY_2_2
+
+void wxScrollHelper::ViewStart(int *x, int *y) const
+{
+    GetViewStart( x, y );
+}
+
+#endif // WXWIN_COMPATIBILITY_2_2
+
 void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const
 {
     if ( xx )
@@ -1169,6 +1183,8 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
                                     orient
                                 );
         m_timerAutoScroll->Start(50); // FIXME: make configurable
+#else
+        wxUnusedVar(pos);
 #endif
     }
 }
@@ -1188,14 +1204,14 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
 
         newEvent.SetPosition(0);
         newEvent.SetOrientation(wxVERTICAL);
-        newEvent.m_eventObject = m_win;
+        newEvent.SetEventObject(m_win);
 
         if (event.IsPageScroll())
         {
             if (lines > 0)
-                newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
+                newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP);
             else
-                newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
+                newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);
 
             m_win->GetEventHandler()->ProcessEvent(newEvent);
         }
@@ -1203,9 +1219,9 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
         {
             lines *= event.GetLinesPerAction();
             if (lines > 0)
-                newEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
+                newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP);
             else
-                newEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
+                newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);
 
             int times = abs(lines);
             for (; times > 0; times--)
@@ -1235,7 +1251,7 @@ bool wxGenericScrolledWindow::Create(wxWindow *parent,
 {
     m_targetWindow = this;
 
-    bool ok = wxPanel::Create(parent, id, pos, size, style, name);
+    bool ok = wxPanel::Create(parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name);
 
     return ok;
 }
@@ -1255,7 +1271,7 @@ bool wxGenericScrolledWindow::Layout()
         CalcScrolledPosition(0,0, &x,&y);
         GetVirtualSize(&w, &h);
         GetSizer()->SetDimension(x, y, w, h);
-        return TRUE;
+        return true;
     }
 
     // fall back to default for LayoutConstraints
@@ -1267,10 +1283,8 @@ void wxGenericScrolledWindow::DoSetVirtualSize(int x, int y)
     wxPanel::DoSetVirtualSize( x, y );
     AdjustScrollbars();
 
-#if wxUSE_CONSTRAINTS
     if (GetAutoLayout())
         Layout();
-#endif
 }
 
 void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event)
@@ -1283,12 +1297,12 @@ void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event)
 }
 
 #ifdef __WXMSW__
-long
+WXLRESULT
 wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg,
                                        WXWPARAM wParam,
                                        WXLPARAM lParam)
 {
-    long rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
+    WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
 
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling