Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@57531 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2008-12-24 16:43:30 +00:00
parent 69e9752529
commit 29e1398fa0
7 changed files with 738 additions and 703 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
include/wx/generic/scrolwin.h
View File

@@ -1,11 +1,10 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/scrolwin.h
// Purpose: wxGenericScrolledWindow class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Purpose: generic wxScrollHelper
// Author: Vadim Zeitlin
// Created: 2008-12-24 (replacing old file with the same name)
// 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"
#include "wx/panel.h"
class WXDLLIMPEXP_CORE wxScrollHelper : public wxScrollHelperBase
{
public:
wxScrollHelper(wxWindow *winToScroll);
// ----------------------------------------------------------------------------
// wxGenericScrolledWindow
// ----------------------------------------------------------------------------
// implement base class pure virtuals
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_

6
include/wx/gtk/scrolwin.h
View File

@@ -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_

15
include/wx/gtk1/scrolwin.h
View File

@@ -16,20 +16,23 @@
// 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) { }
// 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_

59
include/wx/scrolwin.h
View File

@@ -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);
virtual ~wxScrollHelper();
wxScrollHelperBase(wxWindow *winToScroll);
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,
int *pixelsPerUnitY) const;
void GetScrollPixelsPerUnit(int *pixelsPerUnitX, 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;
virtual void DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const;
void DoCalcScrolledPosition(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);
virtual wxWindow *GetTargetWindow() const;
void SetTargetWindow(wxWindow *target);
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,
m_yVisibility;
DECLARE_NO_COPY_CLASS(wxScrollHelper)
DECLARE_NO_COPY_CLASS(wxScrollHelperBase)
};
// 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);
}

659
src/generic/scrlwing.cpp
View File

@@ -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
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)
void wxScrollHelperBase::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;
}
/*
* 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)
void wxScrollHelperBase::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

12
src/gtk/scrolwin.cpp
View File

@@ -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);

20
src/gtk1/scrolwin.cpp
View File

@@ -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
}