X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1f06669822f2c4e66bae66a41bc4361d46cdaf8c..cb2f2135b0c8966eb353634d1239a5dc6ba09266:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index 9ab5ebe316..35d85bbefa 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -1,12 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: generic/scrolwin.cpp -// Purpose: wxGenericScrolledWindow implementation +// Name: src/generic/scrlwing.cpp +// Purpose: wxScrolledWindow implementation // Author: Julian Smart // Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement. // Ron Lee on 10.4.02: virtual size / auto scrollbars et al. // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team +// Copyright: (c) wxWidgets team // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -18,10 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "genscrolwin.h" -#endif - #ifdef __VMS #define XtDisplay XTDISPLAY #endif @@ -33,18 +29,27 @@ #pragma hdrstop #endif -#if !defined(__WXGTK__) || defined(__WXUNIVERSAL__) +#include "wx/scrolwin.h" + +#ifndef WX_PRECOMP + #include "wx/utils.h" + #include "wx/panel.h" + #include "wx/dcclient.h" + #if wxUSE_TIMER + #include "wx/timer.h" + #endif + #include "wx/sizer.h" +#endif -#include "wx/utils.h" -#include "wx/dcclient.h" +#ifdef __WXMAC__ +#include "wx/scrolbar.h" +#endif -#include "wx/scrolwin.h" -#include "wx/panel.h" -#include "wx/timer.h" -#include "wx/sizer.h" +#include "wx/recguard.h" #ifdef __WXMSW__ #include // for DLGC_WANTARROWS + #include "wx/msw/winundef.h" #endif #ifdef __WXMOTIF__ @@ -59,7 +64,10 @@ #endif #endif -IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) +/* + TODO PROPERTIES + style wxHSCROLL | wxVSCROLL +*/ // ---------------------------------------------------------------------------- // wxScrollHelperEvtHandler: intercept the events from the window and forward @@ -76,7 +84,7 @@ public: virtual bool ProcessEvent(wxEvent& event); - void ResetDrawnFlag() { m_hasDrawnWindow = FALSE; } + void ResetDrawnFlag() { m_hasDrawnWindow = false; } private: wxScrollHelper *m_scrollHelper; @@ -86,6 +94,7 @@ private: DECLARE_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 @@ -170,6 +179,7 @@ void wxAutoScrollTimer::Notify() } } } +#endif // ---------------------------------------------------------------------------- // wxScrollHelperEvtHandler @@ -195,7 +205,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 +221,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) { m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - return TRUE; + return true; } if ( processed ) @@ -219,22 +229,24 @@ 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; } + // 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 +256,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 ) @@ -265,10 +285,17 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) 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; } // ---------------------------------------------------------------------------- @@ -277,6 +304,8 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) wxScrollHelper::wxScrollHelper(wxWindow *win) { + wxASSERT_MSG( win, _T("associated window can't be NULL in wxScrollHelper") ); + m_xScrollPixelsPerLine = m_yScrollPixelsPerLine = m_xScrollPosition = @@ -287,7 +316,7 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_yScrollLinesPerPage = 0; m_xScrollingEnabled = - m_yScrollingEnabled = TRUE; + m_yScrollingEnabled = true; m_scaleX = m_scaleY = 1.0; @@ -302,8 +331,12 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_handler = NULL; - if ( win ) - SetWindow(win); + m_win = win; + + m_win->SetScrollHelper( this ); + + // by default, the associated window is also the target window + DoSetTargetWindow(win); } wxScrollHelper::~wxScrollHelper() @@ -350,15 +383,18 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, // For better backward compatibility we set persisting limits // here not just the size. It makes SetScrollbars 'sticky' // emulating the old non-autoscroll behaviour. - - m_targetWindow->SetVirtualSizeHints( w, h ); + // m_targetWindow->SetVirtualSizeHints( w, h ); // The above should arguably be deprecated, this however we still need. - m_targetWindow->SetVirtualSize( w, h ); + // take care not to set 0 virtual size, 0 means that we don't have any + // scrollbars and hence we should use the real size instead of the virtual + // one which is indicated by using wxDefaultCoord + m_targetWindow->SetVirtualSize( w ? w : wxDefaultCoord, + h ? h : wxDefaultCoord); if (do_refresh && !noRefresh) - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); #ifndef __WXUNIVERSAL__ // If the target is not the same as the window with the scrollbars, @@ -373,9 +409,6 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, else { // otherwise this has been done by AdjustScrollbars, above -#ifdef __WXMAC__ - m_targetWindow->Update() ; -#endif } #endif // !__WXUNIVERSAL__ } @@ -400,19 +433,12 @@ void wxScrollHelper::DeleteEvtHandler() } } -void wxScrollHelper::SetWindow(wxWindow *win) -{ - 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); -} - void wxScrollHelper::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 @@ -442,6 +468,22 @@ wxWindow *wxScrollHelper::GetTargetWindow() const return m_targetWindow; } +#ifdef __WXMAC__ +static bool wxScrolledWindowHasChildren(wxWindow* win) +{ + wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); + while ( node ) + { + wxWindow* child = node->GetData(); + if ( !child->IsKindOf(CLASSINFO(wxScrollBar)) ) + return true; + + node = node->GetNext(); + } + return false; +} +#endif + // ---------------------------------------------------------------------------- // scrolling implementation itself // ---------------------------------------------------------------------------- @@ -457,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 ) @@ -480,7 +511,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } else @@ -491,22 +522,42 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } + if ( !needsRefresh ) + { + // flush all pending repaints before we change m_{x,y}ScrollPosition, as + // otherwise invalidated area could be updated incorrectly later when + // ScrollWindow() makes sure they're repainted before scrolling them +#ifdef __WXMAC__ + // wxWindowMac is taking care of making sure the update area is correctly + // set up, while not forcing an immediate redraw +#else + m_targetWindow->Update(); +#endif + } + + if (orient == wxHORIZONTAL) + { + m_xScrollPosition += nScrollInc; + m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition); + } + else + { + m_yScrollPosition += nScrollInc; + m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition); + } + if ( needsRefresh ) { - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } else { m_targetWindow->ScrollWindow(dx, dy, GetScrollRect()); } - -#ifdef __WXMAC__ - m_targetWindow->Update() ; -#endif } int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) @@ -562,47 +613,36 @@ 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, GetScrollRect()); - } - else - { - if ( m_yScrollPixelsPerLine > 0 ) + else // check for the other bound { - if ( m_yScrollPosition + nScrollInc < 0 ) - { - // As -ve as we can go - nScrollInc = -m_yScrollPosition; - } - else // check for the other bound + const int posMax = m_xScrollLines - m_xScrollLinesPerPage; + if ( m_xScrollPosition + nScrollInc > posMax ) { - const int posMax = m_yScrollLines - m_yScrollLinesPerPage; - if ( m_yScrollPosition + nScrollInc > posMax ) - { - // As +ve as we can go - nScrollInc = posMax - m_yScrollPosition; - } + // As +ve as we can go + nScrollInc = posMax - m_xScrollPosition; } } - else + } + else // wxVERTICAL + { + if ( m_yScrollPosition + nScrollInc < 0 ) { - // VZ: why do we do this? (FIXME) - m_targetWindow->Refresh(TRUE, GetScrollRect()); + // As -ve as we can go + nScrollInc = -m_yScrollPosition; + } + else // check for the other bound + { + const int posMax = m_yScrollLines - m_yScrollLinesPerPage; + if ( m_yScrollPosition + nScrollInc > posMax ) + { + // As +ve as we can go + nScrollInc = posMax - m_yScrollPosition; + } } } @@ -612,9 +652,18 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) // Adjust the scrollbars - new version. void wxScrollHelper::AdjustScrollbars() { -#ifdef __WXMAC__ - m_targetWindow->Update(); -#endif + static wxRecursionGuardFlag s_flagReentrancy; + wxRecursionGuard guard(s_flagReentrancy); + if ( guard.IsInside() ) + { + // don't reenter AdjustScrollbars() while another call to + // AdjustScrollbars() is in progress because this may lead to calling + // ScrollWindow() twice and this can really happen under MSW if + // SetScrollbar() call below adds or removes the scrollbar which + // changes the window size and hence results in another + // AdjustScrollbars() call + return; + } int w = 0, h = 0; int oldw, oldh; @@ -628,41 +677,68 @@ void wxScrollHelper::AdjustScrollbars() // it here for now but it would be better to ensure that all ports // generate EVT_SIZE when scrollbars [dis]appear, emulating it if // necessary, and remove it later + // JACS: Stop potential infinite loop by limiting number of iterations + int iterationCount = 0; + const int iterationMax = 5; do { + iterationCount ++; + GetTargetSize(&w, 0); - if (m_xScrollPixelsPerLine == 0) + // scroll lines per page: if 0, no scrolling is needed + int linesPerPage; + + if ( m_xScrollPixelsPerLine == 0 ) { + // scrolling is disabled m_xScrollLines = 0; m_xScrollPosition = 0; - m_win->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); + linesPerPage = 0; } - else + else // might need scrolling { - m_xScrollLines = m_targetWindow->GetVirtualSize().GetWidth() / m_xScrollPixelsPerLine; + // Round up integer division to catch any "leftover" client space. + const int wVirt = m_targetWindow->GetVirtualSize().GetWidth(); + m_xScrollLines = (wVirt + m_xScrollPixelsPerLine - 1) / m_xScrollPixelsPerLine; // Calculate page size i.e. number of scroll units you get on the - // current client window - 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); + // current client window. + linesPerPage = w / m_xScrollPixelsPerLine; + + // Special case. When client and virtual size are very close but + // the client is big enough, kill scrollbar. + if ((linesPerPage < m_xScrollLines) && (w >= wVirt)) ++linesPerPage; + + if (linesPerPage >= m_xScrollLines) + { + // we're big enough to not need scrolling + linesPerPage = + m_xScrollLines = + m_xScrollPosition = 0; + } + else // we do need a scrollbar + { + if ( linesPerPage < 1 ) + linesPerPage = 1; + + // Correct position if greater than extent of canvas minus + // the visible portion of it or if below zero + const int posMax = m_xScrollLines - linesPerPage; + if ( m_xScrollPosition > posMax ) + m_xScrollPosition = posMax; + else if ( m_xScrollPosition < 0 ) + m_xScrollPosition = 0; + } } - GetTargetSize(0, &h); + m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, + linesPerPage, m_xScrollLines); - // scroll lines per page: if 0, no scrolling is needed - int linesPerPage; + // The amount by which we scroll when paging + SetScrollPageSize(wxHORIZONTAL, linesPerPage); + + GetTargetSize(0, &h); if ( m_yScrollPixelsPerLine == 0 ) { @@ -673,13 +749,19 @@ void wxScrollHelper::AdjustScrollbars() } else // might need scrolling { - int hVirt = m_targetWindow->GetVirtualSize().GetHeight(); - m_yScrollLines = hVirt / m_yScrollPixelsPerLine; + // Round up integer division to catch any "leftover" client space. + const int hVirt = m_targetWindow->GetVirtualSize().GetHeight(); + m_yScrollLines = ( hVirt + m_yScrollPixelsPerLine - 1 ) / m_yScrollPixelsPerLine; // Calculate page size i.e. number of scroll units you get on the - // current client window + // current client window. linesPerPage = h / m_yScrollPixelsPerLine; - if ( linesPerPage >= m_yScrollLines ) + + // Special case. When client and virtual size are very close but + // the client is big enough, kill scrollbar. + if ((linesPerPage < m_yScrollLines) && (h >= hVirt)) ++linesPerPage; + + if (linesPerPage >= m_yScrollLines) { // we're big enough to not need scrolling linesPerPage = @@ -713,7 +795,7 @@ void wxScrollHelper::AdjustScrollbars() oldh = h; GetTargetSize( &w, &h ); - } while ( w != oldw && h != oldh ); + } while ( (w != oldw || h != oldh) && (iterationCount < iterationMax) ); #ifdef __WXMOTIF__ // Sorry, some Motif-specific code to implement a backing pixmap @@ -754,7 +836,7 @@ void wxScrollHelper::AdjustScrollbars() m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0, GetScrollRect() ); else - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } if (oldYScroll != m_yScrollPosition) @@ -763,19 +845,24 @@ void wxScrollHelper::AdjustScrollbars() m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), GetScrollRect() ); else - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } - -#ifdef __WXMAC__ - m_targetWindow->Update(); -#endif } void wxScrollHelper::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 leve 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 ); } @@ -805,6 +892,15 @@ void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const *y_unit = m_yScrollPixelsPerLine; } + +int wxScrollHelper::GetScrollLines( int orient ) const +{ + if ( orient == wxHORIZONTAL ) + return m_xScrollLines; + else + return m_yScrollLines; +} + int wxScrollHelper::GetScrollPageSize(int orient) const { if ( orient == wxHORIZONTAL ) @@ -832,60 +928,68 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos ) if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && ((y_pos == -1) || (y_pos == m_yScrollPosition))) return; -#ifdef __WXMAC__ - m_targetWindow->Update(); -#endif - - int w, h; + 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)) { - int old_x = m_xScrollPosition; - m_xScrollPosition = x_pos; + new_x = 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 ); + 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 - m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition ); - m_xScrollPosition = wxMax( 0, m_xScrollPosition ); - - if (old_x != m_xScrollPosition) { - m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition ); - m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0, - GetScrollRect() ); - } + new_x = wxMin( m_xScrollLines-noPagePositions, new_x ); + new_x = wxMax( 0, new_x ); } if ((y_pos != -1) && (m_yScrollPixelsPerLine)) { - int old_y = m_yScrollPosition; - m_yScrollPosition = y_pos; + new_y = 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 ); + 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 - m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition ); - m_yScrollPosition = wxMax( 0, m_yScrollPosition ); - - if (old_y != m_yScrollPosition) { - m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition ); - m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine, - GetScrollRect() ); - } + new_y = wxMin( m_yScrollLines-noPagePositions, new_y ); + new_y = wxMax( 0, new_y ); } -#ifdef __WXMAC__ + 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(); -#endif + // 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) @@ -919,6 +1023,71 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co *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(); +} + +// wxWindow's GetBestVirtualSize returns the actual window size, +// whereas we want to return the virtual size +wxSize wxScrollHelper::ScrollGetBestVirtualSize() const +{ + wxSize clientSize(m_win->GetClientSize()); + if ( m_win->GetSizer() ) + clientSize.IncTo(m_win->GetSizer()->CalcMin()); + + return clientSize; +} + +// return the window best size from the given best virtual size +wxSize +wxScrollHelper::ScrollGetWindowSizeForVirtualSize(const wxSize& size) const +{ + // Only use the content to set the window size in the direction + // where there's no scrolling; otherwise we're going to get a huge + // window in the direction in which scrolling is enabled + int ppuX, ppuY; + GetScrollPixelsPerUnit(&ppuX, &ppuY); + + wxSize minSize = m_win->GetMinSize(); + if ( !minSize.IsFullySpecified() ) + minSize = m_win->GetSize(); + + wxSize best(size); + if (ppuX > 0) + best.x = minSize.x; + if (ppuY > 0) + best.y = minSize.y; + + return best; +} + // ---------------------------------------------------------------------------- // event handlers // ---------------------------------------------------------------------------- @@ -926,22 +1095,17 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co // Default OnSize resets scrollbars, if any void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) { - if( m_win->GetAutoLayout() || m_targetWindow->GetAutoLayout() ) + if ( m_targetWindow->GetAutoLayout() ) { - if ( m_targetWindow != m_win ) - m_targetWindow->FitInside(); - - m_win->FitInside(); + wxSize size = m_targetWindow->GetBestVirtualSize(); - // FIXME: Something is really weird here... This should be - // called by FitInside above (and apparently is), yet the - // scrollsub sample will get the scrollbar wrong if resized - // quickly. This masks the bug, but is surely not the right - // answer at all. - AdjustScrollbars(); + // This will call ::Layout() and ::AdjustScrollbars() + m_win->SetVirtualSize( size ); } else + { AdjustScrollbars(); + } } // This calls OnDraw, having adjusted the origin according to the current @@ -961,9 +1125,9 @@ void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event)) // this they always have the priority void wxScrollHelper::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); @@ -997,13 +1161,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; @@ -1067,11 +1229,13 @@ bool wxScrollHelper::SendAutoScrollEvents(wxScrollWinEvent& event) const void wxScrollHelper::StopAutoScrolling() { +#if wxUSE_TIMER if ( m_timerAutoScroll ) { delete m_timerAutoScroll; m_timerAutoScroll = (wxTimer *)NULL; } +#endif } void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event) @@ -1133,6 +1297,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) if ( !m_targetWindow->HasScrollbar(orient) ) return; +#if wxUSE_TIMER delete m_timerAutoScroll; m_timerAutoScroll = new wxAutoScrollTimer ( @@ -1143,6 +1308,9 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) orient ); m_timerAutoScroll->Start(50); // FIXME: make configurable +#else + wxUnusedVar(pos); +#endif } } @@ -1160,15 +1328,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); } @@ -1176,9 +1344,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--) @@ -1190,16 +1358,16 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) #endif // wxUSE_MOUSEWHEEL // ---------------------------------------------------------------------------- -// wxGenericScrolledWindow implementation +// wxScrolledWindow implementation // ---------------------------------------------------------------------------- -IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel) +IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel) -BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel) - EVT_PAINT(wxGenericScrolledWindow::OnPaint) +BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel) + EVT_PAINT(wxScrolledWindow::OnPaint) END_EVENT_TABLE() -bool wxGenericScrolledWindow::Create(wxWindow *parent, +bool wxScrolledWindow::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, @@ -1207,46 +1375,26 @@ bool wxGenericScrolledWindow::Create(wxWindow *parent, const wxString& name) { m_targetWindow = this; +#ifdef __WXMAC__ + MacSetClipChildren( true ) ; +#endif + + // by default, we're scrollable in both directions (but if one of the + // styles is specified explicitly, we shouldn't add the other one + // automatically) + if ( !(style & (wxHSCROLL | wxVSCROLL)) ) + style |= wxHSCROLL | wxVSCROLL; bool ok = wxPanel::Create(parent, id, pos, size, style, name); return ok; } -wxGenericScrolledWindow::~wxGenericScrolledWindow() -{ -} - -bool wxGenericScrolledWindow::Layout() -{ - if (GetSizer() && m_targetWindow == this) - { - // If we're the scroll target, take into account the - // virtual size and scrolled position of the window. - - int x, y, w, h; - CalcScrolledPosition(0,0, &x,&y); - GetVirtualSize(&w, &h); - GetSizer()->SetDimension(x, y, w, h); - return TRUE; - } - - // fall back to default for LayoutConstraints - return wxPanel::Layout(); -} - -void wxGenericScrolledWindow::DoSetVirtualSize(int x, int y) +wxScrolledWindow::~wxScrolledWindow() { - wxPanel::DoSetVirtualSize( x, y ); - AdjustScrollbars(); - -#if wxUSE_CONSTRAINTS - if (GetAutoLayout()) - Layout(); -#endif } -void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event) +void wxScrolledWindow::OnPaint(wxPaintEvent& event) { // the user code didn't really draw the window if we got here, so set this // flag to try to call OnDraw() later @@ -1256,42 +1404,21 @@ void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event) } #ifdef __WXMSW__ -long -wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg, +WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) { - long rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam); + WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam); +#ifndef __WXWINCE__ // we need to process arrows ourselves for scrolling if ( nMsg == WM_GETDLGCODE ) { rc |= DLGC_WANTARROWS; } +#endif return rc; } #endif // __WXMSW__ - -#if WXWIN_COMPATIBILITY - -void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const -{ - *x_page = GetScrollPageSize(wxHORIZONTAL); - *y_page = GetScrollPageSize(wxVERTICAL); -} - -void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const -{ - if ( xx ) - *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine); - if ( yy ) - *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine); -} - -#endif // WXWIN_COMPATIBILITY - -#endif // !wxGTK - -// vi:sts=4:sw=4:et