Added ability to switch off more components of the size page UI

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

diff --git a/src/generic/vscroll.cpp b/src/generic/vscroll.cpp
index 492b3ead2c3e267c154abc6e2cff771ade9cf11d..589451775c9f6d0c436e0452e069fa4af4ff0e37 100644 (file)
--- a/src/generic/vscroll.cpp
+++ b/src/generic/vscroll.cpp
@@ -2,7 +2,7 @@
 // Name:        src/generic/vscroll.cpp
 // Purpose:     wxVScrolledWindow implementation
 // Author:      Vadim Zeitlin
 // Name:        src/generic/vscroll.cpp
 // Purpose:     wxVScrolledWindow implementation
 // Author:      Vadim Zeitlin

-// Modified by: Brad Anderson
+// Modified by: Brad Anderson, David Warkentin

 // Created:     30.05.03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
 // Created:     30.05.03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>


@@ -31,6 +31,8 @@
 
 #include "wx/vscroll.h"
 
 
 #include "wx/vscroll.h"
 

+#include "wx/utils.h"   // For wxMin/wxMax().
+

 // ============================================================================
 // wxVarScrollHelperEvtHandler declaration
 // ============================================================================
 // ============================================================================
 // wxVarScrollHelperEvtHandler declaration
 // ============================================================================


@@ -53,7 +55,7 @@ public:
 private:
     wxVarScrollHelperBase *m_scrollHelper;
 
 private:
     wxVarScrollHelperBase *m_scrollHelper;
 

-    DECLARE_NO_COPY_CLASS(wxVarScrollHelperEvtHandler)
+    wxDECLARE_NO_COPY_CLASS(wxVarScrollHelperEvtHandler);

 };
 
 // ============================================================================
 };
 
 // ============================================================================


@@ -97,10 +99,6 @@ bool wxVarScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     if ( wasSkipped )
         event.Skip(false);
 
     if ( wasSkipped )
         event.Skip(false);
 

-    // reset the skipped flag to false as it might have been set to true in
-    // ProcessEvent() above
-    event.Skip(false);
-

     if ( evType == wxEVT_SCROLLWIN_TOP ||
          evType == wxEVT_SCROLLWIN_BOTTOM ||
          evType == wxEVT_SCROLLWIN_LINEUP ||
     if ( evType == wxEVT_SCROLLWIN_TOP ||
          evType == wxEVT_SCROLLWIN_BOTTOM ||
          evType == wxEVT_SCROLLWIN_LINEUP ||


@@ -127,8 +125,7 @@ bool wxVarScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     }
 #endif // wxUSE_MOUSEWHEEL
 
     }
 #endif // wxUSE_MOUSEWHEEL
 

-    if ( processed )
-        event.Skip(wasSkipped);
+    event.Skip(wasSkipped);

 
     return processed;
 }
 
     return processed;
 }


