minor cleanup

[wxWidgets.git] / src / generic / vscroll.cpp

diff --git a/src/generic/vscroll.cpp b/src/generic/vscroll.cpp
index aa52fab013343200cf29a6f6a68d69389362b3a2..9267c8aad3329ddbc0eeaa85771012f116365974 100644 (file)
--- a/src/generic/vscroll.cpp
+++ b/src/generic/vscroll.cpp
@@ -17,6 +17,13 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+

 #include "wx/vscroll.h"
 
 // ----------------------------------------------------------------------------
 #include "wx/vscroll.h"
 
 // ----------------------------------------------------------------------------


@@ -26,6 +33,9 @@
 BEGIN_EVENT_TABLE(wxVScrolledWindow, wxPanel)
     EVT_SIZE(wxVScrolledWindow::OnSize)
     EVT_SCROLLWIN(wxVScrolledWindow::OnScroll)
 BEGIN_EVENT_TABLE(wxVScrolledWindow, wxPanel)
     EVT_SIZE(wxVScrolledWindow::OnSize)
     EVT_SCROLLWIN(wxVScrolledWindow::OnScroll)

+#if wxUSE_MOUSEWHEEL
+    EVT_MOUSEWHEEL(wxVScrolledWindow::OnMouseWheel)
+#endif

 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 


@@ -33,6 +43,8 @@ END_EVENT_TABLE()
 // implementation
 // ============================================================================
 
 // implementation
 // ============================================================================
 

+IMPLEMENT_ABSTRACT_CLASS(wxVScrolledWindow, wxPanel)
+

 // ----------------------------------------------------------------------------
 // initialization
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // initialization
 // ----------------------------------------------------------------------------


@@ -47,12 +59,48 @@ void wxVScrolledWindow::Init()
     m_nVisible = 1;
 
     m_heightTotal = 0;
     m_nVisible = 1;
 
     m_heightTotal = 0;

+
+#if wxUSE_MOUSEWHEEL
+    m_sumWheelRotation = 0;
+#endif

 }
 
 // ----------------------------------------------------------------------------
 // various helpers
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // various helpers
 // ----------------------------------------------------------------------------
 

+wxCoord wxVScrolledWindow::EstimateTotalHeight() const
+{
+    // estimate the total height: it is impossible to call
+    // OnGetLineHeight() for every line because there may be too many of
+    // them, so we just make a guess using some lines in the beginning,
+    // some in the end and some in the middle
+    static const size_t NUM_LINES_TO_SAMPLE = 10;
+
+    wxCoord heightTotal;
+    if ( m_lineMax < 3*NUM_LINES_TO_SAMPLE )
+    {
+        // in this case calculating exactly is faster and more correct than
+        // guessing
+        heightTotal = GetLinesHeight(0, m_lineMax);
+    }
+    else // too many lines to calculate exactly
+    {
+        // look at some lines in the beginning/middle/end
+        heightTotal =
+            GetLinesHeight(0, NUM_LINES_TO_SAMPLE) +
+                GetLinesHeight(m_lineMax - NUM_LINES_TO_SAMPLE, m_lineMax) +
+                    GetLinesHeight(m_lineMax/2 - NUM_LINES_TO_SAMPLE/2,
+                                   m_lineMax/2 + NUM_LINES_TO_SAMPLE/2);
+
+        // use the height of the lines we looked as the average
+        heightTotal = (wxCoord)
+                (((float)heightTotal / (3*NUM_LINES_TO_SAMPLE)) * m_lineMax);
+    }
+
+    return heightTotal;
+}
+

 wxCoord wxVScrolledWindow::GetLinesHeight(size_t lineMin, size_t lineMax) const
 {
     if ( lineMin == lineMax )
 wxCoord wxVScrolledWindow::GetLinesHeight(size_t lineMin, size_t lineMax) const
 {
     if ( lineMin == lineMax )


@@ -74,7 +122,7 @@ wxCoord wxVScrolledWindow::GetLinesHeight(size_t lineMin, size_t lineMax) const
     return height;
 }
 
     return height;
 }
 

