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; }
-
private:
- wxScrollHelper *m_scrollHelper;
-
- bool m_hasDrawnWindow;
+ wxScrollHelperBase *m_scrollHelper;
- 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)
{
// first scroll the window if we are allowed to do it
wxScrollWinEvent event1(m_eventType, m_pos, m_orient);
event1.SetEventObject(m_win);
+ event1.SetId(m_win->GetId());
if ( m_scrollHelper->SendAutoScrollEvents(event1) &&
m_win->GetEventHandler()->ProcessEvent(event1) )
{
// 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
event2.SetEventObject(m_win);
- // FIXME: we don't fill in the other members - ok?
+ wxMouseState mouseState = wxGetMouseState();
+
+ event2.m_leftDown = mouseState.LeftIsDown();
+ event2.m_middleDown = mouseState.MiddleIsDown();
+ event2.m_rightDown = mouseState.RightIsDown();
+
+ event2.m_shiftDown = mouseState.ShiftDown();
+ event2.m_controlDown = mouseState.ControlDown();
+ event2.m_altDown = mouseState.AltDown();
+ event2.m_metaDown = mouseState.MetaDown();
m_win->GetEventHandler()->ProcessEvent(event2);
}
{
wxEventType evType = event.GetEventType();
- // the explanation of wxEVT_PAINT processing hack: for historic reasons
- // there are 2 ways to process this event in classes deriving from
- // wxScrolledWindow. The user code may
- //
- // 1. override wxScrolledWindow::OnDraw(dc)
- // 2. define its own OnPaint() handler
- //
- // In addition, in wxUniversal wxWindow defines OnPaint() itself and
- // always processes the draw event, so we can't just try the window
- // OnPaint() first and call our HandleOnPaint() if it doesn't process it
- // (the latter would never be called in wxUniversal).
- //
- // So the solution is to have a flag telling us whether the user code drew
- // 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;
-
- // 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 ( evType == wxEVT_SIZE )
{
m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
-
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 || event.IsCommandEvent() )
- {
- return true;
- }
- }
+ if ( processed && event.IsCommandEvent())
+ return true;
- if ( evType == wxEVT_PAINT )
+ // For wxEVT_PAINT the user code can either handle this event as usual or
+ // override virtual OnDraw(), so if the event hasn't been handled we need
+ // to call this virtual function ourselves.
+ if (
+#ifndef __WXUNIVERSAL__
+ // in wxUniversal "processed" will always be true, because
+ // all windows use the paint event to draw themselves.
+ // In this case we can't use this flag to determine if a custom
+ // paint event handler already drew our window and we just
+ // call OnDraw() anyway.
+ !processed &&
+#endif // !__WXUNIVERSAL__
+ evType == wxEVT_PAINT )
{
m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
return true;
}
}
- 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;
+ // Convert positions expressed in scroll units to positions in pixels.
+ int xPosInPixels = (xPos + m_xScrollPosition)*m_xScrollPixelsPerLine,
+ yPosInPixels = (yPos + m_yScrollPosition)*m_yScrollPixelsPerLine;
- CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos);
bool do_refresh =
(
(noUnitsX != 0 && m_xScrollLines == 0) ||
- (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX * noUnitsX) ||
+ (noUnitsX < m_xScrollLines && xPosInPixels > pixelsPerUnitX * noUnitsX) ||
(noUnitsY != 0 && m_yScrollLines == 0) ||
- (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY * noUnitsY) ||
+ (noUnitsY < m_yScrollLines && yPosInPixels > pixelsPerUnitY * noUnitsY) ||
(xPos != m_xScrollPosition) ||
(yPos != m_yScrollPosition)
);
// [target] window handling
// ----------------------------------------------------------------------------
-void wxScrollHelper::DeleteEvtHandler()
+void wxScrollHelperBase::DeleteEvtHandler()
{
// search for m_handler in the handler list
if ( m_win && m_handler )
}
}
-void wxScrollHelper::ResetDrawnFlag()
-{
- wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" );
- m_handler->ResetDrawnFlag();
-}
-
-void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target)
{
m_targetWindow = target;
#ifdef __WXMAC__
}
}
-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;
}
-void
-wxScrollHelper::AdjustScrollbar(int orient,
- int clientSize,
- int virtSize,
- int& pixelsPerUnit,
- int& scrollUnits,
- int& scrollPosition)
-{
- // scroll lines per page: if 0, no scrolling is needed
- int unitsPerPage;
-
- // check if we need scrollbar in this direction at all
- if ( pixelsPerUnit == 0 || clientSize >= virtSize )
- {
- // scrolling is disabled or unnecessary
- scrollUnits =
- scrollPosition = 0;
- unitsPerPage = 0;
- }
- else // might need scrolling
- {
- // Round up integer division to catch any "leftover" client space.
- scrollUnits = (virtSize + pixelsPerUnit - 1) / pixelsPerUnit;
-
- // Calculate the number of fully scroll units
- unitsPerPage = clientSize / pixelsPerUnit;
-
- if (unitsPerPage >= scrollUnits)
- {
- // we're big enough to not need scrolling
- scrollUnits =
- scrollPosition = 0;
- unitsPerPage = 0;
- }
- else // we do need a scrollbar
- {
- if ( unitsPerPage < 1 )
- unitsPerPage = 1;
-
- // Correct position if greater than extent of canvas minus
- // the visible portion of it or if below zero
- const int posMax = scrollUnits - unitsPerPage;
- if ( scrollPosition > posMax )
- scrollPosition = posMax;
- else if ( scrollPosition < 0 )
- scrollPosition = 0;
- }
- }
-
- m_win->SetScrollbar(orient, scrollPosition, unitsPerPage, scrollUnits);
-
- // The amount by which we scroll when paging
- SetScrollPageSize(orient, unitsPerPage);
-}
-
-void wxScrollHelper::AdjustScrollbars()
-{
- static wxRecursionGuardFlag s_flagReentrancy;
- wxRecursionGuard guard(s_flagReentrancy);
- if ( guard.IsInside() )
- {
- // don't reenter AdjustScrollbars() while another call to
- // AdjustScrollbars() is in progress because this may lead to calling
- // ScrollWindow() twice and this can really happen under MSW if
- // SetScrollbar() call below adds or removes the scrollbar which
- // changes the window size and hence results in another
- // AdjustScrollbars() call
- return;
- }
-
- int oldXScroll = m_xScrollPosition;
- int oldYScroll = m_yScrollPosition;
-
- // we may need to readjust the scrollbars several times as enabling one of
- // them reduces the area available for the window contents and so can make
- // the other scrollbar necessary now although it wasn't necessary before
- //
- // VZ: normally this loop should be over in at most 2 iterations, I don't
- // know why do we need 5 of them
- for ( int iterationCount = 0; iterationCount < 5; iterationCount++ )
- {
- wxSize clientSize = GetTargetSize();
- const wxSize virtSize = m_targetWindow->GetVirtualSize();
-
- // this block of code tries to work around the following problem: the
- // window could have been just resized to have enough space to show its
- // full contents without the scrollbars, but its client size could be
- // not big enough because it does have the scrollbars right now and so
- // the scrollbars would remain even though we don't need them any more
- //
- // to prevent this from happening, check if we have enough space for
- // everything without the scrollbars and explicitly disable them then
- const wxSize availSize = GetSizeAvailableForScrollTarget(
- m_win->GetSize() - m_win->GetWindowBorderSize());
- if ( availSize != clientSize )
- {
- if ( availSize.x >= virtSize.x && availSize.y >= virtSize.y )
- {
- // this will be enough to make the scrollbars disappear below
- // and then the client size will indeed become equal to the
- // full available size
- clientSize = availSize;
- }
- }
-
-
- AdjustScrollbar(wxHORIZONTAL,
- clientSize.x,
- virtSize.x,
- m_xScrollPixelsPerLine,
- m_xScrollLines,
- m_xScrollPosition);
-
- AdjustScrollbar(wxVERTICAL,
- clientSize.y,
- virtSize.y,
- m_yScrollPixelsPerLine,
- m_yScrollLines,
- m_yScrollPosition);
-
-
- // If a scrollbar (dis)appeared as a result of this, we need to adjust
- // them again but if the client size didn't change, then we're done
- if ( GetTargetSize() == clientSize )
- break;
- }
-
-#ifdef __WXMOTIF__
- // Sorry, some Motif-specific code to implement a backing pixmap
- // for the wxRETAINED style. Implementing a backing store can't
- // be entirely generic because it relies on the wxWindowDC implementation
- // to duplicate X drawing calls for the backing pixmap.
-
- if ( m_targetWindow->GetWindowStyle() & wxRETAINED )
- {
- Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget());
-
- int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
- int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
- if (m_targetWindow->GetBackingPixmap() &&
- !((m_targetWindow->GetPixmapWidth() == totalPixelWidth) &&
- (m_targetWindow->GetPixmapHeight() == totalPixelHeight)))
- {
- XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap());
- m_targetWindow->SetBackingPixmap((WXPixmap) 0);
- }
-
- if (!m_targetWindow->GetBackingPixmap() &&
- (m_xScrollLines != 0) && (m_yScrollLines != 0))
- {
- int depth = wxDisplayDepth();
- m_targetWindow->SetPixmapWidth(totalPixelWidth);
- m_targetWindow->SetPixmapHeight(totalPixelHeight);
- m_targetWindow->SetBackingPixmap((WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
- m_targetWindow->GetPixmapWidth(), m_targetWindow->GetPixmapHeight(), depth));
- }
-
- }
-#endif // Motif
-
- if (oldXScroll != m_xScrollPosition)
- {
- if (m_xScrollingEnabled)
- m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0,
- GetScrollRect() );
- else
- m_targetWindow->Refresh(true, GetScrollRect());
- }
-
- if (oldYScroll != m_yScrollPosition)
- {
- if (m_yScrollingEnabled)
- m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
- GetScrollRect() );
- else
- m_targetWindow->Refresh(true, GetScrollRect());
- }
-}
-
-void wxScrollHelper::DoPrepareDC(wxDC& dc)
+void wxScrollHelperBase::DoPrepareDC(wxDC& dc)
{
wxPoint pt = dc.GetDeviceOrigin();
#ifdef __WXGTK__
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::DoScroll( int x_pos, int y_pos )
+void wxScrollHelperBase::EnableScrolling (bool x_scroll, bool y_scroll)
{
- if (!m_targetWindow)
- return;
+ m_xScrollingEnabled = x_scroll;
+ m_yScrollingEnabled = y_scroll;
+}
- if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
- ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
+// Where the current view starts from
+void wxScrollHelperBase::DoGetViewStart (int *x, int *y) const
+{
+ if ( x )
+ *x = m_xScrollPosition;
+ if ( y )
+ *y = m_yScrollPosition;
+}
- int w = 0, h = 0;
- GetTargetSize(&w, &h);
+void wxScrollHelperBase::DoCalcScrolledPosition(int x, int y,
+ int *xx, int *yy) const
+{
+ if ( xx )
+ *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
+ if ( yy )
+ *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
+}
- // compute new position:
- int new_x = m_xScrollPosition;
- int new_y = m_yScrollPosition;
+void wxScrollHelperBase::DoCalcUnscrolledPosition(int x, int y,
+ int *xx, int *yy) const
+{
+ if ( xx )
+ *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
+ if ( yy )
+ *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
+}
- if ((x_pos != -1) && (m_xScrollPixelsPerLine))
- {
- new_x = x_pos;
+// ----------------------------------------------------------------------------
+// geometry
+// ----------------------------------------------------------------------------
- // 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;
+bool wxScrollHelperBase::ScrollLayout()
+{
+ if ( m_win->GetSizer() && m_targetWindow == m_win )
+ {
+ // If we're the scroll target, take into account the
+ // virtual size and scrolled position of the window.
- // 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 );
+ 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;
}
- 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;
+ // fall back to default for LayoutConstraints
+ return m_win->wxWindow::Layout();
+}
- // 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 );
- }
+void wxScrollHelperBase::ScrollDoSetVirtualSize(int x, int y)
+{
+ m_win->wxWindow::DoSetVirtualSize( x, y );
+ AdjustScrollbars();
- if ( new_x == m_xScrollPosition && new_y == m_yScrollPosition )
- return; // nothing to do, the position didn't change
-
- // flush all pending repaints before we change m_{x,y}ScrollPosition, as
- // otherwise invalidated area could be updated incorrectly later when
- // ScrollWindow() makes sure they're repainted before scrolling them
- m_targetWindow->Update();
-
- // update the position and scroll the window now:
- if (m_xScrollPosition != new_x)
- {
- int old_x = m_xScrollPosition;
- m_xScrollPosition = new_x;
- m_win->SetScrollPos( wxHORIZONTAL, new_x );
- m_targetWindow->ScrollWindow( (old_x-new_x)*m_xScrollPixelsPerLine, 0,
- GetScrollRect() );
- }
-
- if (m_yScrollPosition != new_y)
- {
- int old_y = m_yScrollPosition;
- m_yScrollPosition = new_y;
- m_win->SetScrollPos( wxVERTICAL, new_y );
- m_targetWindow->ScrollWindow( 0, (old_y-new_y)*m_yScrollPixelsPerLine,
- GetScrollRect() );
- }
-}
-
-void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll)
-{
- m_xScrollingEnabled = x_scroll;
- m_yScrollingEnabled = y_scroll;
-}
-
-void wxScrollHelper::ShowScrollbars(wxScrollbarVisibility horz,
- wxScrollbarVisibility vert)
-{
- DoShowScrollbars(horz, vert);
-}
-
-void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
- wxScrollbarVisibility vert)
-{
- // TODO
-}
-
-// Where the current view starts from
-void wxScrollHelper::DoGetViewStart (int *x, int *y) const
-{
- if ( x )
- *x = m_xScrollPosition;
- if ( y )
- *y = m_yScrollPosition;
-}
-
-void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const
-{
- if ( xx )
- *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
- if ( yy )
- *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
-}
-
-void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
-{
- if ( xx )
- *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
- if ( yy )
- *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
-}
-
-// ----------------------------------------------------------------------------
-// geometry
-// ----------------------------------------------------------------------------
-
-bool wxScrollHelper::ScrollLayout()
-{
- if ( m_win->GetSizer() && m_targetWindow == m_win )
- {
- // If we're the scroll target, take into account the
- // virtual size and scrolled position of the window.
-
- 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 wxScrollHelper::ScrollDoSetVirtualSize(int x, int y)
-{
- m_win->wxWindow::DoSetVirtualSize( x, y );
- AdjustScrollbars();
-
- if (m_win->GetAutoLayout())
- m_win->Layout();
-}
+ if (m_win->GetAutoLayout())
+ m_win->Layout();
+}
// 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 )
- {
- 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);
+ newEvent.SetId(m_win->GetId());
+
+ // 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
-#ifdef __WXMAC__
+#if defined( __WXOSX__ ) && wxUSE_SCROLLBAR
if (wxDynamicCast(win, wxScrollBar))
return;
#endif
win->GetParent() == m_targetWindow)
// if win is a wxPanel and receives the focus, it should not be
// scrolled into view
- return;
+ return;
const wxRect viewRect(m_targetWindow->GetClientRect());
// 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
+ // wxScrolledWindows, the parent might be way too big to fit inside the
// scrolled window. If that is the case, then make only the focused window
// visible
if ( win->GetParent() != m_targetWindow)
if (parent_size.GetWidth() <= viewRect.GetWidth() &&
parent_size.GetHeight() <= viewRect.GetHeight())
// make the immediate parent visible instead of the focused control
- win=parent;
+ win=parent;
}
// make win position relative to the m_targetWindow viewing area instead of
Scroll(startx, starty);
}
+
+#ifdef wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrollHelper implementation
+// ----------------------------------------------------------------------------
+
+wxScrollHelper::wxScrollHelper(wxWindow *winToScroll)
+ : wxScrollHelperBase(winToScroll)
+{
+ m_xVisibility =
+ m_yVisibility = wxSHOW_SB_DEFAULT;
+}
+
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
+ wxScrollbarVisibility vert)
+{
+ if ( horz != m_xVisibility || vert != m_yVisibility )
+ {
+ m_xVisibility = horz;
+ m_yVisibility = vert;
+
+ AdjustScrollbars();
+ }
+}
+
+void
+wxScrollHelper::DoAdjustScrollbar(int orient,
+ int clientSize,
+ int virtSize,
+ int pixelsPerUnit,
+ int& scrollUnits,
+ int& scrollPosition,
+ 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);
+}
+
+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 wxScrollHelper::DoScroll( int x_pos, int y_pos )
+{
+ if (!m_targetWindow)
+ return;
+
+ if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
+ ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
+
+ int w = 0, h = 0;
+ GetTargetSize(&w, &h);
+
+ // compute new position:
+ int new_x = m_xScrollPosition;
+ int new_y = m_yScrollPosition;
+
+ if ((x_pos != -1) && (m_xScrollPixelsPerLine))
+ {
+ new_x = x_pos;
+
+ // Calculate page size i.e. number of scroll units you get on the
+ // current client window
+ int noPagePositions = w/m_xScrollPixelsPerLine;
+ if (noPagePositions < 1) noPagePositions = 1;
+
+ // Correct position if greater than extent of canvas minus
+ // the visible portion of it or if below zero
+ new_x = wxMin( m_xScrollLines-noPagePositions, new_x );
+ new_x = wxMax( 0, new_x );
+ }
+ if ((y_pos != -1) && (m_yScrollPixelsPerLine))
+ {
+ new_y = y_pos;
+
+ // Calculate page size i.e. number of scroll units you get on the
+ // current client window
+ int noPagePositions = h/m_yScrollPixelsPerLine;
+ if (noPagePositions < 1) noPagePositions = 1;
+
+ // Correct position if greater than extent of canvas minus
+ // the visible portion of it or if below zero
+ new_y = wxMin( m_yScrollLines-noPagePositions, new_y );
+ new_y = wxMax( 0, new_y );
+ }
+
+ if ( new_x == m_xScrollPosition && new_y == m_yScrollPosition )
+ return; // nothing to do, the position didn't change
+
+ // flush all pending repaints before we change m_{x,y}ScrollPosition, as
+ // otherwise invalidated area could be updated incorrectly later when
+ // ScrollWindow() makes sure they're repainted before scrolling them
+ m_targetWindow->Update();
+
+ // update the position and scroll the window now:
+ if (m_xScrollPosition != new_x)
+ {
+ int old_x = m_xScrollPosition;
+ m_xScrollPosition = new_x;
+ m_win->SetScrollPos( wxHORIZONTAL, new_x );
+ m_targetWindow->ScrollWindow( (old_x-new_x)*m_xScrollPixelsPerLine, 0,
+ GetScrollRect() );
+ }
+
+ if (m_yScrollPosition != new_y)
+ {
+ int old_y = m_yScrollPosition;
+ m_yScrollPosition = new_y;
+ m_win->SetScrollPos( wxVERTICAL, new_y );
+ m_targetWindow->ScrollWindow( 0, (old_y-new_y)*m_yScrollPixelsPerLine,
+ GetScrollRect() );
+ }
+}
+
+#endif // wxHAS_GENERIC_SCROLLWIN
+
// ----------------------------------------------------------------------------
// wxScrolled<T> and wxScrolledWindow implementation
// ----------------------------------------------------------------------------
wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
- const wxScrollHelperNative *helper,
+ const wxScrollHelper *helper,
const wxSize& origBest)
{
// NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not
projects / wxWidgets.git / blobdiff