further untangle generic and native GTK implementations of wxScrollHelper: use the standard wxScrollHelperBase/wxScrollHelper naming convention and move the stuff unused by GTK in the generic implementation

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@57531 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/generic/scrolwin.h

@@ -1,11 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/generic/scrolwin.h
-// Purpose:     wxGenericScrolledWindow class
+// Purpose:     generic wxScrollHelper
-// Author:      Julian Smart
+// Author:      Vadim Zeitlin
-// Modified by:
+// Created:     2008-12-24 (replacing old file with the same name)
-// Created:     01/02/97
 // RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart
+// Copyright:   (c) 2008 Vadim Zeitlin <vadim@wxwidgets.org>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
@@ -13,15 +12,40 @@
 #define _WX_GENERIC_SCROLLWIN_H_
 
 // ----------------------------------------------------------------------------
-// headers and constants
+// generic wxScrollHelper implementation
 // ----------------------------------------------------------------------------
 
-#include "wx/window.h"
+class WXDLLIMPEXP_CORE wxScrollHelper : public wxScrollHelperBase
-#include "wx/panel.h"
+{
+public:
+    wxScrollHelper(wxWindow *winToScroll);
 
-// ----------------------------------------------------------------------------
+    // implement base class pure virtuals
-// wxGenericScrolledWindow
+    virtual void AdjustScrollbars();
-// ----------------------------------------------------------------------------
+
+private:
+    virtual void DoScroll(int x, int y);
+    virtual void DoShowScrollbars(wxScrollbarVisibility horz,
+                                  wxScrollbarVisibility vert);
+
+    // helper of AdjustScrollbars(): does the work for the single scrollbar
+    //
+    // notice that the parameters passed by non-const references are modified
+    // by this function
+    void DoAdjustScrollbar(int orient,
+                           int clientSize,
+                           int virtSize,
+                           int& pixelsPerUnit,
+                           int& scrollUnits,
+                           int& scrollPosition,
+                           wxScrollbarVisibility visibility);
+
+
+    wxScrollbarVisibility m_xVisibility,
+                          m_yVisibility;
+
+    DECLARE_NO_COPY_CLASS(wxScrollHelper)
+};
 
 #endif // _WX_GENERIC_SCROLLWIN_H_
 

include/wx/gtk/scrolwin.h

@@ -16,11 +16,11 @@
 // wxScrolledWindow
 // ----------------------------------------------------------------------------
 
-class WXDLLIMPEXP_CORE wxScrollHelperNative : public wxScrollHelper
+class WXDLLIMPEXP_CORE wxScrollHelper : public wxScrollHelperBase
 {
 public:
     // default ctor doesn't do anything
-    wxScrollHelperNative(wxWindow *win) : wxScrollHelper(win) { }
+    wxScrollHelper(wxWindow *win) : wxScrollHelperBase(win) { }
 
     virtual void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
                                int noUnitsX, int noUnitsY,
@@ -70,7 +70,7 @@ protected:
                                   wxScrollbarVisibility vert);
 
 private:
-    DECLARE_NO_COPY_CLASS(wxScrollHelperNative)
+    DECLARE_NO_COPY_CLASS(wxScrollHelper)
 };
 
 #endif // _WX_GTK_SCROLLWIN_H_

include/wx/gtk1/scrolwin.h

@@ -16,20 +16,23 @@
 // wxScrolledWindow
 // ----------------------------------------------------------------------------
 
-class WXDLLIMPEXP_CORE wxScrollHelperNative : public wxScrollHelper
+class WXDLLIMPEXP_CORE wxScrollHelper : public wxScrollHelperBase
 {
 public:
-    // default ctor doesn't do anything
+    wxScrollHelper(wxWindow *win) : wxScrollHelperBase(win) { }
-    wxScrollHelperNative(wxWindow *win) : wxScrollHelper(win) { }
 
+    // implement base class pure virtuals
     virtual void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
                                int noUnitsX, int noUnitsY,
                                int xPos = 0, int yPos = 0,
                                bool noRefresh = false);
     virtual void AdjustScrollbars();
-    virtual void Scroll(int x, int y);
 
 protected:
+    virtual void DoScroll(int x, int y);
+    virtual void DoShowScrollbars(wxScrollbarVisibility horz,
+                                  wxScrollbarVisibility vert);
+
     // this does (each) half of AdjustScrollbars() work
     void DoAdjustScrollbar(GtkAdjustment *adj,
                            int pixelsPerLine,
@@ -40,14 +43,14 @@ protected:
                            int *linesPerPage);
 
     // and this does the same for Scroll()
-    void DoScroll(int orient,
+    void DoScrollOneDir(int orient,
                         GtkAdjustment *adj,
                         int pos,
                         int pixelsPerLine,
                         int *posOld);
 
 private:
-    DECLARE_NO_COPY_CLASS(wxScrollHelperNative)
+    DECLARE_NO_COPY_CLASS(wxScrollHelper)
 };
 
 #endif // _WX_GTK_SCROLLWIN_H_

include/wx/scrolwin.h

@@ -37,11 +37,11 @@ enum wxScrollbarVisibility
 //
 // So we have
 //
-//                             wxScrollHelper
+//                           wxScrollHelperBase
 //                                   |
 //                                   |
 //                                  \|/
-//      wxWindow            wxScrollHelperNative
+//      wxWindow               wxScrollHelper
 //       |  \                   /        /
 //       |   \                 /        /
 //       |    _|             |_        /
@@ -56,12 +56,12 @@ enum wxScrollbarVisibility
 //
 // ----------------------------------------------------------------------------
 
