X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4995ca8037df9bea1192bd549f87e874d19fe0fe..9b49405777342458dc1666001865eef7309b6c30:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index f516a8552d..85e2ef3bae 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -1,13 +1,13 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: generic/scrolwin.cpp -// Purpose: wxGenericScrolledWindow implementation +// Name: src/generic/scrlwing.cpp +// Purpose: wxScrolledWindow implementation // Author: Julian Smart // Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement. // Ron Lee on 10.4.02: virtual size / auto scrollbars et al. // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team -// Licence: wxWindows license +// Copyright: (c) wxWidgets team +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -18,14 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "genscrolwin.h" -#endif - -#ifdef __VMS -#define XtDisplay XTDISPLAY -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -33,18 +25,26 @@ #pragma hdrstop #endif -#if !defined(__WXGTK__) || defined(__WXUNIVERSAL__) +#include "wx/scrolwin.h" -#include "wx/utils.h" -#include "wx/dcclient.h" +#ifndef WX_PRECOMP + #include "wx/utils.h" + #include "wx/panel.h" + #include "wx/dcclient.h" + #include "wx/timer.h" + #include "wx/sizer.h" + #include "wx/settings.h" +#endif -#include "wx/scrolwin.h" -#include "wx/panel.h" -#include "wx/timer.h" -#include "wx/sizer.h" +#ifdef __WXMAC__ +#include "wx/scrolbar.h" +#endif + +#include "wx/recguard.h" #ifdef __WXMSW__ #include // for DLGC_WANTARROWS + #include "wx/msw/winundef.h" #endif #ifdef __WXMOTIF__ @@ -59,7 +59,10 @@ #endif #endif -IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) +/* + TODO PROPERTIES + style wxHSCROLL | wxVSCROLL +*/ // ---------------------------------------------------------------------------- // wxScrollHelperEvtHandler: intercept the events from the window and forward @@ -69,23 +72,24 @@ IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler { public: - wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper) + wxScrollHelperEvtHandler(wxScrollHelperBase *scrollHelper) { m_scrollHelper = scrollHelper; } virtual bool ProcessEvent(wxEvent& event); - void ResetDrawnFlag() { m_hasDrawnWindow = FALSE; } + void ResetDrawnFlag() { m_hasDrawnWindow = false; } private: - wxScrollHelper *m_scrollHelper; + wxScrollHelperBase *m_scrollHelper; bool m_hasDrawnWindow; - DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler) + wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler); }; +#if wxUSE_TIMER // ---------------------------------------------------------------------------- // wxAutoScrollTimer: the timer used to generate a stream of scroll events when // a captured mouse is held outside the window @@ -94,7 +98,8 @@ private: class wxAutoScrollTimer : public wxTimer { public: - wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll, + wxAutoScrollTimer(wxWindow *winToScroll, + wxScrollHelperBase *scroll, wxEventType eventTypeToSend, int pos, int orient); @@ -102,12 +107,12 @@ public: 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); }; // ============================================================================ @@ -119,7 +124,7 @@ private: // ---------------------------------------------------------------------------- wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll, - wxScrollHelper *scroll, + wxScrollHelperBase *scroll, wxEventType eventTypeToSend, int pos, int orient) { @@ -170,6 +175,7 @@ void wxAutoScrollTimer::Notify() } } } +#endif // ---------------------------------------------------------------------------- // wxScrollHelperEvtHandler @@ -195,7 +201,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) // anything in the window. We set it to true here but reset it to false in // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the // user code defined OnPaint() in the derived class) - m_hasDrawnWindow = TRUE; + m_hasDrawnWindow = true; // pass it on to the real handler bool processed = wxEvtHandler::ProcessEvent(event); @@ -211,7 +217,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) { m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - return TRUE; + return true; } if ( processed ) @@ -219,22 +225,30 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) // normally, nothing more to do here - except if it was a paint event // which wasn't really processed, then we'll try to call our // OnDraw() below (from HandleOnPaint) - if ( m_hasDrawnWindow ) + if ( m_hasDrawnWindow || event.IsCommandEvent() ) { - return TRUE; + return true; } } - // reset the skipped flag to FALSE as it might have been set to TRUE in - // ProcessEvent() above - event.Skip(FALSE); - if ( evType == wxEVT_PAINT ) { m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); - return TRUE; + return true; + } + + if ( evType == wxEVT_CHILD_FOCUS ) + { + m_scrollHelper->HandleOnChildFocus((wxChildFocusEvent &)event); + return true; } + // reset the skipped flag (which might have been set to true in + // ProcessEvent() above) to be able to test it below + bool wasSkipped = event.GetSkipped(); + if ( wasSkipped ) + event.Skip(false); + if ( evType == wxEVT_SCROLLWIN_TOP || evType == wxEVT_SCROLLWIN_BOTTOM || evType == wxEVT_SCROLLWIN_LINEUP || @@ -244,8 +258,16 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) evType == wxEVT_SCROLLWIN_THUMBTRACK || evType == wxEVT_SCROLLWIN_THUMBRELEASE ) { - m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event); - return !event.GetSkipped(); + m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event); + if ( !event.GetSkipped() ) + { + // it makes sense to indicate that we processed the message as we + // did scroll the window (and also notice that wxAutoScrollTimer + // relies on our return value to stop scrolling when we are at top + // or bottom already) + processed = true; + wasSkipped = false; + } } if ( evType == wxEVT_ENTER_WINDOW ) @@ -257,26 +279,43 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) m_scrollHelper->HandleOnMouseLeave((wxMouseEvent &)event); } #if wxUSE_MOUSEWHEEL + // Use GTK's own scroll wheel handling in GtkScrolledWindow +#ifndef __WXGTK20__ else if ( evType == wxEVT_MOUSEWHEEL ) { m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event); + return true; } +#endif #endif // wxUSE_MOUSEWHEEL else if ( evType == wxEVT_CHAR ) { m_scrollHelper->HandleOnChar((wxKeyEvent &)event); - return !event.GetSkipped(); + if ( !event.GetSkipped() ) + { + processed = true; + wasSkipped = false; + } } - return FALSE; + if ( processed ) + event.Skip(wasSkipped); + + 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") ); + m_xScrollPixelsPerLine = m_yScrollPixelsPerLine = m_xScrollPosition = @@ -287,7 +326,7 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_yScrollLinesPerPage = 0; m_xScrollingEnabled = - m_yScrollingEnabled = TRUE; + m_yScrollingEnabled = true; m_scaleX = m_scaleY = 1.0; @@ -296,17 +335,21 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) #endif m_win = - m_targetWindow = (wxWindow *)NULL; + m_targetWindow = NULL; - m_timerAutoScroll = (wxTimer *)NULL; + m_timerAutoScroll = NULL; m_handler = NULL; - if ( win ) - SetWindow(win); + m_win = win; + + m_win->SetScrollHelper(static_cast(this)); + + // by default, the associated window is also the target window + DoSetTargetWindow(win); } -wxScrollHelper::~wxScrollHelper() +wxScrollHelperBase::~wxScrollHelperBase() { StopAutoScrolling(); @@ -317,13 +360,13 @@ wxScrollHelper::~wxScrollHelper() // 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; @@ -344,43 +387,47 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, m_xScrollPosition = xPos; m_yScrollPosition = yPos; + int w = noUnitsX * pixelsPerUnitX; + int h = noUnitsY * pixelsPerUnitY; + // For better backward compatibility we set persisting limits // here not just the size. It makes SetScrollbars 'sticky' // emulating the old non-autoscroll behaviour. - - wxSize sz = m_targetWindow->GetClientSize(); -#if 1 - int x = wxMax(noUnitsX * pixelsPerUnitX, sz.x); - int y = wxMax(noUnitsY * pixelsPerUnitY, sz.y); -#else - int x = noUnitsX * pixelsPerUnitX; - int y = noUnitsY * pixelsPerUnitY; -#endif - m_targetWindow->SetVirtualSizeHints( x, y ); + // m_targetWindow->SetVirtualSizeHints( w, h ); // The above should arguably be deprecated, this however we still need. - m_targetWindow->SetVirtualSize( x, y ); + // take care not to set 0 virtual size, 0 means that we don't have any + // scrollbars and hence we should use the real size instead of the virtual + // one which is indicated by using wxDefaultCoord + m_targetWindow->SetVirtualSize( w ? w : wxDefaultCoord, + h ? h : wxDefaultCoord); if (do_refresh && !noRefresh) - m_targetWindow->Refresh(TRUE, GetRect()); - - // TODO: check if we can use AdjustScrollbars always. -#ifdef __WXUNIVERSAL__ - AdjustScrollbars(); -#else - // This is also done by AdjustScrollbars, above -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately() ; -#endif -#endif + m_targetWindow->Refresh(true, GetScrollRect()); + +#ifndef __WXUNIVERSAL__ + // If the target is not the same as the window with the scrollbars, + // then we need to update the scrollbars here, since they won't have + // been updated by SetVirtualSize(). + if ( m_targetWindow != m_win ) +#endif // !__WXUNIVERSAL__ + { + AdjustScrollbars(); + } +#ifndef __WXUNIVERSAL__ + else + { + // otherwise this has been done by AdjustScrollbars, above + } +#endif // !__WXUNIVERSAL__ } // ---------------------------------------------------------------------------- // [target] window handling // ---------------------------------------------------------------------------- -void wxScrollHelper::DeleteEvtHandler() +void wxScrollHelperBase::DeleteEvtHandler() { // search for m_handler in the handler list if ( m_win && m_handler ) @@ -396,19 +443,18 @@ void wxScrollHelper::DeleteEvtHandler() } } -void wxScrollHelper::SetWindow(wxWindow *win) +void wxScrollHelperBase::ResetDrawnFlag() { - wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") ); - - m_win = win; - - // by default, the associated window is also the target window - DoSetTargetWindow(win); + wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" ); + m_handler->ResetDrawnFlag(); } -void wxScrollHelper::DoSetTargetWindow(wxWindow *target) +void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target) { m_targetWindow = target; +#ifdef __WXMAC__ + target->MacSetClipChildren( true ) ; +#endif // install the event handler which will intercept the events we're // interested in (but only do it for our real window, not the target window @@ -423,7 +469,7 @@ void wxScrollHelper::DoSetTargetWindow(wxWindow *target) } } -void wxScrollHelper::SetTargetWindow(wxWindow *target) +void wxScrollHelperBase::SetTargetWindow(wxWindow *target) { wxCHECK_RET( target, wxT("target window must not be NULL") ); @@ -433,7 +479,7 @@ void wxScrollHelper::SetTargetWindow(wxWindow *target) DoSetTargetWindow(target); } -wxWindow *wxScrollHelper::GetTargetWindow() const +wxWindow *wxScrollHelperBase::GetTargetWindow() const { return m_targetWindow; } @@ -442,7 +488,7 @@ wxWindow *wxScrollHelper::GetTargetWindow() const // scrolling implementation itself // ---------------------------------------------------------------------------- -void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) +void wxScrollHelperBase::HandleOnScroll(wxScrollWinEvent& event) { int nScrollInc = CalcScrollInc(event); if ( nScrollInc == 0 ) @@ -453,21 +499,10 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) return; } - int orient = event.GetOrientation(); - if (orient == wxHORIZONTAL) - { - m_xScrollPosition += nScrollInc; - m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition); - } - else - { - m_yScrollPosition += nScrollInc; - m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition); - } - - bool needsRefresh = FALSE; + bool needsRefresh = false; int dx = 0, dy = 0; + int orient = event.GetOrientation(); if (orient == wxHORIZONTAL) { if ( m_xScrollingEnabled ) @@ -476,7 +511,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } else @@ -487,25 +522,45 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } - if ( needsRefresh ) + if ( !needsRefresh ) + { + // flush all pending repaints before we change m_{x,y}ScrollPosition, as + // otherwise invalidated area could be updated incorrectly later when + // ScrollWindow() makes sure they're repainted before scrolling them +#ifdef __WXMAC__ + // wxWindowMac is taking care of making sure the update area is correctly + // set up, while not forcing an immediate redraw +#else + m_targetWindow->Update(); +#endif + } + + if (orient == wxHORIZONTAL) { - m_targetWindow->Refresh(TRUE, GetRect()); + m_xScrollPosition += nScrollInc; + m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition); } else { - m_targetWindow->ScrollWindow(dx, dy, GetRect()); + m_yScrollPosition += nScrollInc; + m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition); } -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately() ; -#endif + if ( needsRefresh ) + { + m_targetWindow->Refresh(true, GetScrollRect()); + } + else + { + m_targetWindow->ScrollWindow(dx, dy, GetScrollRect()); + } } -int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) +int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event) { int pos = event.GetPosition(); int orient = event.GetOrientation(); @@ -558,193 +613,60 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) if (orient == wxHORIZONTAL) { - if (m_xScrollPixelsPerLine > 0) + if ( m_xScrollPosition + nScrollInc < 0 ) { - int w, h; - GetTargetSize(&w, &h); - - int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine; - int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 ); - if (noPositions < 0) - noPositions = 0; - - if ( (m_xScrollPosition + nScrollInc) < 0 ) - nScrollInc = -m_xScrollPosition; // As -ve as we can go - else if ( (m_xScrollPosition + nScrollInc) > noPositions ) - nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go + // As -ve as we can go + nScrollInc = -m_xScrollPosition; } - else - m_targetWindow->Refresh(TRUE, GetRect()); - } - else - { - if (m_yScrollPixelsPerLine > 0) + else // check for the other bound { - int w, h; - GetTargetSize(&w, &h); - - int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine; - int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 ); - if (noPositions < 0) - noPositions = 0; - - if ( (m_yScrollPosition + nScrollInc) < 0 ) - nScrollInc = -m_yScrollPosition; // As -ve as we can go - else if ( (m_yScrollPosition + nScrollInc) > noPositions ) - nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go + const int posMax = m_xScrollLines - m_xScrollLinesPerPage; + if ( m_xScrollPosition + nScrollInc > posMax ) + { + // As +ve as we can go + nScrollInc = posMax - m_xScrollPosition; + } } - else - m_targetWindow->Refresh(TRUE, GetRect()); } - - return nScrollInc; -} - -// Adjust the scrollbars - new version. -void wxScrollHelper::AdjustScrollbars() -{ -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately(); -#endif - - int w = 0, h = 0; - int oldw, oldh; - - int oldXScroll = m_xScrollPosition; - int oldYScroll = m_yScrollPosition; - - do { - GetTargetSize(&w, 0); - - if (m_xScrollPixelsPerLine == 0) - { - m_xScrollLines = 0; - m_xScrollPosition = 0; - m_win->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); - } - else - { - m_xScrollLines = m_targetWindow->GetVirtualSize().GetWidth() / m_xScrollPixelsPerLine; - - // Calculate page size i.e. number of scroll units you get on the - // current client window - int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 ); - if (noPagePositions < 1) noPagePositions = 1; - if ( noPagePositions > m_xScrollLines ) - noPagePositions = m_xScrollLines; - - // Correct position if greater than extent of canvas minus - // the visible portion of it or if below zero - m_xScrollPosition = wxMin( m_xScrollLines - noPagePositions, m_xScrollPosition); - m_xScrollPosition = wxMax( 0, m_xScrollPosition ); - - m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines); - // The amount by which we scroll when paging - SetScrollPageSize(wxHORIZONTAL, noPagePositions); - } - - GetTargetSize(0, &h); - - if (m_yScrollPixelsPerLine == 0) - { - m_yScrollLines = 0; - m_yScrollPosition = 0; - m_win->SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE); - } - else - { - m_yScrollLines = m_targetWindow->GetVirtualSize().GetHeight() / m_yScrollPixelsPerLine; - - // Calculate page size i.e. number of scroll units you get on the - // current client window - int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 ); - if (noPagePositions < 1) noPagePositions = 1; - if ( noPagePositions > m_yScrollLines ) - noPagePositions = m_yScrollLines; - - // Correct position if greater than extent of canvas minus - // the visible portion of it or if below zero - m_yScrollPosition = wxMin( m_yScrollLines - noPagePositions, m_yScrollPosition ); - m_yScrollPosition = wxMax( 0, m_yScrollPosition ); - - m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines); - // The amount by which we scroll when paging - SetScrollPageSize(wxVERTICAL, noPagePositions); - } - - // If a scrollbar (dis)appeared as a result of this, adjust them again. - - oldw = w; - oldh = h; - - GetTargetSize( &w, &h ); - } while ( w != oldw && h != oldh ); - -#ifdef __WXMOTIF__ - // Sorry, some Motif-specific code to implement a backing pixmap - // for the wxRETAINED style. Implementing a backing store can't - // be entirely generic because it relies on the wxWindowDC implementation - // to duplicate X drawing calls for the backing pixmap. - - if ( m_targetWindow->GetWindowStyle() & wxRETAINED ) + else // wxVERTICAL { - 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))) + if ( m_yScrollPosition + nScrollInc < 0 ) { - XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap()); - m_targetWindow->SetBackingPixmap((WXPixmap) 0); + // As -ve as we can go + nScrollInc = -m_yScrollPosition; } - - if (!m_targetWindow->GetBackingPixmap() && - (m_xScrollLines != 0) && (m_yScrollLines != 0)) + else // check for the other bound { - 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)); + const int posMax = m_yScrollLines - m_yScrollLinesPerPage; + if ( m_yScrollPosition + nScrollInc > posMax ) + { + // As +ve as we can go + nScrollInc = posMax - m_yScrollPosition; + } } - - } -#endif // Motif - - if (oldXScroll != m_xScrollPosition) - { - if (m_xScrollingEnabled) - m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0, - GetRect() ); - else - m_targetWindow->Refresh(TRUE, GetRect()); - } - - if (oldYScroll != m_yScrollPosition) - { - if (m_yScrollingEnabled) - m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), - GetRect() ); - else - m_targetWindow->Refresh(TRUE, GetRect()); } -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately(); -#endif + return nScrollInc; } -void wxScrollHelper::DoPrepareDC(wxDC& dc) +void wxScrollHelperBase::DoPrepareDC(wxDC& dc) { wxPoint pt = dc.GetDeviceOrigin(); - dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine, - pt.y - m_yScrollPosition * m_yScrollPixelsPerLine ); +#ifdef __WXGTK__ + // It may actually be correct to always query + // the m_sign from the DC here, but I leave the + // #ifdef GTK for now. + if (m_win->GetLayoutDirection() == wxLayout_RightToLeft) + dc.SetDeviceOrigin( pt.x + m_xScrollPosition * m_xScrollPixelsPerLine, + pt.y - m_yScrollPosition * m_yScrollPixelsPerLine ); + else +#endif + dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine, + pt.y - m_yScrollPosition * m_yScrollPixelsPerLine ); dc.SetUserScale( m_scaleX, m_scaleY ); } -void wxScrollHelper::SetScrollRate( int xstep, int ystep ) +void wxScrollHelperBase::SetScrollRate( int xstep, int ystep ) { int old_x = m_xScrollPixelsPerLine * m_xScrollPosition; int old_y = m_yScrollPixelsPerLine * m_yScrollPosition; @@ -762,7 +684,7 @@ void wxScrollHelper::SetScrollRate( int xstep, int ystep ) AdjustScrollbars(); } -void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const +void wxScrollHelperBase::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const { if ( x_unit ) *x_unit = m_xScrollPixelsPerLine; @@ -770,7 +692,16 @@ void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const *y_unit = m_yScrollPixelsPerLine; } -int wxScrollHelper::GetScrollPageSize(int orient) const + +int wxScrollHelperBase::GetScrollLines( int orient ) const +{ + if ( orient == wxHORIZONTAL ) + return m_xScrollLines; + else + return m_yScrollLines; +} + +int wxScrollHelperBase::GetScrollPageSize(int orient) const { if ( orient == wxHORIZONTAL ) return m_xScrollLinesPerPage; @@ -778,7 +709,7 @@ int wxScrollHelper::GetScrollPageSize(int orient) const return m_yScrollLinesPerPage; } -void wxScrollHelper::SetScrollPageSize(int orient, int pageSize) +void wxScrollHelperBase::SetScrollPageSize(int orient, int pageSize) { if ( orient == wxHORIZONTAL ) m_xScrollLinesPerPage = pageSize; @@ -786,81 +717,14 @@ void wxScrollHelper::SetScrollPageSize(int orient, int pageSize) m_yScrollLinesPerPage = pageSize; } -/* - * Scroll to given position (scroll position, not pixel position) - */ -void wxScrollHelper::Scroll( int x_pos, int y_pos ) -{ - if (!m_targetWindow) - return; - - if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && - ((y_pos == -1) || (y_pos == m_yScrollPosition))) return; - -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately(); -#endif - - int w, h; - GetTargetSize(&w, &h); - - if ((x_pos != -1) && (m_xScrollPixelsPerLine)) - { - int old_x = m_xScrollPosition; - m_xScrollPosition = x_pos; - - // Calculate page size i.e. number of scroll units you get on the - // current client window - int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 ); - if (noPagePositions < 1) noPagePositions = 1; - - // Correct position if greater than extent of canvas minus - // the visible portion of it or if below zero - m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition ); - m_xScrollPosition = wxMax( 0, m_xScrollPosition ); - - if (old_x != m_xScrollPosition) { - m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition ); - m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0, - GetRect() ); - } - } - if ((y_pos != -1) && (m_yScrollPixelsPerLine)) - { - int old_y = m_yScrollPosition; - m_yScrollPosition = y_pos; - - // Calculate page size i.e. number of scroll units you get on the - // current client window - int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 ); - if (noPagePositions < 1) noPagePositions = 1; - - // Correct position if greater than extent of canvas minus - // the visible portion of it or if below zero - m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition ); - m_yScrollPosition = wxMax( 0, m_yScrollPosition ); - - if (old_y != m_yScrollPosition) { - m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition ); - m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine, - GetRect() ); - } - } - -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately(); -#endif - -} - -void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll) +void wxScrollHelperBase::EnableScrolling (bool x_scroll, bool y_scroll) { m_xScrollingEnabled = x_scroll; m_yScrollingEnabled = y_scroll; } // Where the current view starts from -void wxScrollHelper::GetViewStart (int *x, int *y) const +void wxScrollHelperBase::DoGetViewStart (int *x, int *y) const { if ( x ) *x = m_xScrollPosition; @@ -868,7 +732,8 @@ void wxScrollHelper::GetViewStart (int *x, int *y) const *y = m_yScrollPosition; } -void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const +void wxScrollHelperBase::DoCalcScrolledPosition(int x, int y, + int *xx, int *yy) const { if ( xx ) *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine; @@ -876,7 +741,8 @@ void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) cons *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine; } -void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const +void wxScrollHelperBase::DoCalcUnscrolledPosition(int x, int y, + int *xx, int *yy) const { if ( xx ) *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine; @@ -885,30 +751,70 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co } // ---------------------------------------------------------------------------- -// event handlers +// geometry // ---------------------------------------------------------------------------- -// Default OnSize resets scrollbars, if any -void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) +bool wxScrollHelperBase::ScrollLayout() { - if( m_win->GetAutoLayout() ) + if ( m_win->GetSizer() && m_targetWindow == m_win ) { - if ( m_targetWindow != m_win ) - m_targetWindow->FitInside(); + // 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; + } - m_win->FitInside(); + // fall back to default for LayoutConstraints + return m_win->wxWindow::Layout(); +} -#if wxUSE_CONSTRAINTS +void wxScrollHelperBase::ScrollDoSetVirtualSize(int x, int y) +{ + m_win->wxWindow::DoSetVirtualSize( x, y ); + AdjustScrollbars(); + + if (m_win->GetAutoLayout()) m_win->Layout(); -#endif +} + +// wxWindow's GetBestVirtualSize returns the actual window size, +// whereas we want to return the virtual size +wxSize wxScrollHelperBase::ScrollGetBestVirtualSize() const +{ + wxSize clientSize(m_win->GetClientSize()); + if ( m_win->GetSizer() ) + clientSize.IncTo(m_win->GetSizer()->CalcMin()); + + return clientSize; +} + +// ---------------------------------------------------------------------------- +// event handlers +// ---------------------------------------------------------------------------- + +// Default OnSize resets scrollbars, if any +void wxScrollHelperBase::HandleOnSize(wxSizeEvent& WXUNUSED(event)) +{ + if ( m_targetWindow->GetAutoLayout() ) + { + wxSize size = m_targetWindow->GetBestVirtualSize(); + + // This will call ::Layout() and ::AdjustScrollbars() + m_win->SetVirtualSize( size ); } else + { AdjustScrollbars(); + } } // 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); @@ -921,11 +827,11 @@ void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event)) // compatibility here - if we used OnKeyDown(), the programs which process // arrows themselves in their OnChar() would never get the message and like // this they always have the priority -void wxScrollHelper::HandleOnChar(wxKeyEvent& event) +void wxScrollHelperBase::HandleOnChar(wxKeyEvent& event) { - int stx, sty, // view origin - szx, szy, // view size (total) - clix, cliy; // view size (on screen) + 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); @@ -959,13 +865,11 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event) switch ( event.GetKeyCode() ) { case WXK_PAGEUP: - case WXK_PRIOR: dsty = sty - (5 * cliy / 6); Scroll(-1, (dsty == -1) ? 0 : dsty); break; case WXK_PAGEDOWN: - case WXK_NEXT: Scroll(-1, sty + (5 * cliy / 6)); break; @@ -1000,18 +904,18 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event) if ( m_xScrollPosition != xScrollOld ) { - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition, + wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition, wxHORIZONTAL); - event.SetEventObject(m_win); - m_win->GetEventHandler()->ProcessEvent(event); + evt.SetEventObject(m_win); + m_win->GetEventHandler()->ProcessEvent(evt); } if ( m_yScrollPosition != yScrollOld ) { - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition, + wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition, wxVERTICAL); - event.SetEventObject(m_win); - m_win->GetEventHandler()->ProcessEvent(event); + evt.SetEventObject(m_win); + m_win->GetEventHandler()->ProcessEvent(evt); } } @@ -1020,30 +924,32 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event) // a captured mouse is being held outside the window // ---------------------------------------------------------------------------- -bool wxScrollHelper::SendAutoScrollEvents(wxScrollWinEvent& event) const +bool wxScrollHelperBase::SendAutoScrollEvents(wxScrollWinEvent& event) const { // only send the event if the window is scrollable in this direction wxWindow *win = (wxWindow *)event.GetEventObject(); return win->HasScrollbar(event.GetOrientation()); } -void wxScrollHelper::StopAutoScrolling() +void wxScrollHelperBase::StopAutoScrolling() { +#if wxUSE_TIMER if ( m_timerAutoScroll ) { 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(); @@ -1095,6 +1001,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) if ( !m_targetWindow->HasScrollbar(orient) ) return; +#if wxUSE_TIMER delete m_timerAutoScroll; m_timerAutoScroll = new wxAutoScrollTimer ( @@ -1105,12 +1012,15 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) orient ); m_timerAutoScroll->Start(50); // FIXME: make configurable +#else + wxUnusedVar(pos); +#endif } } #if wxUSE_MOUSEWHEEL -void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) +void wxScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event) { m_wheelRotation += event.GetWheelRotation(); int lines = m_wheelRotation / event.GetWheelDelta(); @@ -1122,15 +1032,15 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) wxScrollWinEvent newEvent; newEvent.SetPosition(0); - newEvent.SetOrientation(wxVERTICAL); - newEvent.m_eventObject = m_win; + newEvent.SetOrientation( event.GetWheelAxis() == 0 ? wxVERTICAL : wxHORIZONTAL); + newEvent.SetEventObject(m_win); if (event.IsPageScroll()) { if (lines > 0) - newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP; + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP); else - newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN; + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN); m_win->GetEventHandler()->ProcessEvent(newEvent); } @@ -1138,9 +1048,9 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) { lines *= event.GetLinesPerAction(); if (lines > 0) - newEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP; + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP); else - newEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN; + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN); int times = abs(lines); for (; times > 0; times--) @@ -1151,109 +1061,511 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) #endif // wxUSE_MOUSEWHEEL -// ---------------------------------------------------------------------------- -// wxGenericScrolledWindow implementation -// ---------------------------------------------------------------------------- +void wxScrollHelperBase::HandleOnChildFocus(wxChildFocusEvent& event) +{ + // this event should be processed by all windows in parenthood chain, + // e.g. so that nested wxScrolledWindows work correctly + event.Skip(); -IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel) + // find the immediate child under which the window receiving focus is: + wxWindow *win = event.GetWindow(); -BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel) - EVT_PAINT(wxGenericScrolledWindow::OnPaint) -END_EVENT_TABLE() + if ( win == m_targetWindow ) + return; // nothing to do + +#ifdef __WXMAC__ + 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) + { + wxWindow *parent=win->GetParent(); + wxSize parent_size=parent->GetSize(); + if (parent_size.GetWidth() <= viewRect.GetWidth() && + parent_size.GetHeight() <= viewRect.GetHeight()) + // make the immediate parent visible instead of the focused control + win=parent; + } + + // make win position relative to the m_targetWindow viewing area instead of + // its parent + const wxRect + winRect(m_targetWindow->ScreenToClient(win->GetScreenPosition()), + win->GetSize()); + + // check if it's fully visible + if ( viewRect.Contains(winRect) ) + { + // it is, nothing to do + return; + } + + // check if we can make it fully visible: this is only possible if it's not + // larger than our view area + if ( winRect.GetWidth() > viewRect.GetWidth() || + winRect.GetHeight() > viewRect.GetHeight() ) + { + // we can't make it fit so avoid scrolling it at all, this is only + // going to be confusing and not helpful + return; + } -bool wxGenericScrolledWindow::Create(wxWindow *parent, - wxWindowID id, - const wxPoint& pos, - const wxSize& size, - long style, - const wxString& name) -{ - m_targetWindow = this; - bool ok = wxPanel::Create(parent, id, pos, size, style, name); + // do make the window fit inside the view area by scrolling to it + int stepx, stepy; + GetScrollPixelsPerUnit(&stepx, &stepy); - return ok; + int startx, starty; + GetViewStart(&startx, &starty); + + // first in vertical direction: + if ( stepy > 0 ) + { + int diff = 0; + + if ( winRect.GetTop() < 0 ) + { + diff = winRect.GetTop(); + } + else if ( winRect.GetBottom() > viewRect.GetHeight() ) + { + diff = winRect.GetBottom() - viewRect.GetHeight() + 1; + // round up to next scroll step if we can't get exact position, + // so that the window is fully visible: + diff += stepy - 1; + } + + starty = (starty * stepy + diff) / stepy; + } + + // then horizontal: + if ( stepx > 0 ) + { + int diff = 0; + + if ( winRect.GetLeft() < 0 ) + { + diff = winRect.GetLeft(); + } + else if ( winRect.GetRight() > viewRect.GetWidth() ) + { + diff = winRect.GetRight() - viewRect.GetWidth() + 1; + // round up to next scroll step if we can't get exact position, + // so that the window is fully visible: + diff += stepx - 1; + } + + startx = (startx * stepx + diff) / stepx; + } + + Scroll(startx, starty); } -wxGenericScrolledWindow::~wxGenericScrolledWindow() + +#ifdef wxHAS_GENERIC_SCROLLWIN + +// ---------------------------------------------------------------------------- +// wxScrollHelper implementation +// ---------------------------------------------------------------------------- + +wxScrollHelper::wxScrollHelper(wxWindow *winToScroll) + : wxScrollHelperBase(winToScroll) { + m_xVisibility = + m_yVisibility = wxSHOW_SB_DEFAULT; } -bool wxGenericScrolledWindow::Layout() +void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz, + wxScrollbarVisibility vert) { - if (GetSizer() && m_targetWindow == this) + if ( horz != m_xVisibility || vert != m_yVisibility ) { - // If we're the scroll target, take into account the - // virtual size and scrolled position of the window. + m_xVisibility = horz; + m_yVisibility = vert; - int x, y, w, h; - CalcScrolledPosition(0,0, &x,&y); - GetVirtualSize(&w, &h); - GetSizer()->SetDimension(x, y, w, h); - return TRUE; + AdjustScrollbars(); } - - // fall back to default for LayoutConstraints - return wxPanel::Layout(); } -void wxGenericScrolledWindow::DoSetVirtualSize(int x, int y) +void +wxScrollHelper::DoAdjustScrollbar(int orient, + int clientSize, + int virtSize, + int pixelsPerUnit, + int& scrollUnits, + int& scrollPosition, + int& scrollLinesPerPage, + wxScrollbarVisibility visibility) { - wxPanel::DoSetVirtualSize( x, y ); - AdjustScrollbars(); + // 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; -#if wxUSE_CONSTRAINTS - if (GetAutoLayout()) - Layout(); -#endif + // 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 wxGenericScrolledWindow::OnPaint(wxPaintEvent& event) +void wxScrollHelper::AdjustScrollbars() { - // 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(); + 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; + } - event.Skip(); + 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()); + } } -#ifdef __WXMSW__ -long -wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg, - WXWPARAM wParam, - WXLPARAM lParam) +void wxScrollHelper::DoScroll( int x_pos, int y_pos ) { - long rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam); + if (!m_targetWindow) + return; - // we need to process arrows ourselves for scrolling - if ( nMsg == WM_GETDLGCODE ) + 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)) { - rc |= DLGC_WANTARROWS; + 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; - return rc; + // 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 // __WXMSW__ +#endif // wxHAS_GENERIC_SCROLLWIN -#if WXWIN_COMPATIBILITY +// ---------------------------------------------------------------------------- +// wxScrolled and wxScrolledWindow implementation +// ---------------------------------------------------------------------------- -void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const +wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win, + const wxScrollHelper *helper, + const wxSize& origBest) { - *x_page = GetScrollPageSize(wxHORIZONTAL); - *y_page = GetScrollPageSize(wxVERTICAL); + // NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not + // all scrollable windows should behave like this, only those that + // contain children controls within scrollable area + // (i.e., wxScrolledWindow) and other some scrollable windows may + // have different DoGetBestSize() implementation (e.g. wxTreeCtrl). + + wxSize best = origBest; + + if ( win->GetAutoLayout() ) + { + // Only use the content to set the window size in the direction + // where there's no scrolling; otherwise we're going to get a huge + // window in the direction in which scrolling is enabled + int ppuX, ppuY; + helper->GetScrollPixelsPerUnit(&ppuX, &ppuY); + + // NB: This code used to use *current* size if min size wasn't + // specified, presumably to get some reasonable (i.e., larger than + // minimal) size. But that's a wrong thing to do in GetBestSize(), + // so we use minimal size as specified. If the app needs some + // minimal size for its scrolled window, it should set it and put + // the window into sizer as expandable so that it can use all space + // available to it. + // + // See also http://svn.wxwidgets.org/viewvc/wx?view=rev&revision=45864 + + wxSize minSize = win->GetMinSize(); + + if ( ppuX > 0 ) + best.x = minSize.x + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X); + + if ( ppuY > 0 ) + best.y = minSize.y + wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y); + } + + return best; } -void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const +#ifdef __WXMSW__ +WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc) { - if ( xx ) - *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine); - if ( yy ) - *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine); +#ifndef __WXWINCE__ + // we need to process arrows ourselves for scrolling + if ( nMsg == WM_GETDLGCODE ) + { + rc |= DLGC_WANTARROWS; + } +#endif + return rc; } +#endif // __WXMSW__ -#endif // WXWIN_COMPATIBILITY - -#endif // !wxGTK - -// vi:sts=4:sw=4:et +// NB: skipping wxScrolled in wxRTTI information because being a templte, +// it doesn't and can't implement wxRTTI support +IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)