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
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 =
#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::ResetDrawnFlag()
+void wxScrollHelperBase::ResetDrawnFlag()
{
wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" );
m_handler->ResetDrawnFlag();
}
-void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target)
{
m_targetWindow = target;
#ifdef __WXMAC__
}
}
-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::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)
+ // prepare the event this key press maps to
+ wxScrollWinEvent newEvent;
- GetViewStart(&stx, &sty);
- GetTargetSize(&clix, &cliy);
- m_targetWindow->GetVirtualSize(&szx, &szy);
+ newEvent.SetPosition(0);
+ newEvent.SetEventObject(m_win);
- if( m_xScrollPixelsPerLine )
- {
- 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;
- }
+ // this is the default, it's changed to wxHORIZONTAL below if needed
+ newEvent.SetOrientation(wxVERTICAL);
- int xScrollOld = m_xScrollPosition,
- yScrollOld = m_yScrollPosition;
+ // 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;
+ m_timerAutoScroll = NULL;
}
#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;
- wxSize view(m_targetWindow->GetClientSize());
+ 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
{
wxWindow *parent=win->GetParent();
wxSize parent_size=parent->GetSize();
- if (parent_size.GetWidth() <= view.GetWidth() &&
- parent_size.GetHeight() <= view.GetHeight())
+ 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
+ // 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;
}
- // if the child is not fully visible, try to scroll it into view:
+
+ // do make the window fit inside the view area by scrolling to it
int stepx, stepy;
GetScrollPixelsPerUnit(&stepx, &stepy);
- // 'win' position coordinates are relative to it's parent
- // convert them so that they are relative to the m_targetWindow viewing area
- wxRect winrect(m_targetWindow->ScreenToClient(win->GetScreenPosition()),
- win->GetSize());
-
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
+
+// ----------------------------------------------------------------------------
+// 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