-class WXDLLIMPEXP_CORE wxScrollHelper
+class WXDLLIMPEXP_CORE wxScrollHelperBase
 {
 public:
     // ctor must be given the associated window
-    wxScrollHelper(wxWindow *winToScroll);
+    wxScrollHelperBase(wxWindow *winToScroll);
-    virtual ~wxScrollHelper();
+    virtual ~wxScrollHelperBase();
 
     // configure the scrolling
     virtual void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
@@ -85,8 +85,7 @@ public:
     void SetScrollRate( int xstep, int ystep );
 
     // get the size of one logical unit in physical ones
-    virtual void GetScrollPixelsPerUnit(int *pixelsPerUnitX,
+    void GetScrollPixelsPerUnit(int *pixelsPerUnitX, int *pixelsPerUnitY) const;
-                                        int *pixelsPerUnitY) const;
 
     // Set scrollbar visibility: it is possible to show scrollbar only if it is
     // needed (i.e. if our virtual size is greater than the current size of the
@@ -139,21 +138,21 @@ public:
         return p2;
     }
 
-    virtual void DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const;
+    void DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const;
-    virtual void DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const;
+    void DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const;
 
     // Adjust the scrollbars
-    virtual void AdjustScrollbars(void);
+    virtual void AdjustScrollbars() = 0;
 
     // Calculate scroll increment
-    virtual int CalcScrollInc(wxScrollWinEvent& event);
+    int CalcScrollInc(wxScrollWinEvent& event);
 
     // Normally the wxScrolledWindow will scroll itself, but in some rare
     // occasions you might want it to scroll [part of] another window (e.g. a
     // child of it in order to scroll only a portion the area between the
     // scrollbars (spreadsheet: only cell area will move).
-    virtual void SetTargetWindow(wxWindow *target);
+    void SetTargetWindow(wxWindow *target);
-    virtual wxWindow *GetTargetWindow() const;
+    wxWindow *GetTargetWindow() const;
 
     void SetTargetRect(const wxRect& rect) { m_rectToScroll = rect; }
     wxRect GetTargetRect() const { return m_rectToScroll; }
@@ -219,9 +218,9 @@ protected:
 
     // implementation of public methods with the same name
     virtual void DoGetViewStart(int *x, int *y) const;
-    virtual void DoScroll(int x, int y);
+    virtual void DoScroll(int x, int y) = 0;
     virtual void DoShowScrollbars(wxScrollbarVisibility horz,
-                                  wxScrollbarVisibility vert);
+                                  wxScrollbarVisibility vert) = 0;
 
     // implementations of various wxWindow virtual methods which should be
     // forwarded to us (this can be done by WX_FORWARD_TO_SCROLL_HELPER())
@@ -240,18 +239,6 @@ protected:
     // in wxScrollHelperEvtHandler::ProcessEvent()
     void ResetDrawnFlag();
 
-    // helper of AdjustScrollbars(): does the work for the single scrollbar
-    //
-    // notice that the parameters passed by non-const references are modified
-    // by this function
-    void AdjustScrollbar(int orient,
-                         int clientSize,
-                         int virtSize,
-                         int& pixelsPerUnit,
-                         int& scrollUnits,
-                         int& scrollPosition,
-                         wxScrollbarVisibility visibility);
-
     // this function should be overridden to return the size available for
     // m_targetWindow inside m_win of the given size
     //
@@ -297,10 +284,7 @@ protected:
 
     wxScrollHelperEvtHandler *m_handler;
 
-    wxScrollbarVisibility m_xVisibility,
+    DECLARE_NO_COPY_CLASS(wxScrollHelperBase)
-                          m_yVisibility;
-
-    DECLARE_NO_COPY_CLASS(wxScrollHelper)
 };
 
 // this macro can be used in a wxScrollHelper-derived class to forward wxWindow
@@ -314,13 +298,14 @@ public:                                                                       \
     virtual wxSize GetBestVirtualSize() const                                 \
         { return ScrollGetBestVirtualSize(); }
 
-// include the declaration of wxScrollHelperNative if needed
+// include the declaration of the real wxScrollHelper
 #if defined(__WXGTK20__) && !defined(__WXUNIVERSAL__)
     #include "wx/gtk/scrolwin.h"
 #elif defined(__WXGTK__) && !defined(__WXUNIVERSAL__)
     #include "wx/gtk1/scrolwin.h"
 #else
-    typedef wxScrollHelper wxScrollHelperNative;
+    #define wxHAS_GENERIC_SCROLLWIN
+    #include "wx/generic/scrolwin.h"
 #endif
 
 // ----------------------------------------------------------------------------
