/////////////////////////////////////////////////////////////////////////////
-// Name: generic/scrolwin.cpp
-// Purpose: wxGenericScrolledWindow implementation
+// Name: src/generic/scrlwing.cpp
+// Purpose: wxScrolledWindow implementation
// Author: Julian Smart
// Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement.
// Ron Lee on 10.4.02: virtual size / auto scrollbars et al.
// Created: 01/02/97
// RCS-ID: $Id$
-// Copyright: (c) wxWindows team
+// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "genscrolwin.h"
-#endif
-
-#ifdef __VMS
-#define XtDisplay XTDISPLAY
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#pragma hdrstop
#endif
-#if !defined(__WXGTK__) || defined(__WXUNIVERSAL__)
+#include "wx/scrolwin.h"
-#include "wx/utils.h"
-#include "wx/dcclient.h"
+#ifndef WX_PRECOMP
+ #include "wx/utils.h"
+ #include "wx/panel.h"
+ #include "wx/dcclient.h"
+ #include "wx/timer.h"
+ #include "wx/sizer.h"
+ #include "wx/settings.h"
+#endif
-#include "wx/scrolwin.h"
-#include "wx/panel.h"
-#if wxUSE_TIMER
-#include "wx/timer.h"
+#ifdef __WXMAC__
+#include "wx/scrolbar.h"
#endif
-#include "wx/sizer.h"
+
#include "wx/recguard.h"
#ifdef __WXMSW__
#include <windows.h> // for DLGC_WANTARROWS
+ #include "wx/msw/winundef.h"
#endif
#ifdef __WXMOTIF__
#endif
#endif
-IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
-
/*
- TODO PROPERTIES
- style wxHSCROLL | wxVSCROLL
+ TODO PROPERTIES
+ style wxHSCROLL | wxVSCROLL
*/
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
{
public:
- wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)
+ wxScrollHelperEvtHandler(wxScrollHelperBase *scrollHelper)
{
m_scrollHelper = scrollHelper;
}
virtual bool ProcessEvent(wxEvent& event);
- void ResetDrawnFlag() { m_hasDrawnWindow = FALSE; }
+ void ResetDrawnFlag() { m_hasDrawnWindow = false; }
private:
- wxScrollHelper *m_scrollHelper;
+ wxScrollHelperBase *m_scrollHelper;
bool m_hasDrawnWindow;
- DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler)
+ wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler);
};
#if wxUSE_TIMER
class wxAutoScrollTimer : public wxTimer
{
public:
- wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll,
+ wxAutoScrollTimer(wxWindow *winToScroll,
+ wxScrollHelperBase *scroll,
wxEventType eventTypeToSend,
int pos, int orient);
private:
wxWindow *m_win;
- wxScrollHelper *m_scrollHelper;
+ wxScrollHelperBase *m_scrollHelper;
wxEventType m_eventType;
int m_pos,
m_orient;
- DECLARE_NO_COPY_CLASS(wxAutoScrollTimer)
+ wxDECLARE_NO_COPY_CLASS(wxAutoScrollTimer);
};
// ============================================================================
// ----------------------------------------------------------------------------
wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll,
- wxScrollHelper *scroll,
+ wxScrollHelperBase *scroll,
wxEventType eventTypeToSend,
int pos, int orient)
{
{
// and then send a pseudo mouse-move event to refresh the selection
wxMouseEvent event2(wxEVT_MOTION);
- wxGetMousePosition(&event2.m_x, &event2.m_y);
+ event2.SetPosition(wxGetMousePosition());
// the mouse event coordinates should be client, not screen as
// returned by wxGetMousePosition
// anything in the window. We set it to true here but reset it to false in
// wxScrolledWindow::OnPaint() handler (which wouldn't be called if the
// user code defined OnPaint() in the derived class)
- m_hasDrawnWindow = TRUE;
+ m_hasDrawnWindow = true;
- // pass it on to the real handler
- bool processed = wxEvtHandler::ProcessEvent(event);
+ // Pass it on to the real handler: notice that we must not call
+ // ProcessEvent() on this object itself as it wouldn't pass it to the next
+ // handler (i.e. the real window) if we're called from a previous handler
+ // (as indicated by "process here only" flag being set) and we do want to
+ // execute the handler defined in the window we're associated with right
+ // now, without waiting until TryAfter() is called from wxEvtHandler.
+ bool processed = m_nextHandler->ProcessEvent(event);
// always process the size events ourselves, even if the user code handles
// them as well, as we need to AdjustScrollbars()
{
m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
- return TRUE;
+ return true;
}
if ( processed )
// normally, nothing more to do here - except if it was a paint event
// which wasn't really processed, then we'll try to call our
// OnDraw() below (from HandleOnPaint)
- if ( m_hasDrawnWindow )
+ if ( m_hasDrawnWindow || event.IsCommandEvent() )
{
- return TRUE;
+ return true;
}
}
- // reset the skipped flag to FALSE as it might have been set to TRUE in
- // ProcessEvent() above
- event.Skip(FALSE);
-
if ( evType == wxEVT_PAINT )
{
m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
- return TRUE;
+ return true;
}
+ if ( evType == wxEVT_CHILD_FOCUS )
+ {
+ m_scrollHelper->HandleOnChildFocus((wxChildFocusEvent &)event);
+ return true;
+ }
+
+ // reset the skipped flag (which might have been set to true in
+ // ProcessEvent() above) to be able to test it below
+ bool wasSkipped = event.GetSkipped();
+ if ( wasSkipped )
+ event.Skip(false);
+
if ( evType == wxEVT_SCROLLWIN_TOP ||
evType == wxEVT_SCROLLWIN_BOTTOM ||
evType == wxEVT_SCROLLWIN_LINEUP ||
evType == wxEVT_SCROLLWIN_THUMBTRACK ||
evType == wxEVT_SCROLLWIN_THUMBRELEASE )
{
- m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event);
- return !event.GetSkipped();
+ m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event);
+ if ( !event.GetSkipped() )
+ {
+ // it makes sense to indicate that we processed the message as we
+ // did scroll the window (and also notice that wxAutoScrollTimer
+ // relies on our return value to stop scrolling when we are at top
+ // or bottom already)
+ processed = true;
+ wasSkipped = false;
+ }
}
if ( evType == wxEVT_ENTER_WINDOW )
m_scrollHelper->HandleOnMouseLeave((wxMouseEvent &)event);
}
#if wxUSE_MOUSEWHEEL
+ // Use GTK's own scroll wheel handling in GtkScrolledWindow
+#ifndef __WXGTK20__
else if ( evType == wxEVT_MOUSEWHEEL )
{
m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event);
+ return true;
}
+#endif
#endif // wxUSE_MOUSEWHEEL
else if ( evType == wxEVT_CHAR )
{
m_scrollHelper->HandleOnChar((wxKeyEvent &)event);
- return !event.GetSkipped();
+ if ( !event.GetSkipped() )
+ {
+ processed = true;
+ wasSkipped = false;
+ }
}
- return FALSE;
+ event.Skip(wasSkipped);
+
+ // We called ProcessEvent() on the next handler, meaning that we explicitly
+ // worked around the request to process the event in this handler only. As
+ // explained above, this is unfortunately really necessary but the trouble
+ // is that the event will continue to be post-processed by the previous
+ // handler resulting in duplicate calls to event handlers. Call the special
+ // function below to prevent this from happening, base class DoTryChain()
+ // will check for it and behave accordingly.
+ //
+ // And if we're not called from DoTryChain(), this won't do anything anyhow.
+ event.DidntHonourProcessOnlyIn();
+
+ return processed;
}
+// ============================================================================
+// wxScrollHelperBase implementation
+// ============================================================================
+
// ----------------------------------------------------------------------------
-// wxScrollHelper construction
+// wxScrollHelperBase construction
// ----------------------------------------------------------------------------
-wxScrollHelper::wxScrollHelper(wxWindow *win)
+wxScrollHelperBase::wxScrollHelperBase(wxWindow *win)
{
+ wxASSERT_MSG( win, wxT("associated window can't be NULL in wxScrollHelper") );
+
m_xScrollPixelsPerLine =
m_yScrollPixelsPerLine =
m_xScrollPosition =
m_yScrollLinesPerPage = 0;
m_xScrollingEnabled =
- m_yScrollingEnabled = TRUE;
+ m_yScrollingEnabled = true;
+
+ m_kbdScrollingEnabled = true;
m_scaleX =
m_scaleY = 1.0;
#endif
m_win =
- m_targetWindow = (wxWindow *)NULL;
+ m_targetWindow = NULL;
- m_timerAutoScroll = (wxTimer *)NULL;
+ m_timerAutoScroll = NULL;
m_handler = NULL;
- if ( win )
- SetWindow(win);
+ m_win = win;
+
+ m_win->SetScrollHelper(static_cast<wxScrollHelper *>(this));
+
+ // by default, the associated window is also the target window
+ DoSetTargetWindow(win);
}
-wxScrollHelper::~wxScrollHelper()
+wxScrollHelperBase::~wxScrollHelperBase()
{
StopAutoScrolling();
// setting scrolling parameters
// ----------------------------------------------------------------------------
-void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
- int pixelsPerUnitY,
- int noUnitsX,
- int noUnitsY,
- int xPos,
- int yPos,
- bool noRefresh)
+void wxScrollHelperBase::SetScrollbars(int pixelsPerUnitX,
+ int pixelsPerUnitY,
+ int noUnitsX,
+ int noUnitsY,
+ int xPos,
+ int yPos,
+ bool noRefresh)
{
int xpos, ypos;
// For better backward compatibility we set persisting limits
// here not just the size. It makes SetScrollbars 'sticky'
// emulating the old non-autoscroll behaviour.
-
- m_targetWindow->SetVirtualSizeHints( w, h );
+ // m_targetWindow->SetVirtualSizeHints( w, h );
// The above should arguably be deprecated, this however we still need.
- m_targetWindow->SetVirtualSize( w, h );
+ // take care not to set 0 virtual size, 0 means that we don't have any
+ // scrollbars and hence we should use the real size instead of the virtual
+ // one which is indicated by using wxDefaultCoord
+ m_targetWindow->SetVirtualSize( w ? w : wxDefaultCoord,
+ h ? h : wxDefaultCoord);
if (do_refresh && !noRefresh)
- m_targetWindow->Refresh(TRUE, GetScrollRect());
+ m_targetWindow->Refresh(true, GetScrollRect());
#ifndef __WXUNIVERSAL__
// If the target is not the same as the window with the scrollbars,
else
{
// otherwise this has been done by AdjustScrollbars, above
-#ifdef __WXMAC__
- m_targetWindow->Update() ;
-#endif
}
#endif // !__WXUNIVERSAL__
}
// [target] window handling
// ----------------------------------------------------------------------------
-void wxScrollHelper::DeleteEvtHandler()
+void wxScrollHelperBase::DeleteEvtHandler()
{
// search for m_handler in the handler list
if ( m_win && m_handler )
}
}
-void wxScrollHelper::SetWindow(wxWindow *win)
+void wxScrollHelperBase::ResetDrawnFlag()
{
- wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") );
-
- m_win = win;
-
- // by default, the associated window is also the target window
- DoSetTargetWindow(win);
+ 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__
+ target->MacSetClipChildren( true ) ;
+#endif
// install the event handler which will intercept the events we're
// interested in (but only do it for our real window, not the target window
}
}
-void wxScrollHelper::SetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::SetTargetWindow(wxWindow *target)
{
wxCHECK_RET( target, wxT("target window must not be NULL") );
DoSetTargetWindow(target);
}
-wxWindow *wxScrollHelper::GetTargetWindow() const
+wxWindow *wxScrollHelperBase::GetTargetWindow() const
{
return m_targetWindow;
}
// scrolling implementation itself
// ----------------------------------------------------------------------------
-void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
+void wxScrollHelperBase::HandleOnScroll(wxScrollWinEvent& event)
{
int nScrollInc = CalcScrollInc(event);
if ( nScrollInc == 0 )
return;
}
- int orient = event.GetOrientation();
- if (orient == wxHORIZONTAL)
- {
- m_xScrollPosition += nScrollInc;
- m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);
- }
- else
- {
- m_yScrollPosition += nScrollInc;
- m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition);
- }
-
- bool needsRefresh = FALSE;
+ bool needsRefresh = false;
int dx = 0,
dy = 0;
+ int orient = event.GetOrientation();
if (orient == wxHORIZONTAL)
{
if ( m_xScrollingEnabled )
}
else
{
- needsRefresh = TRUE;
+ needsRefresh = true;
}
}
else
}
else
{
- needsRefresh = TRUE;
+ needsRefresh = true;
}
}
+ if ( !needsRefresh )
+ {
+ // 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
+#ifdef __WXMAC__
+ // wxWindowMac is taking care of making sure the update area is correctly
+ // set up, while not forcing an immediate redraw
+#else
+ m_targetWindow->Update();
+#endif
+ }
+
+ if (orient == wxHORIZONTAL)
+ {
+ m_xScrollPosition += nScrollInc;
+ m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);
+ }
+ else
+ {
+ m_yScrollPosition += nScrollInc;
+ m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition);
+ }
+
if ( needsRefresh )
{
- m_targetWindow->Refresh(TRUE, GetScrollRect());
+ m_targetWindow->Refresh(true, GetScrollRect());
}
else
{
m_targetWindow->ScrollWindow(dx, dy, GetScrollRect());
}
-
-#ifdef __WXMAC__
- m_targetWindow->Update() ;
-#endif
}
-int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
+int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event)
{
int pos = event.GetPosition();
int orient = event.GetOrientation();
if (orient == wxHORIZONTAL)
{
- if (m_xScrollPixelsPerLine > 0)
+ if ( m_xScrollPosition + nScrollInc < 0 )
{
- int w, h;
- GetTargetSize(&w, &h);
-
- int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
- int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 );
- if (noPositions < 0)
- noPositions = 0;
-
- if ( (m_xScrollPosition + nScrollInc) < 0 )
- nScrollInc = -m_xScrollPosition; // As -ve as we can go
- else if ( (m_xScrollPosition + nScrollInc) > noPositions )
- nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
+ // As -ve as we can go
+ nScrollInc = -m_xScrollPosition;
}
- else
- m_targetWindow->Refresh(TRUE, GetScrollRect());
- }
- else
- {
- if ( m_yScrollPixelsPerLine > 0 )
+ else // check for the other bound
{
- if ( m_yScrollPosition + nScrollInc < 0 )
- {
- // As -ve as we can go
- nScrollInc = -m_yScrollPosition;
- }
- else // check for the other bound
+ const int posMax = m_xScrollLines - m_xScrollLinesPerPage;
+ if ( m_xScrollPosition + nScrollInc > posMax )
{
- const int posMax = m_yScrollLines - m_yScrollLinesPerPage;
- if ( m_yScrollPosition + nScrollInc > posMax )
- {
- // As +ve as we can go
- nScrollInc = posMax - m_yScrollPosition;
- }
+ // As +ve as we can go
+ nScrollInc = posMax - m_xScrollPosition;
}
}
- else
- {
- // VZ: why do we do this? (FIXME)
- m_targetWindow->Refresh(TRUE, GetScrollRect());
- }
- }
-
- return nScrollInc;
-}
-
-// Adjust the scrollbars - new version.
-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;
}
-
-#ifdef __WXMAC__
- m_targetWindow->Update();
-#endif
-
- int w = 0, h = 0;
- int oldw, oldh;
-
- int oldXScroll = m_xScrollPosition;
- int oldYScroll = m_yScrollPosition;
-
- // VZ: at least under Windows this loop is useless because when scrollbars
- // [dis]appear we get a WM_SIZE resulting in another call to
- // AdjustScrollbars() anyhow. As it doesn't seem to do any harm I leave
- // it here for now but it would be better to ensure that all ports
- // generate EVT_SIZE when scrollbars [dis]appear, emulating it if
- // necessary, and remove it later
- do
+ else // wxVERTICAL
{
- GetTargetSize(&w, 0);
-
- if (m_xScrollPixelsPerLine == 0)
- {
- m_xScrollLines = 0;
- m_xScrollPosition = 0;
- m_win->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
- }
- else
- {
- m_xScrollLines = m_targetWindow->GetVirtualSize().GetWidth() / m_xScrollPixelsPerLine;
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
- int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
- if (noPagePositions < 1) noPagePositions = 1;
- if ( noPagePositions > m_xScrollLines )
- noPagePositions = m_xScrollLines;
-
- // Correct position if greater than extent of canvas minus
- // the visible portion of it or if below zero
- m_xScrollPosition = wxMin( m_xScrollLines - noPagePositions, m_xScrollPosition);
- m_xScrollPosition = wxMax( 0, m_xScrollPosition );
-
- m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
- // The amount by which we scroll when paging
- SetScrollPageSize(wxHORIZONTAL, noPagePositions);
- }
-
- GetTargetSize(0, &h);
-
- // scroll lines per page: if 0, no scrolling is needed
- int linesPerPage;
-
- if ( m_yScrollPixelsPerLine == 0 )
+ if ( m_yScrollPosition + nScrollInc < 0 )
{
- // scrolling is disabled
- m_yScrollLines = 0;
- m_yScrollPosition = 0;
- linesPerPage = 0;
+ // As -ve as we can go
+ nScrollInc = -m_yScrollPosition;
}
- else // might need scrolling
+ else // check for the other bound
{
- int hVirt = m_targetWindow->GetVirtualSize().GetHeight();
- m_yScrollLines = hVirt / m_yScrollPixelsPerLine;
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
- linesPerPage = h / m_yScrollPixelsPerLine;
- if ( linesPerPage >= m_yScrollLines )
- {
- // we're big enough to not need scrolling
- linesPerPage =
- m_yScrollLines =
- m_yScrollPosition = 0;
- }
- else // we do need a scrollbar
+ const int posMax = m_yScrollLines - m_yScrollLinesPerPage;
+ if ( m_yScrollPosition + nScrollInc > posMax )
{
- if ( linesPerPage < 1 )
- linesPerPage = 1;
-
- // Correct position if greater than extent of canvas minus
- // the visible portion of it or if below zero
- const int posMax = m_yScrollLines - linesPerPage;
- if ( m_yScrollPosition > posMax )
- m_yScrollPosition = posMax;
- else if ( m_yScrollPosition < 0 )
- m_yScrollPosition = 0;
+ // As +ve as we can go
+ nScrollInc = posMax - m_yScrollPosition;
}
}
-
- m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition,
- linesPerPage, m_yScrollLines);
-
- // The amount by which we scroll when paging
- SetScrollPageSize(wxVERTICAL, linesPerPage);
-
-
- // If a scrollbar (dis)appeared as a result of this, adjust them again.
- oldw = w;
- oldh = h;
-
- GetTargetSize( &w, &h );
- } while ( w != oldw || h != oldh );
-
-#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());
- }
-
-#ifdef __WXMAC__
- m_targetWindow->Update();
-#endif
+ return nScrollInc;
}
-void wxScrollHelper::DoPrepareDC(wxDC& dc)
+void wxScrollHelperBase::DoPrepareDC(wxDC& dc)
{
wxPoint pt = dc.GetDeviceOrigin();
- dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine,
- pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );
+#ifdef __WXGTK__
+ // It may actually be correct to always query
+ // the m_sign from the DC here, but I leave the
+ // #ifdef GTK for now.
+ if (m_win->GetLayoutDirection() == wxLayout_RightToLeft)
+ dc.SetDeviceOrigin( pt.x + m_xScrollPosition * m_xScrollPixelsPerLine,
+ pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );
+ else
+#endif
+ dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine,
+ pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );
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;
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;
*y_unit = m_yScrollPixelsPerLine;
}
-int wxScrollHelper::GetScrollPageSize(int orient) const
+
+int wxScrollHelperBase::GetScrollLines( int orient ) const
+{
+ if ( orient == wxHORIZONTAL )
+ return m_xScrollLines;
+ else
+ return m_yScrollLines;
+}
+
+int wxScrollHelperBase::GetScrollPageSize(int orient) const
{
if ( orient == wxHORIZONTAL )
return m_xScrollLinesPerPage;
return m_yScrollLinesPerPage;
}
-void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
+void wxScrollHelperBase::SetScrollPageSize(int orient, int pageSize)
{
if ( orient == wxHORIZONTAL )
m_xScrollLinesPerPage = pageSize;
m_yScrollLinesPerPage = pageSize;
}
-/*
- * Scroll to given position (scroll position, not pixel position)
- */
-void wxScrollHelper::Scroll( 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;
-
-#ifdef __WXMAC__
- m_targetWindow->Update();
-#endif
-
- int w, h;
- GetTargetSize(&w, &h);
-
- if ((x_pos != -1) && (m_xScrollPixelsPerLine))
- {
- int old_x = m_xScrollPosition;
- m_xScrollPosition = x_pos;
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
- int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
- if (noPagePositions < 1) noPagePositions = 1;
-
- // Correct position if greater than extent of canvas minus
- // the visible portion of it or if below zero
- m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
- m_xScrollPosition = wxMax( 0, m_xScrollPosition );
-
- if (old_x != m_xScrollPosition) {
- m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition );
- m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0,
- GetScrollRect() );
- }
- }
- if ((y_pos != -1) && (m_yScrollPixelsPerLine))
- {
- int old_y = m_yScrollPosition;
- m_yScrollPosition = y_pos;
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
- int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
- if (noPagePositions < 1) noPagePositions = 1;
-
- // Correct position if greater than extent of canvas minus
- // the visible portion of it or if below zero
- m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
- m_yScrollPosition = wxMax( 0, m_yScrollPosition );
-
- if (old_y != m_yScrollPosition) {
- m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition );
- m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine,
- GetScrollRect() );
- }
- }
-
-#ifdef __WXMAC__
- m_targetWindow->Update();
-#endif
-
-}
-
-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;
}
// Where the current view starts from
-void wxScrollHelper::GetViewStart (int *x, int *y) const
+void wxScrollHelperBase::DoGetViewStart (int *x, int *y) const
{
if ( x )
*x = m_xScrollPosition;
*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;
*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;
}
// ----------------------------------------------------------------------------
-// event handlers
+// geometry
// ----------------------------------------------------------------------------
-// Default OnSize resets scrollbars, if any
-void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
+bool wxScrollHelperBase::ScrollLayout()
{
- if( m_win->GetAutoLayout() || m_targetWindow->GetAutoLayout() )
+ if ( m_win->GetSizer() && m_targetWindow == m_win )
{
- if ( m_targetWindow != m_win )
- m_targetWindow->FitInside();
-
- m_win->FitInside();
+ // If we're the scroll target, take into account the
+ // virtual size and scrolled position of the window.
- // FIXME: Something is really weird here... This should be
- // called by FitInside above (and apparently is), yet the
- // scrollsub sample will get the scrollbar wrong if resized
- // quickly. This masks the bug, but is surely not the right
- // answer at all.
- AdjustScrollbars();
+ int x = 0, y = 0, w = 0, h = 0;
+ CalcScrolledPosition(0,0, &x,&y);
+ m_win->GetVirtualSize(&w, &h);
+ m_win->GetSizer()->SetDimension(x, y, w, h);
+ return true;
+ }
+
+ // fall back to default for LayoutConstraints
+ return m_win->wxWindow::Layout();
+}
+
+void wxScrollHelperBase::ScrollDoSetVirtualSize(int x, int y)
+{
+ m_win->wxWindow::DoSetVirtualSize( x, y );
+ AdjustScrollbars();
+
+ if (m_win->GetAutoLayout())
+ m_win->Layout();
+}
+
+// wxWindow's GetBestVirtualSize returns the actual window size,
+// whereas we want to return the virtual size
+wxSize wxScrollHelperBase::ScrollGetBestVirtualSize() const
+{
+ wxSize clientSize(m_win->GetClientSize());
+ if ( m_win->GetSizer() )
+ clientSize.IncTo(m_win->GetSizer()->CalcMin());
+
+ return clientSize;
+}
+
+// ----------------------------------------------------------------------------
+// event handlers
+// ----------------------------------------------------------------------------
+
+// Default OnSize resets scrollbars, if any
+void wxScrollHelperBase::HandleOnSize(wxSizeEvent& WXUNUSED(event))
+{
+ if ( m_targetWindow->GetAutoLayout() )
+ {
+ wxSize size = m_targetWindow->GetBestVirtualSize();
+
+ // This will call ::Layout() and ::AdjustScrollbars()
+ m_win->SetVirtualSize( size );
+ }
+ else
+ {
+ AdjustScrollbars();
}
- else
- AdjustScrollbars();
}
// 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);
// 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, sty, // view origin
- szx, szy, // view size (total)
- clix, cliy; // view size (on screen)
-
- GetViewStart(&stx, &sty);
- GetTargetSize(&clix, &cliy);
- m_targetWindow->GetVirtualSize(&szx, &szy);
-
- if( m_xScrollPixelsPerLine )
- {
- clix /= m_xScrollPixelsPerLine;
- szx /= m_xScrollPixelsPerLine;
- }
- else
- {
- clix = 0;
- szx = -1;
- }
- if( m_yScrollPixelsPerLine )
- {
- cliy /= m_yScrollPixelsPerLine;
- szy /= m_yScrollPixelsPerLine;
- }
- else
+ if ( !m_kbdScrollingEnabled )
{
- cliy = 0;
- szy = -1;
+ event.Skip();
+ return;
}
- int xScrollOld = m_xScrollPosition,
- yScrollOld = m_yScrollPosition;
+ // prepare the event this key press maps to
+ wxScrollWinEvent newEvent;
+
+ newEvent.SetPosition(0);
+ newEvent.SetEventObject(m_win);
+
+ // this is the default, it's changed to wxHORIZONTAL below if needed
+ newEvent.SetOrientation(wxVERTICAL);
+
+ // some key events result in scrolling in both horizontal and vertical
+ // direction, e.g. Ctrl-{Home,End}, if this flag is true we should generate
+ // a second event in horizontal direction in addition to the primary one
+ bool sendHorizontalToo = false;
- int dsty;
switch ( event.GetKeyCode() )
{
case WXK_PAGEUP:
- case WXK_PRIOR:
- dsty = sty - (5 * cliy / 6);
- Scroll(-1, (dsty == -1) ? 0 : dsty);
+ newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP);
break;
case WXK_PAGEDOWN:
- case WXK_NEXT:
- Scroll(-1, sty + (5 * cliy / 6));
+ newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);
break;
case WXK_HOME:
- Scroll(0, event.ControlDown() ? 0 : -1);
- break;
+ newEvent.SetEventType(wxEVT_SCROLLWIN_TOP);
- case WXK_END:
- Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
+ sendHorizontalToo = event.ControlDown();
break;
- case WXK_UP:
- Scroll(-1, sty - 1);
- break;
+ case WXK_END:
+ newEvent.SetEventType(wxEVT_SCROLLWIN_BOTTOM);
- case WXK_DOWN:
- Scroll(-1, sty + 1);
+ sendHorizontalToo = event.ControlDown();
break;
case WXK_LEFT:
- Scroll(stx - 1, -1);
+ newEvent.SetOrientation(wxHORIZONTAL);
+ // fall through
+
+ case WXK_UP:
+ newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP);
break;
case WXK_RIGHT:
- Scroll(stx + 1, -1);
+ newEvent.SetOrientation(wxHORIZONTAL);
+ // fall through
+
+ case WXK_DOWN:
+ newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);
break;
default:
- // not for us
+ // not a scrolling key
event.Skip();
+ return;
}
- if ( m_xScrollPosition != xScrollOld )
- {
- wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition,
- wxHORIZONTAL);
- event.SetEventObject(m_win);
- m_win->GetEventHandler()->ProcessEvent(event);
- }
+ m_win->ProcessWindowEvent(newEvent);
- if ( m_yScrollPosition != yScrollOld )
+ if ( sendHorizontalToo )
{
- wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition,
- wxVERTICAL);
- event.SetEventObject(m_win);
- m_win->GetEventHandler()->ProcessEvent(event);
+ newEvent.SetOrientation(wxHORIZONTAL);
+ m_win->ProcessWindowEvent(newEvent);
}
}
// 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 )
- {
- delete m_timerAutoScroll;
- m_timerAutoScroll = (wxTimer *)NULL;
- }
+ wxDELETE(m_timerAutoScroll);
#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();
// but seems to happen sometimes under wxMSW - maybe it's a bug
// there but for now just ignore it
- //wxFAIL_MSG( _T("can't understand where has mouse gone") );
+ //wxFAIL_MSG( wxT("can't understand where has mouse gone") );
return;
}
orient
);
m_timerAutoScroll->Start(50); // FIXME: make configurable
+#else
+ wxUnusedVar(pos);
#endif
}
}
#if wxUSE_MOUSEWHEEL
-void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event)
{
m_wheelRotation += event.GetWheelRotation();
int lines = m_wheelRotation / event.GetWheelDelta();
wxScrollWinEvent newEvent;
newEvent.SetPosition(0);
- newEvent.SetOrientation(wxVERTICAL);
- newEvent.m_eventObject = m_win;
+ newEvent.SetOrientation( event.GetWheelAxis() == 0 ? wxVERTICAL : wxHORIZONTAL);
+ newEvent.SetEventObject(m_win);
if (event.IsPageScroll())
{
if (lines > 0)
- newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
+ newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP);
else
- newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
+ newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);
m_win->GetEventHandler()->ProcessEvent(newEvent);
}
{
lines *= event.GetLinesPerAction();
if (lines > 0)
- newEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
+ newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP);
else
- newEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
+ newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);
int times = abs(lines);
for (; times > 0; times--)
#endif // wxUSE_MOUSEWHEEL
-// ----------------------------------------------------------------------------
-// wxGenericScrolledWindow implementation
-// ----------------------------------------------------------------------------
+void wxScrollHelperBase::HandleOnChildFocus(wxChildFocusEvent& event)
+{
+ // this event should be processed by all windows in parenthood chain,
+ // e.g. so that nested wxScrolledWindows work correctly
+ event.Skip();
+
+ // find the immediate child under which the window receiving focus is:
+ wxWindow *win = event.GetWindow();
+
+ if ( win == m_targetWindow )
+ return; // nothing to do
+
+#if defined( __WXOSX__ ) && wxUSE_SCROLLBAR
+ if (wxDynamicCast(win, wxScrollBar))
+ return;
+#endif
+
+ // Fixing ticket: http://trac.wxwidgets.org/ticket/9563
+ // When a child inside a wxControlContainer receives a focus, the
+ // wxControlContainer generates an artificial wxChildFocusEvent for
+ // itself, telling its parent that 'it' received the focus. The effect is
+ // that this->HandleOnChildFocus is called twice, first with the
+ // artificial wxChildFocusEvent and then with the original event. We need
+ // to ignore the artificial event here or otherwise HandleOnChildFocus
+ // would first scroll the target window to make the entire
+ // wxControlContainer visible and immediately afterwards scroll the target
+ // window again to make the child widget visible. This leads to ugly
+ // flickering when using nested wxPanels/wxScrolledWindows.
+ //
+ // Ignore this event if 'win' is derived from wxControlContainer AND its
+ // parent is the m_targetWindow AND 'win' is not actually reciving the
+ // focus (win != FindFocus). TODO: This affects all wxControlContainer
+ // objects, but wxControlContainer is not part of the wxWidgets RTTI and
+ // so wxDynamicCast(win, wxControlContainer) does not compile. Find a way
+ // to determine if 'win' derives from wxControlContainer. Until then,
+ // testing if 'win' derives from wxPanel will probably get >90% of all
+ // cases.
+
+ wxWindow *actual_focus=wxWindow::FindFocus();
+ if (win != actual_focus &&
+ wxDynamicCast(win, wxPanel) != 0 &&
+ win->GetParent() == m_targetWindow)
+ // if win is a wxPanel and receives the focus, it should not be
+ // scrolled into view
+ return;
-IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
+ const wxRect viewRect(m_targetWindow->GetClientRect());
+
+ // For composite controls such as wxComboCtrl we should try to fit the
+ // entire control inside the visible area of the target window, not just
+ // the focused child of the control. Otherwise we'd make only the textctrl
+ // part of a wxComboCtrl visible and the button would still be outside the
+ // scrolled area. But do so only if the parent fits *entirely* inside the
+ // scrolled window. In other situations, such as nested wxPanel or
+ // wxScrolledWindows, the parent might be way to big to fit inside the
+ // scrolled window. If that is the case, then make only the focused window
+ // visible
+ if ( win->GetParent() != m_targetWindow)
+ {
+ wxWindow *parent=win->GetParent();
+ wxSize parent_size=parent->GetSize();
+ if (parent_size.GetWidth() <= viewRect.GetWidth() &&
+ parent_size.GetHeight() <= viewRect.GetHeight())
+ // make the immediate parent visible instead of the focused control
+ win=parent;
+ }
+
+ // make win position relative to the m_targetWindow viewing area instead of
+ // its parent
+ const wxRect
+ winRect(m_targetWindow->ScreenToClient(win->GetScreenPosition()),
+ win->GetSize());
+
+ // check if it's fully visible
+ if ( viewRect.Contains(winRect) )
+ {
+ // it is, nothing to do
+ return;
+ }
+
+ // check if we can make it fully visible: this is only possible if it's not
+ // larger than our view area
+ if ( winRect.GetWidth() > viewRect.GetWidth() ||
+ winRect.GetHeight() > viewRect.GetHeight() )
+ {
+ // we can't make it fit so avoid scrolling it at all, this is only
+ // going to be confusing and not helpful
+ return;
+ }
+
+
+ // do make the window fit inside the view area by scrolling to it
+ int stepx, stepy;
+ GetScrollPixelsPerUnit(&stepx, &stepy);
+
+ int startx, starty;
+ GetViewStart(&startx, &starty);
+
+ // first in vertical direction:
+ if ( stepy > 0 )
+ {
+ int diff = 0;
+
+ if ( winRect.GetTop() < 0 )
+ {
+ diff = winRect.GetTop();
+ }
+ else if ( winRect.GetBottom() > viewRect.GetHeight() )
+ {
+ diff = winRect.GetBottom() - viewRect.GetHeight() + 1;
+ // round up to next scroll step if we can't get exact position,
+ // so that the window is fully visible:
+ diff += stepy - 1;
+ }
+
+ starty = (starty * stepy + diff) / stepy;
+ }
+
+ // then horizontal:
+ if ( stepx > 0 )
+ {
+ int diff = 0;
+
+ if ( winRect.GetLeft() < 0 )
+ {
+ diff = winRect.GetLeft();
+ }
+ else if ( winRect.GetRight() > viewRect.GetWidth() )
+ {
+ diff = winRect.GetRight() - viewRect.GetWidth() + 1;
+ // round up to next scroll step if we can't get exact position,
+ // so that the window is fully visible:
+ diff += stepx - 1;
+ }
+
+ startx = (startx * stepx + diff) / stepx;
+ }
+
+ Scroll(startx, starty);
+}
-BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
- EVT_PAINT(wxGenericScrolledWindow::OnPaint)
-END_EVENT_TABLE()
-bool wxGenericScrolledWindow::Create(wxWindow *parent,
- wxWindowID id,
- const wxPoint& pos,
- const wxSize& size,
- long style,
- const wxString& name)
+#ifdef wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrollHelper implementation
+// ----------------------------------------------------------------------------
+
+wxScrollHelper::wxScrollHelper(wxWindow *winToScroll)
+ : wxScrollHelperBase(winToScroll)
{
- m_targetWindow = this;
+ m_xVisibility =
+ m_yVisibility = wxSHOW_SB_DEFAULT;
+}
- bool ok = wxPanel::Create(parent, id, pos, size, style, name);
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
+ wxScrollbarVisibility vert)
+{
+ if ( horz != m_xVisibility || vert != m_yVisibility )
+ {
+ m_xVisibility = horz;
+ m_yVisibility = vert;
- return ok;
+ AdjustScrollbars();
+ }
}
-wxGenericScrolledWindow::~wxGenericScrolledWindow()
+void
+wxScrollHelper::DoAdjustScrollbar(int orient,
+ int clientSize,
+ int virtSize,
+ int pixelsPerUnit,
+ int& scrollUnits,
+ int& scrollPosition,
+ int& scrollLinesPerPage,
+ wxScrollbarVisibility visibility)
{
+ // scroll lines per page: if 0, no scrolling is needed
+ // check if we need scrollbar in this direction at all
+ if ( pixelsPerUnit == 0 || clientSize >= virtSize )
+ {
+ // scrolling is disabled or unnecessary
+ scrollUnits =
+ scrollPosition = 0;
+ scrollLinesPerPage = 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
+ scrollLinesPerPage = clientSize / pixelsPerUnit;
+
+ if ( scrollLinesPerPage >= scrollUnits )
+ {
+ // we're big enough to not need scrolling
+ scrollUnits =
+ scrollPosition = 0;
+ scrollLinesPerPage = 0;
+ }
+ else // we do need a scrollbar
+ {
+ if ( scrollLinesPerPage < 1 )
+ scrollLinesPerPage = 1;
+
+ // Correct position if greater than extent of canvas minus
+ // the visible portion of it or if below zero
+ const int posMax = scrollUnits - scrollLinesPerPage;
+ if ( scrollPosition > posMax )
+ scrollPosition = posMax;
+ else if ( scrollPosition < 0 )
+ scrollPosition = 0;
+ }
+ }
+
+ // in wxSHOW_SB_NEVER case don't show the scrollbar even if it's needed, in
+ // wxSHOW_SB_ALWAYS case show the scrollbar even if it's not needed by
+ // passing a special range value to SetScrollbar()
+ int range;
+ switch ( visibility )
+ {
+ case wxSHOW_SB_NEVER:
+ range = 0;
+ break;
+
+ case wxSHOW_SB_ALWAYS:
+ range = scrollUnits ? scrollUnits : -1;
+ break;
+
+ default:
+ wxFAIL_MSG( wxS("unknown scrollbar visibility") );
+ // fall through
+
+ case wxSHOW_SB_DEFAULT:
+ range = scrollUnits;
+ break;
+
+ }
+
+ m_win->SetScrollbar(orient, scrollPosition, scrollLinesPerPage, range);
}
-bool wxGenericScrolledWindow::Layout()
+void wxScrollHelper::AdjustScrollbars()
{
- if (GetSizer() && m_targetWindow == this)
+ static wxRecursionGuardFlag s_flagReentrancy;
+ wxRecursionGuard guard(s_flagReentrancy);
+ if ( guard.IsInside() )
{
- // If we're the scroll target, take into account the
- // virtual size and scrolled position of the window.
+ // 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 x, y, w, h;
- CalcScrolledPosition(0,0, &x,&y);
- GetVirtualSize(&w, &h);
- GetSizer()->SetDimension(x, y, w, h);
- return TRUE;
+ 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_xScrollLinesPerPage,
+ m_xVisibility);
+
+ DoAdjustScrollbar(wxVERTICAL,
+ clientSize.y,
+ virtSize.y,
+ m_yScrollPixelsPerLine,
+ m_yScrollLines,
+ m_yScrollPosition,
+ m_yScrollLinesPerPage,
+ 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;
}
- // fall back to default for LayoutConstraints
- return wxPanel::Layout();
+#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 wxGenericScrolledWindow::DoSetVirtualSize(int x, int y)
+void wxScrollHelper::DoScroll( int x_pos, int y_pos )
{
- wxPanel::DoSetVirtualSize( x, y );
- AdjustScrollbars();
+ if (!m_targetWindow)
+ return;
-#if wxUSE_CONSTRAINTS
- if (GetAutoLayout())
- Layout();
-#endif
+ 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 wxGenericScrolledWindow::OnPaint(wxPaintEvent& event)
+#endif // wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrolled<T> and wxScrolledWindow implementation
+// ----------------------------------------------------------------------------
+
+wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
+ const wxScrollHelper *helper,
+ const wxSize& origBest)
{
- // the user code didn't really draw the window if we got here, so set this
- // flag to try to call OnDraw() later
- m_handler->ResetDrawnFlag();
+ // NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not
+ // all scrollable windows should behave like this, only those that
+ // contain children controls within scrollable area
+ // (i.e., wxScrolledWindow) and other some scrollable windows may
+ // have different DoGetBestSize() implementation (e.g. wxTreeCtrl).
- event.Skip();
+ wxSize best = origBest;
+
+ if ( win->GetAutoLayout() )
+ {
+ // Only use the content to set the window size in the direction
+ // where there's no scrolling; otherwise we're going to get a huge
+ // window in the direction in which scrolling is enabled
+ int ppuX, ppuY;
+ helper->GetScrollPixelsPerUnit(&ppuX, &ppuY);
+
+ // NB: This code used to use *current* size if min size wasn't
+ // specified, presumably to get some reasonable (i.e., larger than
+ // minimal) size. But that's a wrong thing to do in GetBestSize(),
+ // so we use minimal size as specified. If the app needs some
+ // minimal size for its scrolled window, it should set it and put
+ // the window into sizer as expandable so that it can use all space
+ // available to it.
+ //
+ // See also http://svn.wxwidgets.org/viewvc/wx?view=rev&revision=45864
+
+ wxSize minSize = win->GetMinSize();
+
+ if ( ppuX > 0 )
+ best.x = minSize.x + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
+
+ if ( ppuY > 0 )
+ best.y = minSize.y + wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y);
+ }
+
+ return best;
}
#ifdef __WXMSW__
-long
-wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg,
- WXWPARAM wParam,
- WXLPARAM lParam)
+WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc)
{
- long rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
-
#ifndef __WXWINCE__
// we need to process arrows ourselves for scrolling
if ( nMsg == WM_GETDLGCODE )
rc |= DLGC_WANTARROWS;
}
#endif
-
return rc;
}
-
#endif // __WXMSW__
-#endif // !wxGTK
-
-// vi:sts=4:sw=4:et
+// NB: skipping wxScrolled<T> in wxRTTI information because being a templte,
+// it doesn't and can't implement wxRTTI support
+IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
projects / wxWidgets.git / blobdiff