@@ -144,7 +141,7 @@ bool wxVarScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
 
 wxVarScrollHelperBase::wxVarScrollHelperBase(wxWindow *win)
 {
 
 wxVarScrollHelperBase::wxVarScrollHelperBase(wxWindow *win)
 {

-    wxASSERT_MSG( win, _T("associated window can't be NULL in wxVarScrollHelperBase") );
+    wxASSERT_MSG( win, wxT("associated window can't be NULL in wxVarScrollHelperBase") );

 
 #if wxUSE_MOUSEWHEEL
     m_sumWheelRotation = 0;
 
 #if wxUSE_MOUSEWHEEL
     m_sumWheelRotation = 0;


@@ -155,8 +152,9 @@ wxVarScrollHelperBase::wxVarScrollHelperBase(wxWindow *win)
     m_unitFirst = 0;
 
     m_win =
     m_unitFirst = 0;
 
     m_win =

-    m_targetWindow = (wxWindow *)NULL;
+    m_targetWindow = NULL;

 
 

+    m_physicalScrolling = true;

     m_handler = NULL;
 
     m_win = win;
     m_handler = NULL;
 
     m_win = win;


@@ -312,14 +310,17 @@ size_t wxVarScrollHelperBase::GetNewScrollPosition(wxScrollWinEvent& event) cons
     }
     else if ( evtType == wxEVT_SCROLLWIN_PAGEUP )
     {
     }
     else if ( evtType == wxEVT_SCROLLWIN_PAGEUP )
     {

-        return FindFirstVisibleFromLast(m_unitFirst);
+        // Page up should do at least as much as line up.
+        return wxMin(FindFirstVisibleFromLast(m_unitFirst),
+                    m_unitFirst ? m_unitFirst - 1 : 0);

     }
     else if ( evtType == wxEVT_SCROLLWIN_PAGEDOWN )
     {
     }
     else if ( evtType == wxEVT_SCROLLWIN_PAGEDOWN )
     {

+        // And page down should do at least as much as line down.

         if ( GetVisibleEnd() )
         if ( GetVisibleEnd() )

-            return GetVisibleEnd() - 1;
+            return wxMax(GetVisibleEnd() - 1, m_unitFirst + 1);

         else
         else

-            return GetVisibleEnd();
+            return wxMax(GetVisibleEnd(), m_unitFirst + 1);

     }
     else if ( evtType == wxEVT_SCROLLWIN_THUMBRELEASE )
     {
     }
     else if ( evtType == wxEVT_SCROLLWIN_THUMBRELEASE )
     {


@@ -331,7 +332,7 @@ size_t wxVarScrollHelperBase::GetNewScrollPosition(wxScrollWinEvent& event) cons
     }
 
     // unknown scroll event?
     }
 
     // unknown scroll event?

-    wxFAIL_MSG( _T("unknown scroll event type?") );
+    wxFAIL_MSG( wxT("unknown scroll event type?") );

     return 0;
 }
 
     return 0;
 }
 