@@ -331,7 +316,7 @@ public:                                                                       \
 struct WXDLLIMPEXP_CORE wxScrolledT_Helper
 {
     static wxSize FilterBestSize(const wxWindow *win,
-                                 const wxScrollHelperNative *helper,
+                                 const wxScrollHelper *helper,
                                  const wxSize& origBest);
 #ifdef __WXMSW__
     static WXLRESULT FilterMSWWindowProc(WXUINT nMsg, WXLRESULT origResult);
@@ -343,18 +328,18 @@ struct WXDLLIMPEXP_CORE wxScrolledT_Helper
 // not always desirable.
 template<class T>
 class WXDLLIMPEXP_CORE wxScrolled : public T,
-                                    public wxScrollHelperNative,
+                                    public wxScrollHelper,
                                     private wxScrolledT_Helper
 {
 public:
-    wxScrolled() : wxScrollHelperNative(this) { }
+    wxScrolled() : wxScrollHelper(this) { }
     wxScrolled(wxWindow *parent,
                wxWindowID winid = wxID_ANY,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = wxScrolledWindowStyle,
                const wxString& name = wxPanelNameStr)
-        : wxScrollHelperNative(this)
+        : wxScrollHelper(this)
     {
         Create(parent, winid, pos, size, style, name);
     }

src/generic/scrlwing.cpp

@@ -72,7 +72,7 @@
 class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
 {
 public:
-    wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)
+    wxScrollHelperEvtHandler(wxScrollHelperBase *scrollHelper)
     {
         m_scrollHelper = scrollHelper;
     }
@@ -82,7 +82,7 @@ public:
     void ResetDrawnFlag() { m_hasDrawnWindow = false; }
 
 private:
-    wxScrollHelper *m_scrollHelper;
+    wxScrollHelperBase *m_scrollHelper;
 
     bool m_hasDrawnWindow;
 
@@ -98,7 +98,8 @@ private:
 class wxAutoScrollTimer : public wxTimer
 {
 public:
-    wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll,
+    wxAutoScrollTimer(wxWindow *winToScroll,
+                      wxScrollHelperBase *scroll,
                       wxEventType eventTypeToSend,
                       int pos, int orient);
 
@@ -106,7 +107,7 @@ public:
 
 private:
     wxWindow *m_win;
-    wxScrollHelper *m_scrollHelper;
+    wxScrollHelperBase *m_scrollHelper;
     wxEventType m_eventType;
     int m_pos,
         m_orient;
@@ -123,7 +124,7 @@ private:
 // ----------------------------------------------------------------------------
 
 wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll,
-                                     wxScrollHelper *scroll,
+                                     wxScrollHelperBase *scroll,
                                      wxEventType eventTypeToSend,
                                      int pos, int orient)
 {
@@ -303,11 +304,15 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     return processed;
 }
 
+// ============================================================================
+// wxScrollHelperBase implementation
+// ============================================================================
+
 // ----------------------------------------------------------------------------
-// wxScrollHelper construction
+// wxScrollHelperBase construction
 // ----------------------------------------------------------------------------
 
-wxScrollHelper::wxScrollHelper(wxWindow *win)
+wxScrollHelperBase::wxScrollHelperBase(wxWindow *win)
 {
     wxASSERT_MSG( win, _T("associated window can't be NULL in wxScrollHelper") );
 
@@ -323,9 +328,6 @@ wxScrollHelper::wxScrollHelper(wxWindow *win)
     m_xScrollingEnabled =
     m_yScrollingEnabled = true;
 
-    m_xVisibility =
-    m_yVisibility = wxSHOW_SB_DEFAULT;
-
     m_scaleX =
     m_scaleY = 1.0;
 #if wxUSE_MOUSEWHEEL
@@ -333,21 +335,21 @@ wxScrollHelper::wxScrollHelper(wxWindow *win)
 #endif
 
     m_win =
-    m_targetWindow = (wxWindow *)NULL;
+    m_targetWindow = NULL;
 
-    m_timerAutoScroll = (wxTimer *)NULL;
+    m_timerAutoScroll = NULL;
 
     m_handler = NULL;
 
     m_win = win;
 
-    m_win->SetScrollHelper( this );
+    m_win->SetScrollHelper(static_cast<wxScrollHelper *>(this));
 
     // by default, the associated window is also the target window
     DoSetTargetWindow(win);
 }
 
-wxScrollHelper::~wxScrollHelper()
+wxScrollHelperBase::~wxScrollHelperBase()
 {
     StopAutoScrolling();
 
@@ -358,7 +360,7 @@ wxScrollHelper::~wxScrollHelper()
 // setting scrolling parameters
 // ----------------------------------------------------------------------------
 
-void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
+void wxScrollHelperBase::SetScrollbars(int pixelsPerUnitX,
                                        int pixelsPerUnitY,
                                        int noUnitsX,
                                        int noUnitsY,
@@ -425,7 +427,7 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
 // [target] window handling
 // ----------------------------------------------------------------------------
 
-void wxScrollHelper::DeleteEvtHandler()
+void wxScrollHelperBase::DeleteEvtHandler()
 {
     // search for m_handler in the handler list
     if ( m_win && m_handler )
@@ -441,13 +443,13 @@ void wxScrollHelper::DeleteEvtHandler()
     }
 }
 
-void wxScrollHelper::ResetDrawnFlag()
+void wxScrollHelperBase::ResetDrawnFlag()
 {
     wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" );
     m_handler->ResetDrawnFlag();
 }
 
-void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target)
 {
     m_targetWindow = target;
 #ifdef __WXMAC__
@@ -467,7 +469,7 @@ void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
     }
 }
 
-void wxScrollHelper::SetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::SetTargetWindow(wxWindow *target)
 {
     wxCHECK_RET( target, wxT("target window must not be NULL") );
 
@@ -477,7 +479,7 @@ void wxScrollHelper::SetTargetWindow(wxWindow *target)
     DoSetTargetWindow(target);
 }
 
-wxWindow *wxScrollHelper::GetTargetWindow() const
+wxWindow *wxScrollHelperBase::GetTargetWindow() const
 {
     return m_targetWindow;
 }
@@ -486,7 +488,7 @@ wxWindow *wxScrollHelper::GetTargetWindow() const
 // scrolling implementation itself
 // ----------------------------------------------------------------------------
 
-void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
+void wxScrollHelperBase::HandleOnScroll(wxScrollWinEvent& event)
 {
     int nScrollInc = CalcScrollInc(event);
     if ( nScrollInc == 0 )
@@ -558,7 +560,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
     }
 }
 
-int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
+int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event)
 {
     int pos = event.GetPosition();
     int orient = event.GetOrientation();
@@ -647,196 +649,7 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
     return nScrollInc;
 }
 
