#pragma hdrstop
#endif
-#ifdef __VMS
-#define XtDisplay XTDISPLAY
-#endif
-
#include "wx/scrolwin.h"
#ifndef WX_PRECOMP
class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
{
public:
- wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)
+ wxScrollHelperEvtHandler(wxScrollHelperBase *scrollHelper)
{
m_scrollHelper = scrollHelper;
}
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
// user code defined OnPaint() in the derived class)
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()
}
}
- if ( processed )
- event.Skip(wasSkipped);
+ 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, _T("associated window can't be NULL in wxScrollHelper") );
+ wxASSERT_MSG( win, wxT("associated window can't be NULL in wxScrollHelper") );
m_xScrollPixelsPerLine =
m_yScrollPixelsPerLine =
m_xScrollingEnabled =
m_yScrollingEnabled = true;
+ m_kbdScrollingEnabled = true;
+
m_scaleX =
m_scaleY = 1.0;
#if wxUSE_MOUSEWHEEL
#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();
// 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;
// [target] window handling
// ----------------------------------------------------------------------------
-void wxScrollHelper::DeleteEvtHandler()
+void wxScrollHelperBase::DeleteEvtHandler()
{
// search for m_handler in the handler list
if ( m_win && m_handler )
}
}
-void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::ResetDrawnFlag()
+{
+ wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" );
+ m_handler->ResetDrawnFlag();
+}
+
+void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target)
{
m_targetWindow = target;
#ifdef __WXMAC__
}
}
-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 )
}
}
-int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
+int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event)
{
int pos = event.GetPosition();
int orient = event.GetOrientation();
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;
- }
-
- 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
- // JACS: Stop potential infinite loop by limiting number of iterations
- int iterationCount = 0;
- const int iterationMax = 5;
- do
- {
- iterationCount ++;
-
- GetTargetSize(&w, 0);
-
- // scroll lines per page: if 0, no scrolling is needed
- int linesPerPage;
-
- if ( m_xScrollPixelsPerLine == 0 )
- {
- // scrolling is disabled
- m_xScrollLines = 0;
- m_xScrollPosition = 0;
- linesPerPage = 0;
- }
- else // might need scrolling
- {
- // Round up integer division to catch any "leftover" client space.
- const int wVirt = m_targetWindow->GetVirtualSize().GetWidth();
- m_xScrollLines = (wVirt + m_xScrollPixelsPerLine - 1) / m_xScrollPixelsPerLine;
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window.
- linesPerPage = w / m_xScrollPixelsPerLine;
-
- // Special case. When client and virtual size are very close but
- // the client is big enough, kill scrollbar.
- if ((linesPerPage < m_xScrollLines) && (w >= wVirt)) ++linesPerPage;
-
- if (linesPerPage >= m_xScrollLines)
- {
- // we're big enough to not need scrolling
- linesPerPage =
- m_xScrollLines =
- m_xScrollPosition = 0;
- }
- else // we do need a scrollbar
- {
- 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_xScrollLines - linesPerPage;
- if ( m_xScrollPosition > posMax )
- m_xScrollPosition = posMax;
- else if ( m_xScrollPosition < 0 )
- m_xScrollPosition = 0;
- }
- }
-
- m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition,
- linesPerPage, m_xScrollLines);
-
- // The amount by which we scroll when paging
- SetScrollPageSize(wxHORIZONTAL, linesPerPage);
-
- GetTargetSize(0, &h);
-
- if ( m_yScrollPixelsPerLine == 0 )
- {
- // scrolling is disabled
- m_yScrollLines = 0;
- m_yScrollPosition = 0;
- linesPerPage = 0;
- }
- else // might need scrolling
- {
- // Round up integer division to catch any "leftover" client space.
- const int hVirt = m_targetWindow->GetVirtualSize().GetHeight();
- m_yScrollLines = ( hVirt + m_yScrollPixelsPerLine - 1 ) / m_yScrollPixelsPerLine;
-
- // Calculate page size i.e. number of scroll units you get on the
- // current client window.
- linesPerPage = h / m_yScrollPixelsPerLine;
-
- // Special case. When client and virtual size are very close but
- // the client is big enough, kill scrollbar.
- if ((linesPerPage < m_yScrollLines) && (h >= hVirt)) ++linesPerPage;
-
- if (linesPerPage >= m_yScrollLines)
- {
- // we're big enough to not need scrolling
- linesPerPage =
- m_yScrollLines =
- m_yScrollPosition = 0;
- }
- else // we do need a scrollbar
- {
- 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;
- }
- }
-
- 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) && (iterationCount < iterationMax) );
-
-#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__
// It may actually be correct to always query
- // the m_sign from the DC here, but I leve the
+ // 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,
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;
}
-int wxScrollHelper::GetScrollLines( int orient ) const
+int wxScrollHelperBase::GetScrollLines( int orient ) const
{
if ( orient == wxHORIZONTAL )
return m_xScrollLines;
return m_yScrollLines;
}
-int wxScrollHelper::GetScrollPageSize(int orient) const
+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;
-
- 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;
}
// 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;
// geometry
// ----------------------------------------------------------------------------
-bool wxScrollHelper::ScrollLayout()
+bool wxScrollHelperBase::ScrollLayout()
{
if ( m_win->GetSizer() && m_targetWindow == m_win )
{
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();
// 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() )
// ----------------------------------------------------------------------------
// Default OnSize resets scrollbars, if any
-void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
+void wxScrollHelperBase::HandleOnSize(wxSizeEvent& WXUNUSED(event))
{
if ( m_targetWindow->GetAutoLayout() )
{
// 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 = 0, sty = 0, // view origin
- szx = 0, szy = 0, // view size (total)
- clix = 0, cliy = 0; // view size (on screen)
-
- GetViewStart(&stx, &sty);
- GetTargetSize(&clix, &cliy);
- m_targetWindow->GetVirtualSize(&szx, &szy);
-
- if( m_xScrollPixelsPerLine )
+ if ( !m_kbdScrollingEnabled )
{
- clix /= m_xScrollPixelsPerLine;
- szx /= m_xScrollPixelsPerLine;
- }
- else
- {
- clix = 0;
- szx = -1;
- }
- if( m_yScrollPixelsPerLine )
- {
- cliy /= m_yScrollPixelsPerLine;
- szy /= m_yScrollPixelsPerLine;
- }
- else
- {
- 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:
- dsty = sty - (5 * cliy / 6);
- Scroll(-1, (dsty == -1) ? 0 : dsty);
+ newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP);
break;
case WXK_PAGEDOWN:
- 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 evt(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition,
- wxHORIZONTAL);
- evt.SetEventObject(m_win);
- m_win->GetEventHandler()->ProcessEvent(evt);
- }
+ m_win->ProcessWindowEvent(newEvent);
- if ( m_yScrollPosition != yScrollOld )
+ if ( sendHorizontalToo )
{
- wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition,
- wxVERTICAL);
- evt.SetEventObject(m_win);
- m_win->GetEventHandler()->ProcessEvent(evt);
+ 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;
}
#if wxUSE_MOUSEWHEEL
-void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event)
{
m_wheelRotation += event.GetWheelRotation();
int lines = m_wheelRotation / event.GetWheelDelta();
#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
if ( win == m_targetWindow )
return; // nothing to do
- while ( win->GetParent() != m_targetWindow )
+#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;
+
+ 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)
{
- win = win->GetParent();
- if ( !win )
- return; // event is not from a child of the target window
+ 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;
}
- // if the child is not fully visible, try to scroll it into view:
+ // 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);
- // NB: we don't call CalcScrolledPosition() on win->GetPosition() here,
- // because children' positions are already scrolled
- wxRect winrect(win->GetPosition(), win->GetSize());
- wxSize view(m_targetWindow->GetClientSize());
-
int startx, starty;
GetViewStart(&startx, &starty);
{
int diff = 0;
- if ( winrect.GetTop() < 0 )
+ if ( winRect.GetTop() < 0 )
{
- diff = winrect.GetTop();
+ diff = winRect.GetTop();
}
- else if ( winrect.GetBottom() > view.y )
+ else if ( winRect.GetBottom() > viewRect.GetHeight() )
{
- diff = winrect.GetBottom() - view.y + 1;
+ 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;
{
int diff = 0;
- if ( winrect.GetLeft() < 0 )
+ if ( winRect.GetLeft() < 0 )
{
- diff = winrect.GetLeft();
+ diff = winRect.GetLeft();
}
- else if ( winrect.GetRight() > view.x )
+ else if ( winRect.GetRight() > viewRect.GetWidth() )
{
- diff = winrect.GetRight() - view.x + 1;
+ 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;
Scroll(startx, starty);
}
+
+#ifdef wxHAS_GENERIC_SCROLLWIN
+
// ----------------------------------------------------------------------------
-// wxScrolledWindow implementation
+// wxScrollHelper implementation
// ----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
+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;
-BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel)
- EVT_PAINT(wxScrolledWindow::OnPaint)
-END_EVENT_TABLE()
+ AdjustScrollbars();
+ }
+}
-bool wxScrolledWindow::Create(wxWindow *parent,
- wxWindowID id,
- const wxPoint& pos,
- const wxSize& size,
- long style,
- const wxString& name)
+void
+wxScrollHelper::DoAdjustScrollbar(int orient,
+ int clientSize,
+ int virtSize,
+ int pixelsPerUnit,
+ int& scrollUnits,
+ int& scrollPosition,
+ int& scrollLinesPerPage,
+ wxScrollbarVisibility visibility)
{
- m_targetWindow = this;
-#ifdef __WXMAC__
- MacSetClipChildren( true ) ;
-#endif
+ // 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;
- // by default, we're scrollable in both directions (but if one of the
- // styles is specified explicitly, we shouldn't add the other one
- // automatically)
- if ( !(style & (wxHSCROLL | wxVSCROLL)) )
- style |= wxHSCROLL | wxVSCROLL;
+ default:
+ wxFAIL_MSG( wxS("unknown scrollbar visibility") );
+ // fall through
+
+ case wxSHOW_SB_DEFAULT:
+ range = scrollUnits;
+ break;
- bool ok = wxPanel::Create(parent, id, pos, size, style, name);
+ }
- return ok;
+ m_win->SetScrollbar(orient, scrollPosition, scrollLinesPerPage, range);
}
-wxScrolledWindow::~wxScrolledWindow()
+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_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;
+ }
+
+#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 wxScrolledWindow::OnPaint(wxPaintEvent& event)
+void wxScrollHelper::DoScroll( int x_pos, int y_pos )
{
- // 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();
+ if (!m_targetWindow)
+ return;
- event.Skip();
+ 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() );
+ }
}
-wxSize wxScrolledWindow::DoGetBestSize() const
+#endif // wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrolled<T> and wxScrolledWindow implementation
+// ----------------------------------------------------------------------------
+
+wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
+ const wxScrollHelper *helper,
+ const wxSize& origBest)
{
// NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not
// all scrollable windows should behave like this, only those that
// (i.e., wxScrolledWindow) and other some scrollable windows may
// have different DoGetBestSize() implementation (e.g. wxTreeCtrl).
- wxSize best = wxPanel::DoGetBestSize();
+ wxSize best = origBest;
- if ( GetAutoLayout() )
+ 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;
- GetScrollPixelsPerUnit(&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
//
// See also http://svn.wxwidgets.org/viewvc/wx?view=rev&revision=45864
- wxSize minSize = GetMinSize();
+ wxSize minSize = win->GetMinSize();
if ( ppuX > 0 )
best.x = minSize.x + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
}
#ifdef __WXMSW__
-WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg,
- WXWPARAM wParam,
- WXLPARAM lParam)
+WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc)
{
- WXLRESULT 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__
+
+// 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