@@ -475,7 +476,7 @@ void wxVarScrollHelperBase::RefreshUnit(size_t unit)
 
 void wxVarScrollHelperBase::RefreshUnits(size_t from, size_t to)
 {
 
 void wxVarScrollHelperBase::RefreshUnits(size_t from, size_t to)
 {

-    wxASSERT_MSG( from <= to, _T("RefreshUnits(): empty range") );
+    wxASSERT_MSG( from <= to, wxT("RefreshUnits(): empty range") );

 
     // clump the range to just the visible units -- it is useless to refresh
     // the other ones
 
     // clump the range to just the visible units -- it is useless to refresh
     // the other ones


@@ -486,10 +487,10 @@ void wxVarScrollHelperBase::RefreshUnits(size_t from, size_t to)
         to = GetVisibleEnd();
 
     // calculate the rect occupied by these units on screen
         to = GetVisibleEnd();
 
     // calculate the rect occupied by these units on screen

-    int orient_size, nonorient_size, orient_pos;
-    orient_size = nonorient_size = orient_pos = 0;
+    int orient_size = 0,
+        orient_pos = 0;

 
 

-    nonorient_size = GetNonOrientationTargetSize();
+    int nonorient_size = GetNonOrientationTargetSize();

 
     for ( size_t nBefore = GetVisibleBegin();
           nBefore < from;
 
     for ( size_t nBefore = GetVisibleBegin();
           nBefore < from;


@@ -539,7 +540,7 @@ bool wxVarScrollHelperBase::ScrollLayout()
     return m_targetWindow->wxWindow::Layout();
 }
 
     return m_targetWindow->wxWindow::Layout();
 }
 

-int wxVarScrollHelperBase::HitTest(wxCoord coord) const
+int wxVarScrollHelperBase::VirtualHitTest(wxCoord coord) const

 {
     const size_t unitMax = GetVisibleEnd();
     for ( size_t unit = GetVisibleBegin(); unit < unitMax; ++unit )
 {
     const size_t unitMax = GetVisibleEnd();
     for ( size_t unit = GetVisibleBegin(); unit < unitMax; ++unit )


@@ -592,7 +593,7 @@ bool wxVarScrollHelperBase::DoScrollToUnit(size_t unit)
     // to avoid flicker.  We can't do this if we have children because they
     // won't be scrolled
     if ( m_targetWindow->GetChildren().empty() &&
     // to avoid flicker.  We can't do this if we have children because they
     // won't be scrolled
     if ( m_targetWindow->GetChildren().empty() &&

-         GetVisibleBegin() >= unitLastOld || GetVisibleEnd() <= unitFirstOld )
+         (GetVisibleBegin() >= unitLastOld || GetVisibleEnd() <= unitFirstOld) )

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


@@ -600,7 +601,12 @@ bool wxVarScrollHelperBase::DoScrollToUnit(size_t unit)
     }
     else // scroll the window
     {
     }
     else // scroll the window
     {

+        // Avoid scrolling visible parts of the screen on Mac
+#ifdef __WXMAC__
+        if (m_physicalScrolling && m_targetWindow->IsShownOnScreen())
+#else

         if ( m_physicalScrolling )
         if ( m_physicalScrolling )

+#endif

         {
             wxCoord dx = 0,
                     dy = GetUnitsSize(GetVisibleBegin(), unitFirstOld);
         {
             wxCoord dx = 0,
                     dy = GetUnitsSize(GetVisibleBegin(), unitFirstOld);


@@ -668,6 +674,39 @@ bool wxVarScrollHelperBase::DoScrollPages(int pages)
 
 void wxVarScrollHelperBase::HandleOnSize(wxSizeEvent& event)
 {
 
 void wxVarScrollHelperBase::HandleOnSize(wxSizeEvent& event)
 {

+    if ( m_unitMax )
+    {
+        // sometimes change in varscrollable window's size can result in
+        // unused empty space after the last item. Fix it by decrementing
+        // first visible item position according to the available space.
+
+        // determine free space
+        const wxCoord sWindow = GetOrientationTargetSize();
+        wxCoord s = 0;
+        size_t unit;
+        for ( unit = m_unitFirst; unit < m_unitMax; ++unit )
+        {
+            if ( s > sWindow )
+                break;
+
+            s += OnGetUnitSize(unit);
+        }
+        wxCoord freeSpace = sWindow - s;
+
+        // decrement first visible item index as long as there is free space
+        size_t idealUnitFirst;
+        for ( idealUnitFirst = m_unitFirst;
+              idealUnitFirst > 0;
+              idealUnitFirst-- )
+        {
+            wxCoord us = OnGetUnitSize(idealUnitFirst-1);
+            if ( freeSpace < us )
+                break;
+            freeSpace -= us;
+        }
+        m_unitFirst = idealUnitFirst;
+    }
+

     UpdateScrollbar();
 
     event.Skip();
     UpdateScrollbar();
 
     event.Skip();


@@ -788,7 +827,7 @@ void wxVarHVScrollHelper::RefreshRowColumn(size_t row, size_t column)
         h_rect.x += OnGetColumnWidth(n);
     }
 
         h_rect.x += OnGetColumnWidth(n);
     }
 

-    // refresh but specialize the behavior if we have a single target window
+    // refresh but specialize the behaviour if we have a single target window

     if ( wxVarVScrollHelper::GetTargetWindow() == wxVarHScrollHelper::GetTargetWindow() )
     {
         v_rect.x = h_rect.x;
     if ( wxVarVScrollHelper::GetTargetWindow() == wxVarHScrollHelper::GetTargetWindow() )
     {
         v_rect.x = h_rect.x;


@@ -811,7 +850,7 @@ void wxVarHVScrollHelper::RefreshRowsColumns(size_t fromRow, size_t toRow,
                                              size_t fromColumn, size_t toColumn)
 {
     wxASSERT_MSG( fromRow <= toRow || fromColumn <= toColumn,
                                              size_t fromColumn, size_t toColumn)
 {
     wxASSERT_MSG( fromRow <= toRow || fromColumn <= toColumn,

-        _T("RefreshRowsColumns(): empty range") );
+        wxT("RefreshRowsColumns(): empty range") );

 
     // clump the range to just the visible units -- it is useless to refresh
     // the other ones
 
     // clump the range to just the visible units -- it is useless to refresh
     // the other ones


@@ -855,7 +894,7 @@ void wxVarHVScrollHelper::RefreshRowsColumns(size_t fromRow, size_t toRow,
         h_rect.width += OnGetColumnWidth(nBetween);
     }
 
         h_rect.width += OnGetColumnWidth(nBetween);
     }
 

-    // refresh but specialize the behavior if we have a single target window
+    // refresh but specialize the behaviour if we have a single target window

     if ( wxVarVScrollHelper::GetTargetWindow() == wxVarHScrollHelper::GetTargetWindow() )
     {
         v_rect.x = h_rect.x;
     if ( wxVarVScrollHelper::GetTargetWindow() == wxVarHScrollHelper::GetTargetWindow() )
     {
         v_rect.x = h_rect.x;


@@ -874,10 +913,10 @@ void wxVarHVScrollHelper::RefreshRowsColumns(size_t fromRow, size_t toRow,
     }
 }
 
     }
 }
 

-wxPosition wxVarHVScrollHelper::HitTest(wxCoord x, wxCoord y) const
+wxPosition wxVarHVScrollHelper::VirtualHitTest(wxCoord x, wxCoord y) const

 {
 {

-    return wxPosition(wxVarVScrollHelper::HitTest(y),
-                        wxVarHScrollHelper::HitTest(x));
+    return wxPosition(wxVarVScrollHelper::VirtualHitTest(y),
+                      wxVarHScrollHelper::VirtualHitTest(x));

 }
 
 void wxVarHVScrollHelper::DoPrepareDC(wxDC& dc)
 }
 
 void wxVarHVScrollHelper::DoPrepareDC(wxDC& dc)


@@ -923,3 +962,60 @@ IMPLEMENT_ABSTRACT_CLASS(wxVScrolledWindow, wxPanel)
 IMPLEMENT_ABSTRACT_CLASS(wxHScrolledWindow, wxPanel)
 IMPLEMENT_ABSTRACT_CLASS(wxHVScrolledWindow, wxPanel)
 
 IMPLEMENT_ABSTRACT_CLASS(wxHScrolledWindow, wxPanel)
 IMPLEMENT_ABSTRACT_CLASS(wxHVScrolledWindow, wxPanel)
 

+
+#if WXWIN_COMPATIBILITY_2_8
+
+// ===========================================================================
+// wxVarVScrollLegacyAdaptor
+// ===========================================================================
+
+size_t wxVarVScrollLegacyAdaptor::GetFirstVisibleLine() const
+{ return GetVisibleRowsBegin(); }
+
+size_t wxVarVScrollLegacyAdaptor::GetLastVisibleLine() const
+{ return GetVisibleRowsEnd() - 1; }
+
+size_t wxVarVScrollLegacyAdaptor::GetLineCount() const
+{ return GetRowCount(); }
+
+void wxVarVScrollLegacyAdaptor::SetLineCount(size_t count)
+{ SetRowCount(count); }
+
+void wxVarVScrollLegacyAdaptor::RefreshLine(size_t line)
+{ RefreshRow(line); }
+
+void wxVarVScrollLegacyAdaptor::RefreshLines(size_t from, size_t to)
+{ RefreshRows(from, to); }
+
+bool wxVarVScrollLegacyAdaptor::ScrollToLine(size_t line)
+{ return ScrollToRow(line); }
+
+bool wxVarVScrollLegacyAdaptor::ScrollLines(int lines)
+{ return ScrollRows(lines); }
+
+bool wxVarVScrollLegacyAdaptor::ScrollPages(int pages)
+{ return ScrollRowPages(pages); }
+
+wxCoord wxVarVScrollLegacyAdaptor::OnGetLineHeight(size_t WXUNUSED(n)) const
+{
+    wxFAIL_MSG( wxT("OnGetLineHeight() must be overridden if OnGetRowHeight() isn't!") );
+    return -1;
+}
+
+void wxVarVScrollLegacyAdaptor::OnGetLinesHint(size_t WXUNUSED(lineMin),
+                                               size_t WXUNUSED(lineMax)) const
+{
+}
+
+wxCoord wxVarVScrollLegacyAdaptor::OnGetRowHeight(size_t n) const
+{
+    return OnGetLineHeight(n);
+}
+
+void wxVarVScrollLegacyAdaptor::OnGetRowsHeightHint(size_t rowMin,
+                                                    size_t rowMax) const
+{
+    OnGetLinesHint(rowMin, rowMax);
+}
+
+#endif // WXWIN_COMPATIBILITY_2_8