-void
+void wxScrollHelperBase::DoPrepareDC(wxDC& dc)
-wxScrollHelper::AdjustScrollbar(int orient,
-                                int clientSize,
-                                int virtSize,
-                                int& pixelsPerUnit,
-                                int& scrollUnits,
-                                int& scrollPosition,
-                                wxScrollbarVisibility visibility)
-{
-    if ( visibility == wxSHOW_SB_NEVER )
-    {
-        m_win->SetScrollbar(orient, 0, 0, 0);
-        return;
-    }
-
-    // scroll lines per page: if 0, no scrolling is needed
-    int unitsPerPage;
-
-    // check if we need scrollbar in this direction at all
-    if ( pixelsPerUnit == 0 ||
-            (clientSize >= virtSize && visibility != wxSHOW_SB_ALWAYS) )
-    {
-        // scrolling is disabled or unnecessary
-        scrollUnits =
-        scrollPosition = 0;
-        unitsPerPage = 0;
-    }
-    else // might need scrolling
-    {
-        // Round up integer division to catch any "leftover" client space.
-        scrollUnits = (virtSize + pixelsPerUnit - 1) / pixelsPerUnit;
-
-        // Calculate the number of fully scroll units
-        unitsPerPage = clientSize / pixelsPerUnit;
-
-        if (unitsPerPage >= scrollUnits)
-        {
-            // we're big enough to not need scrolling
-            scrollUnits =
-            scrollPosition = 0;
-            unitsPerPage = 0;
-        }
-        else // we do need a scrollbar
-        {
-            if ( unitsPerPage < 1 )
-                unitsPerPage = 1;
-
-            // Correct position if greater than extent of canvas minus
-            // the visible portion of it or if below zero
-            const int posMax = scrollUnits - unitsPerPage;
-            if ( scrollPosition > posMax )
-                scrollPosition = posMax;
-            else if ( scrollPosition < 0 )
-                scrollPosition = 0;
-        }
-    }
-
-    m_win->SetScrollbar(orient, scrollPosition, unitsPerPage, scrollUnits);
-
-    // The amount by which we scroll when paging
-    SetScrollPageSize(orient, unitsPerPage);
-}
-
-void wxScrollHelper::AdjustScrollbars()
-{
-    static wxRecursionGuardFlag s_flagReentrancy;
-    wxRecursionGuard guard(s_flagReentrancy);
-    if ( guard.IsInside() )
-    {
-        // don't reenter AdjustScrollbars() while another call to
-        // AdjustScrollbars() is in progress because this may lead to calling
-        // ScrollWindow() twice and this can really happen under MSW if
-        // SetScrollbar() call below adds or removes the scrollbar which
-        // changes the window size and hence results in another
-        // AdjustScrollbars() call
-        return;
-    }
-
-    int oldXScroll = m_xScrollPosition;
-    int oldYScroll = m_yScrollPosition;
-
-    // we may need to readjust the scrollbars several times as enabling one of
-    // them reduces the area available for the window contents and so can make
-    // the other scrollbar necessary now although it wasn't necessary before
-    //
-    // VZ: normally this loop should be over in at most 2 iterations, I don't
-    //     know why do we need 5 of them
-    for ( int iterationCount = 0; iterationCount < 5; iterationCount++ )
-    {
-        wxSize clientSize = GetTargetSize();
-        const wxSize virtSize = m_targetWindow->GetVirtualSize();
-
-        // this block of code tries to work around the following problem: the
-        // window could have been just resized to have enough space to show its
-        // full contents without the scrollbars, but its client size could be
-        // not big enough because it does have the scrollbars right now and so
-        // the scrollbars would remain even though we don't need them any more
-        //
-        // to prevent this from happening, check if we have enough space for
-        // everything without the scrollbars and explicitly disable them then
-        const wxSize availSize = GetSizeAvailableForScrollTarget(
-            m_win->GetSize() - m_win->GetWindowBorderSize());
-        if ( availSize != clientSize )
-        {
-            if ( availSize.x >= virtSize.x && availSize.y >= virtSize.y )
-            {
-                // this will be enough to make the scrollbars disappear below
-                // and then the client size will indeed become equal to the
-                // full available size
-                clientSize = availSize;
-            }
-        }
-
-
-        AdjustScrollbar(wxHORIZONTAL,
-                        clientSize.x,
-                        virtSize.x,
-                        m_xScrollPixelsPerLine,
-                        m_xScrollLines,
-                        m_xScrollPosition,
-                        m_xVisibility);
-
-        AdjustScrollbar(wxVERTICAL,
-                        clientSize.y,
-                        virtSize.y,
-                        m_yScrollPixelsPerLine,
-                        m_yScrollLines,
-                        m_yScrollPosition,
-                        m_yVisibility);
-
-
-        // If a scrollbar (dis)appeared as a result of this, we need to adjust
-        // them again but if the client size didn't change, then we're done
-        if ( GetTargetSize() == clientSize )
-            break;
-    }
-
-#ifdef __WXMOTIF__
-    // Sorry, some Motif-specific code to implement a backing pixmap
-    // for the wxRETAINED style. Implementing a backing store can't
-    // be entirely generic because it relies on the wxWindowDC implementation
-    // to duplicate X drawing calls for the backing pixmap.
-
-    if ( m_targetWindow->GetWindowStyle() & wxRETAINED )
-    {
-        Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget());
-
-        int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
-        int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
-        if (m_targetWindow->GetBackingPixmap() &&
-           !((m_targetWindow->GetPixmapWidth() == totalPixelWidth) &&
-             (m_targetWindow->GetPixmapHeight() == totalPixelHeight)))
-        {
-            XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap());
-            m_targetWindow->SetBackingPixmap((WXPixmap) 0);
-        }
-
-        if (!m_targetWindow->GetBackingPixmap() &&
-           (m_xScrollLines != 0) && (m_yScrollLines != 0))
-        {
-            int depth = wxDisplayDepth();
-            m_targetWindow->SetPixmapWidth(totalPixelWidth);
-            m_targetWindow->SetPixmapHeight(totalPixelHeight);
-            m_targetWindow->SetBackingPixmap((WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-              m_targetWindow->GetPixmapWidth(), m_targetWindow->GetPixmapHeight(), depth));
-        }
-
-    }
-#endif // Motif
-
-    if (oldXScroll != m_xScrollPosition)
-    {
-       if (m_xScrollingEnabled)
-            m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0,
-                                          GetScrollRect() );
-       else
-            m_targetWindow->Refresh(true, GetScrollRect());
-    }
-
-    if (oldYScroll != m_yScrollPosition)
-    {
-        if (m_yScrollingEnabled)
-            m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
-                                          GetScrollRect() );
-        else
-            m_targetWindow->Refresh(true, GetScrollRect());
-    }
-}
-
-void wxScrollHelper::DoPrepareDC(wxDC& dc)
 {
     wxPoint pt = dc.GetDeviceOrigin();
 #ifdef __WXGTK__
@@ -853,7 +666,7 @@ void wxScrollHelper::DoPrepareDC(wxDC& dc)
     dc.SetUserScale( m_scaleX, m_scaleY );
 }
 