-size_t wxVScrolledWindow::FindFirstFromBottom(size_t lineLast)
+size_t wxVScrolledWindow::FindFirstFromBottom(size_t lineLast, bool full)

 {
     const wxCoord hWindow = GetClientSize().y;
 
 {
     const wxCoord hWindow = GetClientSize().y;
 


@@ -88,7 +136,13 @@ size_t wxVScrolledWindow::FindFirstFromBottom(size_t lineLast)
 
         if ( h > hWindow )
         {
 
         if ( h > hWindow )
         {

-            lineFirst++;
+            // for this line to be fully visible we need to go one line
+            // down, but if it is enough for it to be only partly visible then
+            // this line will do as well
+            if ( full )
+            {
+                lineFirst++;
+            }

 
             break;
         }
 
             break;
         }


@@ -141,36 +195,85 @@ void wxVScrolledWindow::SetLineCount(size_t count)
     // save the number of lines
     m_lineMax = count;
 
     // save the number of lines
     m_lineMax = count;
 

+    // and our estimate for their total height
+    m_heightTotal = EstimateTotalHeight();

 
 

-    // estimate the total height: it is impossible to call
-    // OnGetLineHeight() for every line because there may be too many of
-    // them, so we just make a guess using some lines in the beginning,
-    // some in the end and some in the middle
-    static const size_t NUM_LINES_TO_SAMPLE = 10;
+    // recalculate the scrollbars parameters
+    m_lineFirst = 1;    // make sure it is != 0
+    ScrollToLine(0);
+}

 
 

-    if ( count < 3*NUM_LINES_TO_SAMPLE )
+void wxVScrolledWindow::RefreshLine(size_t line)
+{
+    // is this line visible?
+    if ( !IsVisible(line) )

     {
     {

-        // in this case calculating exactly is faster and more correct than
-        // guessing
-        m_heightTotal = GetLinesHeight(0, m_lineMax);
+        // no, it is useless to do anything
+        return;

     }
     }

-    else // too many lines to calculate exactly
+
+    // calculate the rect occupied by this line on screen
+    wxRect rect;
+    rect.width = GetClientSize().x;
+    rect.height = OnGetLineHeight(line);
+    for ( size_t n = GetVisibleBegin(); n < line; n++ )

     {
     {

-        // look at some lines in the beginning/middle/end
-        m_heightTotal =
-            GetLinesHeight(0, NUM_LINES_TO_SAMPLE) +
-                GetLinesHeight(count - NUM_LINES_TO_SAMPLE, count) +
-                    GetLinesHeight(count/2 - NUM_LINES_TO_SAMPLE/2,
-                                   count/2 + NUM_LINES_TO_SAMPLE/2);
+        rect.y += OnGetLineHeight(n);
+    }

 
 

-        // use the height of the lines we looked as the average
-        m_heightTotal = ((float)m_heightTotal / (3*NUM_LINES_TO_SAMPLE)) *
-                            m_lineMax;
+    // do refresh it
+    RefreshRect(rect);
+}
+
+void wxVScrolledWindow::RefreshLines(size_t from, size_t to)
+{
+    wxASSERT_MSG( from <= to, _T("RefreshLines(): empty range") );
+
+    // clump the range to just the visible lines -- it is useless to refresh
+    // the other ones
+    if ( from < GetVisibleBegin() )
+        from = GetVisibleBegin();
+
+    if ( to >= GetVisibleEnd() )
+        to = GetVisibleEnd();
+    else
+        to++;
+
+    // calculate the rect occupied by these lines on screen
+    wxRect rect;
+    rect.width = GetClientSize().x;
+    for ( size_t nBefore = GetVisibleBegin(); nBefore < from; nBefore++ )
+    {
+        rect.y += OnGetLineHeight(nBefore);

     }
 
     }
 

+    for ( size_t nBetween = from; nBetween < to; nBetween++ )
+    {
+        rect.height += OnGetLineHeight(nBetween);
+    }

 
 

-    // recalculate the scrollbars parameters
-    ScrollToLine(0);
+    // do refresh it
+    RefreshRect(rect);
+}
+
+void wxVScrolledWindow::RefreshAll()
+{
+    UpdateScrollbar();
+
+    Refresh();
+}
+
+int wxVScrolledWindow::HitTest(wxCoord WXUNUSED(x), wxCoord y) const
+{
+    const size_t lineMax = GetVisibleEnd();
+    for ( size_t line = GetVisibleBegin(); line < lineMax; line++ )
+    {
+        y -= OnGetLineHeight(line);
+        if ( y < 0 )
+            return line;
+    }
+
+    return wxNOT_FOUND;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -187,7 +290,7 @@ bool wxVScrolledWindow::ScrollToLine(size_t line)
 
     // determine the real first line to scroll to: we shouldn't scroll beyond
     // the end
 
     // determine the real first line to scroll to: we shouldn't scroll beyond
     // the end

-    size_t lineFirstLast = FindFirstFromBottom(m_lineMax - 1);
+    size_t lineFirstLast = FindFirstFromBottom(m_lineMax - 1, true);

     if ( line > lineFirstLast )
         line = lineFirstLast;
 
     if ( line > lineFirstLast )
         line = lineFirstLast;
 


@@ -200,8 +303,8 @@ bool wxVScrolledWindow::ScrollToLine(size_t line)
 
 
     // remember the currently shown lines for the refresh code below
 
 
     // remember the currently shown lines for the refresh code below

-    size_t lineFirstOld = GetFirstVisibleLine(),
-           lineLastOld = GetLastVisibleLine();
+    size_t lineFirstOld = GetVisibleBegin(),
+           lineLastOld = GetVisibleEnd();

 
     m_lineFirst = line;
 
 
     m_lineFirst = line;
 


@@ -212,8 +315,8 @@ bool wxVScrolledWindow::ScrollToLine(size_t line)
 
     // finally refresh the display -- but only redraw as few lines as possible
     // to avoid flicker
 
     // finally refresh the display -- but only redraw as few lines as possible
     // to avoid flicker

-    if ( GetFirstVisibleLine() > lineLastOld ||
-            GetLastVisibleLine() < lineFirstOld )
+    if ( GetVisibleBegin() >= lineLastOld ||
+            GetVisibleEnd() <= lineFirstOld )

     {
         // the simplest case: we don't have any old lines left, just redraw
         // everything
     {
         // the simplest case: we don't have any old lines left, just redraw
         // everything


@@ -221,7 +324,7 @@ bool wxVScrolledWindow::ScrollToLine(size_t line)
     }
     else // overlap between the lines we showed before and should show now
     {
     }
     else // overlap between the lines we showed before and should show now
     {

-        ScrollWindow(0, GetLinesHeight(GetFirstVisibleLine(), lineFirstOld));
+        ScrollWindow(0, GetLinesHeight(GetVisibleBegin(), lineFirstOld));

     }
 
     return true;
     }
 
     return true;


@@ -245,12 +348,14 @@ bool wxVScrolledWindow::ScrollPages(int pages)
         int line;
         if ( pages > 0 )
         {
         int line;
         if ( pages > 0 )
         {

-            line = GetLastVisibleLine();
+            line = GetVisibleEnd();
+            if ( line )
+                line--;

             pages--;
         }
         else // pages < 0
         {
             pages--;
         }
         else // pages < 0
         {

-            line = FindFirstFromBottom(GetFirstVisibleLine());
+            line = FindFirstFromBottom(GetVisibleBegin());

             pages++;
         }
 
             pages++;
         }
 


@@ -276,6 +381,7 @@ void wxVScrolledWindow::OnScroll(wxScrollWinEvent& event)
     size_t lineFirstNew;
 
     const wxEventType evtType = event.GetEventType();
     size_t lineFirstNew;
 
     const wxEventType evtType = event.GetEventType();

+

     if ( evtType == wxEVT_SCROLLWIN_TOP )
     {
         lineFirstNew = 0;
     if ( evtType == wxEVT_SCROLLWIN_TOP )
     {
         lineFirstNew = 0;


@@ -298,25 +404,51 @@ void wxVScrolledWindow::OnScroll(wxScrollWinEvent& event)
     }
     else if ( evtType == wxEVT_SCROLLWIN_PAGEDOWN )
     {
     }
     else if ( evtType == wxEVT_SCROLLWIN_PAGEDOWN )
     {

-        lineFirstNew = GetLastVisibleLine();
+        lineFirstNew = GetVisibleEnd();
+        if ( lineFirstNew )
+            lineFirstNew--;

     }
     }

-    else // unknown scroll event?
+    else if ( evtType == wxEVT_SCROLLWIN_THUMBRELEASE )

     {
     {

-        if ( evtType == wxEVT_SCROLLWIN_THUMBRELEASE )
-        {
-            lineFirstNew = event.GetPosition();
-        }
-        else
-        {
-            wxASSERT_MSG( evtType == wxEVT_SCROLLWIN_THUMBTRACK,
-                            _T("unknown scroll event type?") );
+        lineFirstNew = event.GetPosition();
+    }
+    else if ( evtType == wxEVT_SCROLLWIN_THUMBTRACK )
+    {
+        lineFirstNew = event.GetPosition();
+    }

 
 

-            // don't do anything, otherwise dragging the thumb around would
-            // be too slow
-            return;
-        }
+    else // unknown scroll event?
+    {
+        wxFAIL_MSG( _T("unknown scroll event type?") );
+        return;

     }
 
     ScrollToLine(lineFirstNew);
     }
 
     ScrollToLine(lineFirstNew);

+
+#ifdef __WXMAC__
+    Update();
+#endif // __WXMAC__
+}
+
+#if wxUSE_MOUSEWHEEL
+
+void wxVScrolledWindow::OnMouseWheel(wxMouseEvent& event)
+{
+    m_sumWheelRotation += event.GetWheelRotation();
+    int delta = event.GetWheelDelta();
+
+    // how much to scroll this time
+    int units_to_scroll = -(m_sumWheelRotation/delta);
+    if ( !units_to_scroll )
+        return;
+
+    m_sumWheelRotation += units_to_scroll*delta;
+
+    if ( !event.IsPageScroll() )
+        ScrollLines( units_to_scroll*event.GetLinesPerAction() );
+    else
+        // scroll pages instead of lines
+        ScrollPages( units_to_scroll );

 }
 
 }
 

+#endif