-void wxScrollHelper::SetScrollRate( int xstep, int ystep )
+void wxScrollHelperBase::SetScrollRate( int xstep, int ystep )
 {
     int old_x = m_xScrollPixelsPerLine * m_xScrollPosition;
     int old_y = m_yScrollPixelsPerLine * m_yScrollPosition;
@@ -871,7 +684,7 @@ void wxScrollHelper::SetScrollRate( int xstep, int ystep )
     AdjustScrollbars();
 }
 
-void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
+void wxScrollHelperBase::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 {
     if ( x_unit )
         *x_unit = m_xScrollPixelsPerLine;
@@ -880,7 +693,7 @@ void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 }
 
 
-int wxScrollHelper::GetScrollLines( int orient ) const
+int wxScrollHelperBase::GetScrollLines( int orient ) const
 {
     if ( orient == wxHORIZONTAL )
         return m_xScrollLines;
@@ -888,7 +701,7 @@ int wxScrollHelper::GetScrollLines( int orient ) const
         return m_yScrollLines;
 }
 
-int wxScrollHelper::GetScrollPageSize(int orient) const
+int wxScrollHelperBase::GetScrollPageSize(int orient) const
 {
     if ( orient == wxHORIZONTAL )
         return m_xScrollLinesPerPage;
@@ -896,7 +709,7 @@ int wxScrollHelper::GetScrollPageSize(int orient) const
         return m_yScrollLinesPerPage;
 }
 
-void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
+void wxScrollHelperBase::SetScrollPageSize(int orient, int pageSize)
 {
     if ( orient == wxHORIZONTAL )
         m_xScrollLinesPerPage = pageSize;
@@ -904,101 +717,14 @@ void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
         m_yScrollLinesPerPage = pageSize;
 }
 
-/*
+void wxScrollHelperBase::EnableScrolling (bool x_scroll, bool y_scroll)
- * Scroll to given position (scroll position, not pixel position)
- */
-void wxScrollHelper::DoScroll( int x_pos, int y_pos )
-{
-    if (!m_targetWindow)
-        return;
-
-    if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
-        ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
-
-    int w = 0, h = 0;
-    GetTargetSize(&w, &h);
-
-    // compute new position:
-    int new_x = m_xScrollPosition;
-    int new_y = m_yScrollPosition;
-
-    if ((x_pos != -1) && (m_xScrollPixelsPerLine))
-    {
-        new_x = x_pos;
-
-        // Calculate page size i.e. number of scroll units you get on the
-        // current client window
-        int noPagePositions = w/m_xScrollPixelsPerLine;
-        if (noPagePositions < 1) noPagePositions = 1;
-
-        // Correct position if greater than extent of canvas minus
-        // the visible portion of it or if below zero
-        new_x = wxMin( m_xScrollLines-noPagePositions, new_x );
-        new_x = wxMax( 0, new_x );
-    }
-    if ((y_pos != -1) && (m_yScrollPixelsPerLine))
-    {
-        new_y = y_pos;
-
-        // Calculate page size i.e. number of scroll units you get on the
-        // current client window
-        int noPagePositions = h/m_yScrollPixelsPerLine;
-        if (noPagePositions < 1) noPagePositions = 1;
-
-        // Correct position if greater than extent of canvas minus
-        // the visible portion of it or if below zero
-        new_y = wxMin( m_yScrollLines-noPagePositions, new_y );
-        new_y = wxMax( 0, new_y );
-    }
-
-    if ( new_x == m_xScrollPosition && new_y == m_yScrollPosition )
-        return; // nothing to do, the position didn't change
-
-    // flush all pending repaints before we change m_{x,y}ScrollPosition, as
-    // otherwise invalidated area could be updated incorrectly later when
-    // ScrollWindow() makes sure they're repainted before scrolling them
-    m_targetWindow->Update();
-
-    // update the position and scroll the window now:
-    if (m_xScrollPosition != new_x)
-    {
-        int old_x = m_xScrollPosition;
-        m_xScrollPosition = new_x;
-        m_win->SetScrollPos( wxHORIZONTAL, new_x );
-        m_targetWindow->ScrollWindow( (old_x-new_x)*m_xScrollPixelsPerLine, 0,
-                                      GetScrollRect() );
-    }
-
-    if (m_yScrollPosition != new_y)
-    {
-        int old_y = m_yScrollPosition;
-        m_yScrollPosition = new_y;
-        m_win->SetScrollPos( wxVERTICAL, new_y );
-        m_targetWindow->ScrollWindow( 0, (old_y-new_y)*m_yScrollPixelsPerLine,
-                                      GetScrollRect() );
-    }
-}
-
-void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll)
 {
     m_xScrollingEnabled = x_scroll;
     m_yScrollingEnabled = y_scroll;
 }
 
-void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
-                                      wxScrollbarVisibility vert)
-{
-    if ( horz != m_xVisibility || vert != m_yVisibility )
-    {
-        m_xVisibility = horz;
-        m_yVisibility = vert;
-
-        AdjustScrollbars();
-    }
-}
-
 // Where the current view starts from
-void wxScrollHelper::DoGetViewStart (int *x, int *y) const
+void wxScrollHelperBase::DoGetViewStart (int *x, int *y) const
 {
     if ( x )
         *x = m_xScrollPosition;
@@ -1006,7 +732,8 @@ void wxScrollHelper::DoGetViewStart (int *x, int *y) const
         *y = m_yScrollPosition;
 }
 
-void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const
+void wxScrollHelperBase::DoCalcScrolledPosition(int x, int y,
+                                                int *xx, int *yy) const
 {
     if ( xx )
         *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
@@ -1014,7 +741,8 @@ void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) cons
         *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 }
 
-void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
+void wxScrollHelperBase::DoCalcUnscrolledPosition(int x, int y,
+                                                  int *xx, int *yy) const
 {
     if ( xx )
         *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
@@ -1026,7 +754,7 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co
 // geometry
 // ----------------------------------------------------------------------------
 
-bool wxScrollHelper::ScrollLayout()
+bool wxScrollHelperBase::ScrollLayout()
 {
     if ( m_win->GetSizer() && m_targetWindow == m_win )
     {
@@ -1044,7 +772,7 @@ bool wxScrollHelper::ScrollLayout()
     return m_win->wxWindow::Layout();
 }
 
-void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y)
+void wxScrollHelperBase::ScrollDoSetVirtualSize(int x, int y)
 {
     m_win->wxWindow::DoSetVirtualSize( x, y );
     AdjustScrollbars();
@@ -1055,7 +783,7 @@ void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y)
 
 // wxWindow's GetBestVirtualSize returns the actual window size,
 // whereas we want to return the virtual size
-wxSize wxScrollHelper::ScrollGetBestVirtualSize() const
+wxSize wxScrollHelperBase::ScrollGetBestVirtualSize() const
 {
     wxSize clientSize(m_win->GetClientSize());
     if ( m_win->GetSizer() )
@@ -1069,7 +797,7 @@ wxSize wxScrollHelper::ScrollGetBestVirtualSize() const
 // ----------------------------------------------------------------------------
 
 // Default OnSize resets scrollbars, if any
-void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
+void wxScrollHelperBase::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 {
     if ( m_targetWindow->GetAutoLayout() )
     {
@@ -1086,7 +814,7 @@ void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 
 // This calls OnDraw, having adjusted the origin according to the current
 // scroll position
-void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
+void wxScrollHelperBase::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
 {
     // don't use m_targetWindow here, this is always called for ourselves
     wxPaintDC dc(m_win);
@@ -1099,7 +827,7 @@ void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
 // compatibility here - if we used OnKeyDown(), the programs which process
 // arrows themselves in their OnChar() would never get the message and like
 // this they always have the priority
-void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
+void wxScrollHelperBase::HandleOnChar(wxKeyEvent& event)
 {
     int stx = 0, sty = 0,       // view origin
         szx = 0, szy = 0,       // view size (total)
@@ -1196,14 +924,14 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
 // a captured mouse is being held outside the window
 // ----------------------------------------------------------------------------
 
-bool wxScrollHelper::SendAutoScrollEvents(wxScrollWinEvent& event) const
+bool wxScrollHelperBase::SendAutoScrollEvents(wxScrollWinEvent& event) const
 {
     // only send the event if the window is scrollable in this direction
     wxWindow *win = (wxWindow *)event.GetEventObject();
     return win->HasScrollbar(event.GetOrientation());
 }
 
-void wxScrollHelper::StopAutoScrolling()
+void wxScrollHelperBase::StopAutoScrolling()
 {
 #if wxUSE_TIMER
     if ( m_timerAutoScroll )
@@ -1214,14 +942,14 @@ void wxScrollHelper::StopAutoScrolling()
 #endif
 }
 
-void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseEnter(wxMouseEvent& event)
 {
     StopAutoScrolling();
 
     event.Skip();
 }
 
-void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseLeave(wxMouseEvent& event)
 {
     // don't prevent the usual processing of the event from taking place
     event.Skip();
@@ -1292,7 +1020,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
 
 #if wxUSE_MOUSEWHEEL
 
-void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event)
 {
     m_wheelRotation += event.GetWheelRotation();
     int lines = m_wheelRotation / event.GetWheelDelta();
@@ -1333,7 +1061,7 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
 
 #endif // wxUSE_MOUSEWHEEL
 
-void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
+void wxScrollHelperBase::HandleOnChildFocus(wxChildFocusEvent& event)
 {
     // this event should be processed by all windows in parenthood chain,
     // e.g. so that nested wxScrolledWindows work correctly
@@ -1474,12 +1202,301 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     Scroll(startx, starty);
 }
 
+
+#ifdef wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrollHelper implementation
+// ----------------------------------------------------------------------------
+
+wxScrollHelper::wxScrollHelper(wxWindow *winToScroll)
+    : wxScrollHelperBase(winToScroll)
+{
+    m_xVisibility =
+    m_yVisibility = wxSHOW_SB_DEFAULT;
+}
+
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
+                                      wxScrollbarVisibility vert)
+{
+    if ( horz != m_xVisibility || vert != m_yVisibility )
+    {
+        m_xVisibility = horz;
+        m_yVisibility = vert;
+
+        AdjustScrollbars();
+    }
+}
+
+void
+wxScrollHelper::DoAdjustScrollbar(int orient,
+                                  int clientSize,
+                                  int virtSize,
+                                  int& pixelsPerUnit,
+                                  int& scrollUnits,
+                                  int& scrollPosition,
+                                  wxScrollbarVisibility visibility)
+{
+    if ( visibility == wxSHOW_SB_NEVER )
+    {
+        m_win->SetScrollbar(orient, 0, 0, 0);
+        return;
+    }
+
+    // scroll lines per page: if 0, no scrolling is needed
+    int unitsPerPage;
+
+    // check if we need scrollbar in this direction at all
+    if ( pixelsPerUnit == 0 ||
+            (clientSize >= virtSize && visibility != wxSHOW_SB_ALWAYS) )
+    {
+        // scrolling is disabled or unnecessary
+        scrollUnits =
+        scrollPosition = 0;
+        unitsPerPage = 0;
+    }
+    else // might need scrolling
+    {
+        // Round up integer division to catch any "leftover" client space.
+        scrollUnits = (virtSize + pixelsPerUnit - 1) / pixelsPerUnit;
+
+        // Calculate the number of fully scroll units
+        unitsPerPage = clientSize / pixelsPerUnit;
+
+        if (unitsPerPage >= scrollUnits)
+        {
+            // we're big enough to not need scrolling
+            scrollUnits =
+            scrollPosition = 0;
+            unitsPerPage = 0;
+        }
+        else // we do need a scrollbar
+        {
+            if ( unitsPerPage < 1 )
+                unitsPerPage = 1;
+
+            // Correct position if greater than extent of canvas minus
+            // the visible portion of it or if below zero
+            const int posMax = scrollUnits - unitsPerPage;
+            if ( scrollPosition > posMax )
+                scrollPosition = posMax;
+            else if ( scrollPosition < 0 )
+                scrollPosition = 0;
+        }
+    }
+
+    m_win->SetScrollbar(orient, scrollPosition, unitsPerPage, scrollUnits);
+
+    // The amount by which we scroll when paging
+    SetScrollPageSize(orient, unitsPerPage);
+}
+
+void wxScrollHelper::AdjustScrollbars()
+{
+    static wxRecursionGuardFlag s_flagReentrancy;
+    wxRecursionGuard guard(s_flagReentrancy);
+    if ( guard.IsInside() )
+    {
+        // don't reenter AdjustScrollbars() while another call to
+        // AdjustScrollbars() is in progress because this may lead to calling
+        // ScrollWindow() twice and this can really happen under MSW if
+        // SetScrollbar() call below adds or removes the scrollbar which
+        // changes the window size and hence results in another
+        // AdjustScrollbars() call
+        return;
+    }
+
+    int oldXScroll = m_xScrollPosition;
+    int oldYScroll = m_yScrollPosition;
+
+    // we may need to readjust the scrollbars several times as enabling one of
+    // them reduces the area available for the window contents and so can make
+    // the other scrollbar necessary now although it wasn't necessary before
+    //
+    // VZ: normally this loop should be over in at most 2 iterations, I don't
+    //     know why do we need 5 of them
+    for ( int iterationCount = 0; iterationCount < 5; iterationCount++ )
+    {
+        wxSize clientSize = GetTargetSize();
+        const wxSize virtSize = m_targetWindow->GetVirtualSize();
+
+        // this block of code tries to work around the following problem: the
+        // window could have been just resized to have enough space to show its
+        // full contents without the scrollbars, but its client size could be
+        // not big enough because it does have the scrollbars right now and so
+        // the scrollbars would remain even though we don't need them any more
+        //
+        // to prevent this from happening, check if we have enough space for
+        // everything without the scrollbars and explicitly disable them then
+        const wxSize availSize = GetSizeAvailableForScrollTarget(
+            m_win->GetSize() - m_win->GetWindowBorderSize());
+        if ( availSize != clientSize )
+        {
+            if ( availSize.x >= virtSize.x && availSize.y >= virtSize.y )
+            {
+                // this will be enough to make the scrollbars disappear below
+                // and then the client size will indeed become equal to the
+                // full available size
+                clientSize = availSize;
+            }
+        }
+
+
+        DoAdjustScrollbar(wxHORIZONTAL,
+                          clientSize.x,
+                          virtSize.x,
+                          m_xScrollPixelsPerLine,
+                          m_xScrollLines,
+                          m_xScrollPosition,
+                          m_xVisibility);
+
+        DoAdjustScrollbar(wxVERTICAL,
+                          clientSize.y,
+                          virtSize.y,
+                          m_yScrollPixelsPerLine,
+                          m_yScrollLines,
+                          m_yScrollPosition,
+                          m_yVisibility);
+
+
+        // If a scrollbar (dis)appeared as a result of this, we need to adjust
+        // them again but if the client size didn't change, then we're done
+        if ( GetTargetSize() == clientSize )
+            break;
+    }
+
+#ifdef __WXMOTIF__
+    // Sorry, some Motif-specific code to implement a backing pixmap
+    // for the wxRETAINED style. Implementing a backing store can't
+    // be entirely generic because it relies on the wxWindowDC implementation
+    // to duplicate X drawing calls for the backing pixmap.
+
+    if ( m_targetWindow->GetWindowStyle() & wxRETAINED )
+    {
+        Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget());
+
+        int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
+        int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
+        if (m_targetWindow->GetBackingPixmap() &&
+           !((m_targetWindow->GetPixmapWidth() == totalPixelWidth) &&
+             (m_targetWindow->GetPixmapHeight() == totalPixelHeight)))
+        {
+            XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap());
+            m_targetWindow->SetBackingPixmap((WXPixmap) 0);
+        }
+
+        if (!m_targetWindow->GetBackingPixmap() &&
+           (m_xScrollLines != 0) && (m_yScrollLines != 0))
+        {
+            int depth = wxDisplayDepth();
+            m_targetWindow->SetPixmapWidth(totalPixelWidth);
+            m_targetWindow->SetPixmapHeight(totalPixelHeight);
+            m_targetWindow->SetBackingPixmap((WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
+              m_targetWindow->GetPixmapWidth(), m_targetWindow->GetPixmapHeight(), depth));
+        }
+
+    }
+#endif // Motif
+
+    if (oldXScroll != m_xScrollPosition)
+    {
+       if (m_xScrollingEnabled)
+            m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0,
+                                          GetScrollRect() );
+       else
+            m_targetWindow->Refresh(true, GetScrollRect());
+    }
+
+    if (oldYScroll != m_yScrollPosition)
+    {
+        if (m_yScrollingEnabled)
+            m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
+                                          GetScrollRect() );
+        else
+            m_targetWindow->Refresh(true, GetScrollRect());
+    }
+}
+
+void wxScrollHelper::DoScroll( int x_pos, int y_pos )
+{
+    if (!m_targetWindow)
+        return;
+
+    if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
+        ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
+
+    int w = 0, h = 0;
+    GetTargetSize(&w, &h);
+
+    // compute new position:
+    int new_x = m_xScrollPosition;
+    int new_y = m_yScrollPosition;
+
+    if ((x_pos != -1) && (m_xScrollPixelsPerLine))
+    {
+        new_x = x_pos;
+
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = w/m_xScrollPixelsPerLine;
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        new_x = wxMin( m_xScrollLines-noPagePositions, new_x );
+        new_x = wxMax( 0, new_x );
+    }
+    if ((y_pos != -1) && (m_yScrollPixelsPerLine))
+    {
+        new_y = y_pos;
+
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = h/m_yScrollPixelsPerLine;
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        new_y = wxMin( m_yScrollLines-noPagePositions, new_y );
+        new_y = wxMax( 0, new_y );
+    }
+
+    if ( new_x == m_xScrollPosition && new_y == m_yScrollPosition )
+        return; // nothing to do, the position didn't change
+
+    // flush all pending repaints before we change m_{x,y}ScrollPosition, as
+    // otherwise invalidated area could be updated incorrectly later when
+    // ScrollWindow() makes sure they're repainted before scrolling them
+    m_targetWindow->Update();
+
+    // update the position and scroll the window now:
+    if (m_xScrollPosition != new_x)
+    {
+        int old_x = m_xScrollPosition;
+        m_xScrollPosition = new_x;
+        m_win->SetScrollPos( wxHORIZONTAL, new_x );
+        m_targetWindow->ScrollWindow( (old_x-new_x)*m_xScrollPixelsPerLine, 0,
+                                      GetScrollRect() );
+    }
+
+    if (m_yScrollPosition != new_y)
+    {
+        int old_y = m_yScrollPosition;
+        m_yScrollPosition = new_y;
+        m_win->SetScrollPos( wxVERTICAL, new_y );
+        m_targetWindow->ScrollWindow( 0, (old_y-new_y)*m_yScrollPixelsPerLine,
+                                      GetScrollRect() );
+    }
+}
+
+#endif // wxHAS_GENERIC_SCROLLWIN
+
 // ----------------------------------------------------------------------------
 // wxScrolled<T> and wxScrolledWindow implementation
 // ----------------------------------------------------------------------------
 
 wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
-                                          const wxScrollHelperNative *helper,
+                                          const wxScrollHelper *helper,
                                           const wxSize& origBest)
 {
     // NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not

src/gtk/scrolwin.cpp

@@ -36,7 +36,7 @@
 // wxScrollHelper implementation
 // ----------------------------------------------------------------------------
 
-void wxScrollHelperNative::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
+void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
                                    int noUnitsX, int noUnitsY,
                                    int xPos, int yPos,
                                    bool noRefresh)
@@ -81,7 +81,7 @@ void wxScrollHelperNative::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
     }
 }
 
-void wxScrollHelperNative::DoAdjustScrollbar(GtkRange* range,
+void wxScrollHelper::DoAdjustScrollbar(GtkRange* range,
                                        int pixelsPerLine,
                                        int winSize,
                                        int virtSize,
@@ -119,7 +119,7 @@ void wxScrollHelperNative::DoAdjustScrollbar(GtkRange* range,
         *pos = *lines;
 }
 
-void wxScrollHelperNative::AdjustScrollbars()
+void wxScrollHelper::AdjustScrollbars()
 {
     int vw, vh;
     m_targetWindow->GetVirtualSize(&vw, &vh);
@@ -163,7 +163,7 @@ void wxScrollHelperNative::AdjustScrollbars()
     }
 }
 
-void wxScrollHelperNative::DoScrollOneDir(int orient,
+void wxScrollHelper::DoScrollOneDir(int orient,
                                     int pos,
                                     int pixelsPerLine,
                                     int *posOld)
@@ -181,7 +181,7 @@ void wxScrollHelperNative::DoScrollOneDir(int orient,
     }
 }
 
-void wxScrollHelperNative::DoScroll( int x_pos, int y_pos )
+void wxScrollHelper::DoScroll( int x_pos, int y_pos )
 {
     wxCHECK_RET( m_targetWindow != 0, _T("No target window") );
 
@@ -219,7 +219,7 @@ GtkPolicyType GtkPolicyFromWX(wxScrollbarVisibility visibility)
 
 } // anonymous namespace
 
-void wxScrollHelperNative::DoShowScrollbars(wxScrollbarVisibility horz,
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
                                       wxScrollbarVisibility vert)
 {
     GtkScrolledWindow * const scrolled = GTK_SCROLLED_WINDOW(m_win->m_widget);

src/gtk1/scrolwin.cpp

@@ -36,7 +36,7 @@
 // wxScrollHelper implementation
 // ----------------------------------------------------------------------------
 
-void wxScrollHelperNative::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
+void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
                                          int noUnitsX, int noUnitsY,
                                          int xPos, int yPos,
                                          bool noRefresh)
@@ -73,7 +73,7 @@ void wxScrollHelperNative::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
     m_targetWindow->m_hasScrolling = pixelsPerUnitX || pixelsPerUnitY;
 }
 
-void wxScrollHelperNative::DoAdjustScrollbar(GtkAdjustment *adj,
+void wxScrollHelper::DoAdjustScrollbar(GtkAdjustment *adj,
                                              int pixelsPerLine,
                                              int winSize,
                                              int virtSize,
@@ -127,7 +127,7 @@ void wxScrollHelperNative::DoAdjustScrollbar(GtkAdjustment *adj,
     gtk_signal_emit_by_name( GTK_OBJECT(adj), "changed" );
 }
 
-void wxScrollHelperNative::AdjustScrollbars()
+void wxScrollHelper::AdjustScrollbars()
 {
     int w, h;
     int vw, vh;
@@ -141,7 +141,7 @@ void wxScrollHelperNative::AdjustScrollbars()
                       &m_yScrollPosition, &m_yScrollLines, &m_yScrollLinesPerPage);
 }
 
-void wxScrollHelperNative::DoScroll(int orient,
+void wxScrollHelper::DoScrollOneDir(int orient,
                                     GtkAdjustment *adj,
                                     int pos,
                                     int pixelsPerLine,
@@ -169,13 +169,19 @@ void wxScrollHelperNative::DoScroll(int orient,
     }
 }
 
-void wxScrollHelperNative::Scroll( int x_pos, int y_pos )
+void wxScrollHelper::DoScroll( int x_pos, int y_pos )
 {
     wxCHECK_RET( m_targetWindow != 0, _T("No target window") );
 
-    DoScroll(wxHORIZONTAL, m_win->m_hAdjust, x_pos, m_xScrollPixelsPerLine,
+    DoScrollOneDir(wxHORIZONTAL, m_win->m_hAdjust, x_pos, m_xScrollPixelsPerLine,
                 &m_xScrollPosition);
-    DoScroll(wxVERTICAL, m_win->m_vAdjust, y_pos, m_yScrollPixelsPerLine,
+    DoScrollOneDir(wxVERTICAL, m_win->m_vAdjust, y_pos, m_yScrollPixelsPerLine,
                 &m_yScrollPosition);
 }
 
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility WXUNUSED(horz),
+                                      wxScrollbarVisibility WXUNUSED(vert))
+{
+    // TODO: not supported/implemented
+}
+