X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/39c869a6cd3a3faf36cf90e95ec1dc255edc5676..d40a56d0db2e5249a65087b6af7d1ff7bfb378a6:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index 575df5c5c0..7add087eda 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -2,11 +2,12 @@ // Name: generic/scrolwin.cpp // Purpose: wxGenericScrolledWindow implementation // Author: Julian Smart -// Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement +// 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 ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,7 +18,7 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "genscrolwin.h" #endif @@ -39,10 +40,15 @@ #include "wx/scrolwin.h" #include "wx/panel.h" +#if wxUSE_TIMER #include "wx/timer.h" +#endif +#include "wx/sizer.h" +#include "wx/recguard.h" #ifdef __WXMSW__ #include // for DLGC_WANTARROWS + #include "wx/msw/winundef.h" #endif #ifdef __WXMOTIF__ @@ -59,12 +65,17 @@ IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) +/* + TODO PROPERTIES + style wxHSCROLL | wxVSCROLL +*/ + // ---------------------------------------------------------------------------- // wxScrollHelperEvtHandler: intercept the events from the window and forward // them to wxScrollHelper // ---------------------------------------------------------------------------- -class wxScrollHelperEvtHandler : public wxEvtHandler +class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler { public: wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper) @@ -74,10 +85,17 @@ public: virtual bool ProcessEvent(wxEvent& event); + void ResetDrawnFlag() { m_hasDrawnWindow = false; } + private: wxScrollHelper *m_scrollHelper; + + bool m_hasDrawnWindow; + + 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 @@ -98,6 +116,8 @@ private: wxEventType m_eventType; int m_pos, m_orient; + + DECLARE_NO_COPY_CLASS(wxAutoScrollTimer) }; // ============================================================================ @@ -160,6 +180,7 @@ void wxAutoScrollTimer::Notify() } } } +#endif // ---------------------------------------------------------------------------- // wxScrollHelperEvtHandler @@ -167,19 +188,62 @@ void wxAutoScrollTimer::Notify() bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) { - if ( wxEvtHandler::ProcessEvent(event) ) - return TRUE; + wxEventType evType = event.GetEventType(); - // reset the skipped flag to FALSE as it might have been set to TRUE in - // ProcessEvent() above - event.Skip(FALSE); + // the explanation of wxEVT_PAINT processing hack: for historic reasons + // there are 2 ways to process this event in classes deriving from + // wxScrolledWindow. The user code may + // + // 1. override wxScrolledWindow::OnDraw(dc) + // 2. define its own OnPaint() handler + // + // In addition, in wxUniversal wxWindow defines OnPaint() itself and + // always processes the draw event, so we can't just try the window + // OnPaint() first and call our HandleOnPaint() if it doesn't process it + // (the latter would never be called in wxUniversal). + // + // So the solution is to have a flag telling us whether the user code drew + // anything in the window. We set it to true here but reset it to false in + // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the + // user code defined OnPaint() in the derived class) + m_hasDrawnWindow = true; + + // pass it on to the real handler + bool processed = wxEvtHandler::ProcessEvent(event); + + // always process the size events ourselves, even if the user code handles + // them as well, as we need to AdjustScrollbars() + // + // NB: it is important to do it after processing the event in the normal + // way as HandleOnSize() may generate a wxEVT_SIZE itself if the + // scrollbar[s] (dis)appear and it should be seen by the user code + // after this one + if ( evType == wxEVT_SIZE ) + { + m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - wxEventType evType = event.GetEventType(); + return true; + } + + if ( processed ) + { + // normally, nothing more to do here - except if it was a paint event + // which wasn't really processed, then we'll try to call our + // OnDraw() below (from HandleOnPaint) + if ( m_hasDrawnWindow ) + { + 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_SCROLLWIN_TOP || @@ -209,17 +273,13 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event); } #endif // wxUSE_MOUSEWHEEL - else if ( evType == wxEVT_SIZE ) - { - m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - } else if ( evType == wxEVT_CHAR ) { m_scrollHelper->HandleOnChar((wxKeyEvent &)event); return !event.GetSkipped(); } - return FALSE; + return false; } // ---------------------------------------------------------------------------- @@ -238,7 +298,7 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_yScrollLinesPerPage = 0; m_xScrollingEnabled = - m_yScrollingEnabled = TRUE; + m_yScrollingEnabled = true; m_scaleX = m_scaleY = 1.0; @@ -251,27 +311,17 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_timerAutoScroll = (wxTimer *)NULL; + m_handler = NULL; + if ( win ) SetWindow(win); } -void wxScrollHelper::SetWindow(wxWindow *win) -{ - wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") ); - - m_targetWindow = m_win = win; - - // install the event handler which will intercept the events we're - // interested in - m_win->PushEventHandler(new wxScrollHelperEvtHandler(this)); -} - wxScrollHelper::~wxScrollHelper() { StopAutoScrolling(); - if ( m_targetWindow ) - m_targetWindow->PopEventHandler(TRUE /* do delete it */); + DeleteEvtHandler(); } // ---------------------------------------------------------------------------- @@ -292,10 +342,10 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, bool do_refresh = ( (noUnitsX != 0 && m_xScrollLines == 0) || - (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX*noUnitsX) || + (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX * noUnitsX) || (noUnitsY != 0 && m_yScrollLines == 0) || - (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY*noUnitsY) || + (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY * noUnitsY) || (xPos != m_xScrollPosition) || (yPos != m_yScrollPosition) ); @@ -304,60 +354,98 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, m_yScrollPixelsPerLine = pixelsPerUnitY; m_xScrollPosition = xPos; m_yScrollPosition = yPos; - m_xScrollLines = noUnitsX; - m_yScrollLines = noUnitsY; -#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. + int w = noUnitsX * pixelsPerUnitX; + int h = noUnitsY * pixelsPerUnitY; - if ( m_targetWindow->GetWindowStyle() & wxRETAINED ) + // 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 ); + + // The above should arguably be deprecated, this however we still need. + + // 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()); + +#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__ { - Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget()); + AdjustScrollbars(); + } +#ifndef __WXUNIVERSAL__ + else + { + // otherwise this has been done by AdjustScrollbars, above + } +#endif // !__WXUNIVERSAL__ +} - int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine; - int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine; - if (m_targetWindow->m_backingPixmap && - !((m_targetWindow->m_pixmapWidth == totalPixelWidth) && - (m_targetWindow->m_pixmapHeight == totalPixelHeight))) - { - XFreePixmap (dpy, (Pixmap) m_targetWindow->m_backingPixmap); - m_targetWindow->m_backingPixmap = (WXPixmap) 0; - } +// ---------------------------------------------------------------------------- +// [target] window handling +// ---------------------------------------------------------------------------- - if (!m_targetWindow->m_backingPixmap && - (noUnitsX != 0) && (noUnitsY != 0)) +void wxScrollHelper::DeleteEvtHandler() +{ + // search for m_handler in the handler list + if ( m_win && m_handler ) + { + if ( m_win->RemoveEventHandler(m_handler) ) { - int depth = wxDisplayDepth(); - m_pixmapWidth = totalPixelWidth; - m_pixmapHeight = totalPixelHeight; - m_backingPixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)), - m_pixmapWidth, m_pixmapHeight, depth); + delete m_handler; } + //else: something is very wrong, so better [maybe] leak memory than + // risk a crash because of double deletion + m_handler = NULL; } -#endif // Motif +} - AdjustScrollbars(); +void wxScrollHelper::SetWindow(wxWindow *win) +{ + wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") ); - if (do_refresh && !noRefresh) - m_targetWindow->Refresh(TRUE, GetRect()); + m_win = win; -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately() ; -#endif + // by default, the associated window is also the target window + DoSetTargetWindow(win); } -// ---------------------------------------------------------------------------- -// target window handling -// ---------------------------------------------------------------------------- - -void wxScrollHelper::SetTargetWindow( wxWindow *target ) +void wxScrollHelper::DoSetTargetWindow(wxWindow *target) { - wxASSERT_MSG( target, wxT("target window must not be NULL") ); m_targetWindow = target; + + // 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 + // which we scroll - we don't need to hijack its events) + if ( m_targetWindow == m_win ) + { + // if we already have a handler, delete it first + DeleteEvtHandler(); + + m_handler = new wxScrollHelperEvtHandler(this); + m_targetWindow->PushEventHandler(m_handler); + } +} + +void wxScrollHelper::SetTargetWindow(wxWindow *target) +{ + wxCHECK_RET( target, wxT("target window must not be NULL") ); + + if ( target == m_targetWindow ) + return; + + DoSetTargetWindow(target); } wxWindow *wxScrollHelper::GetTargetWindow() const @@ -384,15 +472,15 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) if (orient == wxHORIZONTAL) { m_xScrollPosition += nScrollInc; - m_targetWindow->SetScrollPos(wxHORIZONTAL, m_xScrollPosition, FALSE); + m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition); } else { m_yScrollPosition += nScrollInc; - m_targetWindow->SetScrollPos(wxVERTICAL, m_yScrollPosition, FALSE); + m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition); } - bool needsRefresh = FALSE; + bool needsRefresh = false; int dx = 0, dy = 0; if (orient == wxHORIZONTAL) @@ -403,7 +491,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } else @@ -414,22 +502,18 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } if ( needsRefresh ) { - m_targetWindow->Refresh(TRUE, GetRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } else { - m_targetWindow->ScrollWindow(dx, dy, GetRect()); + m_targetWindow->ScrollWindow(dx, dy, GetScrollRect()); } - -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately() ; -#endif } int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) @@ -487,41 +571,48 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) { if (m_xScrollPixelsPerLine > 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 + if ( m_xScrollPosition + nScrollInc < 0 ) + { + // As -ve as we can go + nScrollInc = -m_xScrollPosition; + } + else // check for the other bound + { + 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()); + m_targetWindow->Refresh(true, GetScrollRect()); } else { - if (m_yScrollPixelsPerLine > 0) + if ( m_yScrollPixelsPerLine > 0 ) { - 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 + if ( m_yScrollPosition + nScrollInc < 0 ) + { + // 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; + } + } } else - m_targetWindow->Refresh(TRUE, GetRect()); + { + // VZ: why do we do this? (FIXME) + m_targetWindow->Refresh(true, GetScrollRect()); + } } return nScrollInc; @@ -530,85 +621,196 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) // Adjust the scrollbars - new version. void wxScrollHelper::AdjustScrollbars() { -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately(); -#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, h; - GetTargetSize(&w, &h); + int w = 0, h = 0; + int oldw, oldh; int oldXScroll = m_xScrollPosition; int oldYScroll = m_yScrollPosition; - if (m_xScrollLines > 0) + // VZ: at least under Windows this loop is useless because when scrollbars + // [dis]appear we get a WM_SIZE resulting in another call to + // AdjustScrollbars() anyhow. As it doesn't seem to do any harm I leave + // it here for now but it would be better to ensure that all ports + // generate EVT_SIZE when scrollbars [dis]appear, emulating it if + // necessary, and remove it later + do { - // 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; + GetTargetSize(&w, 0); - // 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 ); + // scroll lines per page: if 0, no scrolling is needed + int linesPerPage; + + if ( m_xScrollPixelsPerLine == 0 ) + { + // scrolling is disabled + m_xScrollLines = 0; + m_xScrollPosition = 0; + linesPerPage = 0; + } + else // might need scrolling + { + // Round up integer division to catch any "leftover" client space. + const int wVirt = m_targetWindow->GetVirtualSize().GetWidth(); + m_xScrollLines = (wVirt + m_xScrollPixelsPerLine - 1) / m_xScrollPixelsPerLine; + + // Calculate page size i.e. number of scroll units you get on the + // current client window. + linesPerPage = w / m_xScrollPixelsPerLine; + + // Special case. When client and virtual size are very close but + // the client is big enough, kill scrollbar. + if ((linesPerPage < m_xScrollLines) && (w >= wVirt)) ++linesPerPage; + + if (linesPerPage >= m_xScrollLines) + { + // we're big enough to not need scrolling + linesPerPage = + m_xScrollLines = + m_xScrollPosition = 0; + } + else // we do need a scrollbar + { + if ( linesPerPage < 1 ) + linesPerPage = 1; + + // Correct position if greater than extent of canvas minus + // the visible portion of it or if below zero + const int posMax = m_xScrollLines - linesPerPage; + if ( m_xScrollPosition > posMax ) + m_xScrollPosition = posMax; + else if ( m_xScrollPosition < 0 ) + m_xScrollPosition = 0; + } + } + + m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, + linesPerPage, m_xScrollLines); - m_targetWindow->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines); // The amount by which we scroll when paging - SetScrollPageSize(wxHORIZONTAL, noPagePositions); - } - else - { - m_xScrollPosition = 0; - m_targetWindow->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); - } + SetScrollPageSize(wxHORIZONTAL, linesPerPage); - if (m_yScrollLines > 0) - { - // 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; + GetTargetSize(0, &h); - // 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 ( m_yScrollPixelsPerLine == 0 ) + { + // scrolling is disabled + m_yScrollLines = 0; + m_yScrollPosition = 0; + linesPerPage = 0; + } + else // might need scrolling + { + // Round up integer division to catch any "leftover" client space. + const int hVirt = m_targetWindow->GetVirtualSize().GetHeight(); + m_yScrollLines = ( hVirt + m_yScrollPixelsPerLine - 1 ) / m_yScrollPixelsPerLine; + + // Calculate page size i.e. number of scroll units you get on the + // current client window. + linesPerPage = h / m_yScrollPixelsPerLine; + + // Special case. When client and virtual size are very close but + // the client is big enough, kill scrollbar. + if ((linesPerPage < m_yScrollLines) && (h >= hVirt)) ++linesPerPage; + + if (linesPerPage >= m_yScrollLines) + { + // we're big enough to not need scrolling + linesPerPage = + m_yScrollLines = + m_yScrollPosition = 0; + } + else // we do need a scrollbar + { + if ( linesPerPage < 1 ) + linesPerPage = 1; + + // Correct position if greater than extent of canvas minus + // the visible portion of it or if below zero + const int posMax = m_yScrollLines - linesPerPage; + if ( m_yScrollPosition > posMax ) + m_yScrollPosition = posMax; + else if ( m_yScrollPosition < 0 ) + m_yScrollPosition = 0; + } + } + + m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition, + linesPerPage, m_yScrollLines); - m_targetWindow->SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines); // The amount by which we scroll when paging - SetScrollPageSize(wxVERTICAL, noPagePositions); - } - else + SetScrollPageSize(wxVERTICAL, linesPerPage); + + + // If a scrollbar (dis)appeared as a result of this, adjust them again. + oldw = w; + oldh = h; + + GetTargetSize( &w, &h ); + } while ( w != oldw || h != oldh ); + +#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 ) { - m_yScrollPosition = 0; - m_targetWindow->SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE); + 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, - GetRect() ); + m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0, + GetScrollRect() ); else - m_targetWindow->Refresh(TRUE, GetRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } if (oldYScroll != m_yScrollPosition) { if (m_yScrollingEnabled) m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), - GetRect() ); + GetScrollRect() ); else - m_targetWindow->Refresh(TRUE, GetRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } - -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately(); -#endif } void wxScrollHelper::DoPrepareDC(wxDC& dc) @@ -619,6 +821,24 @@ void wxScrollHelper::DoPrepareDC(wxDC& dc) dc.SetUserScale( m_scaleX, m_scaleY ); } +void wxScrollHelper::SetScrollRate( int xstep, int ystep ) +{ + int old_x = m_xScrollPixelsPerLine * m_xScrollPosition; + int old_y = m_yScrollPixelsPerLine * m_yScrollPosition; + + m_xScrollPixelsPerLine = xstep; + m_yScrollPixelsPerLine = ystep; + + int new_x = m_xScrollPixelsPerLine * m_xScrollPosition; + int new_y = m_yScrollPixelsPerLine * m_yScrollPosition; + + m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition ); + m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition ); + m_targetWindow->ScrollWindow( old_x - new_x, old_y - new_y ); + + AdjustScrollbars(); +} + void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const { if ( x_unit ) @@ -654,10 +874,6 @@ 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->MacUpdateImmediately(); -#endif - int w, h; GetTargetSize(&w, &h); @@ -677,9 +893,9 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos ) m_xScrollPosition = wxMax( 0, m_xScrollPosition ); if (old_x != m_xScrollPosition) { - m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, FALSE ); + m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition ); m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0, - GetRect() ); + GetScrollRect() ); } } if ((y_pos != -1) && (m_yScrollPixelsPerLine)) @@ -698,16 +914,11 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos ) m_yScrollPosition = wxMax( 0, m_yScrollPosition ); if (old_y != m_yScrollPosition) { - m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, FALSE ); + m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition ); m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine, - GetRect() ); + GetScrollRect() ); } } - -#ifdef __WXMAC__ - m_targetWindow->MacUpdateImmediately(); -#endif - } void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll) @@ -716,14 +927,6 @@ void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll) m_yScrollingEnabled = y_scroll; } -void wxScrollHelper::GetVirtualSize (int *x, int *y) const -{ - if ( x ) - *x = m_xScrollPixelsPerLine * m_xScrollLines; - if ( y ) - *y = m_yScrollPixelsPerLine * m_yScrollLines; -} - // Where the current view starts from void wxScrollHelper::GetViewStart (int *x, int *y) const { @@ -733,7 +936,16 @@ void wxScrollHelper::GetViewStart (int *x, int *y) const *y = m_yScrollPosition; } -void wxScrollHelper::CalcScrolledPosition(int x, int y, int *xx, int *yy) const +#if WXWIN_COMPATIBILITY_2_2 + +void wxScrollHelper::ViewStart(int *x, int *y) const +{ + GetViewStart( x, y ); +} + +#endif // WXWIN_COMPATIBILITY_2_2 + +void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const { if ( xx ) *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine; @@ -741,7 +953,7 @@ void wxScrollHelper::CalcScrolledPosition(int x, int y, int *xx, int *yy) const *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine; } -void wxScrollHelper::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const +void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const { if ( xx ) *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine; @@ -756,19 +968,25 @@ void wxScrollHelper::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) cons // Default OnSize resets scrollbars, if any void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) { -#if wxUSE_CONSTRAINTS if ( m_targetWindow->GetAutoLayout() ) - m_targetWindow->Layout(); -#endif - - AdjustScrollbars(); + { + 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)) { - wxPaintDC dc(m_targetWindow); + // don't use m_targetWindow here, this is always called for ourselves + wxPaintDC dc(m_win); DoPrepareDC(dc); OnDraw(dc); @@ -786,7 +1004,7 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event) GetViewStart(&stx, &sty); GetTargetSize(&clix, &cliy); - GetVirtualSize(&szx, &szy); + m_targetWindow->GetVirtualSize(&szx, &szy); if( m_xScrollPixelsPerLine ) { @@ -813,7 +1031,7 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event) yScrollOld = m_yScrollPosition; int dsty; - switch ( event.KeyCode() ) + switch ( event.GetKeyCode() ) { case WXK_PAGEUP: case WXK_PRIOR: @@ -886,11 +1104,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) @@ -952,6 +1172,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) if ( !m_targetWindow->HasScrollbar(orient) ) return; +#if wxUSE_TIMER delete m_timerAutoScroll; m_timerAutoScroll = new wxAutoScrollTimer ( @@ -962,6 +1183,9 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) orient ); m_timerAutoScroll->Start(50); // FIXME: make configurable +#else + wxUnusedVar(pos); +#endif } } @@ -975,11 +1199,34 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) if (lines != 0) { - lines *= event.GetLinesPerAction(); - int vsx, vsy; - GetViewStart(&vsx, &vsy); - Scroll(-1, vsy - lines); + wxScrollWinEvent newEvent; + + newEvent.SetPosition(0); + newEvent.SetOrientation(wxVERTICAL); + newEvent.SetEventObject(m_win); + + if (event.IsPageScroll()) + { + if (lines > 0) + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP); + else + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN); + + m_win->GetEventHandler()->ProcessEvent(newEvent); + } + else + { + lines *= event.GetLinesPerAction(); + if (lines > 0) + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP); + else + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN); + + int times = abs(lines); + for (; times > 0; times--) + m_win->GetEventHandler()->ProcessEvent(newEvent); + } } } @@ -991,6 +1238,10 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel) +BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel) + EVT_PAINT(wxGenericScrolledWindow::OnPaint) +END_EVENT_TABLE() + bool wxGenericScrolledWindow::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, @@ -1000,12 +1251,7 @@ bool wxGenericScrolledWindow::Create(wxWindow *parent, { m_targetWindow = this; - bool ok = wxPanel::Create(parent, id, pos, size, style, name); - -#ifdef __WXMSW__ - // we need to process arrows ourselves for scrolling - m_lDlgCode |= DLGC_WANTARROWS; -#endif // __WXMSW__ + bool ok = wxPanel::Create(parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name); return ok; } @@ -1014,21 +1260,117 @@ wxGenericScrolledWindow::~wxGenericScrolledWindow() { } -#if WXWIN_COMPATIBILITY -void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const +bool wxGenericScrolledWindow::Layout() { - *x_page = GetScrollPageSize(wxHORIZONTAL); - *y_page = GetScrollPageSize(wxVERTICAL); + 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::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const +void wxGenericScrolledWindow::DoSetVirtualSize(int x, int y) { - if ( xx ) - *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine); - if ( yy ) - *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine); + wxPanel::DoSetVirtualSize( x, y ); + AdjustScrollbars(); + + if (GetAutoLayout()) + Layout(); } -#endif // WXWIN_COMPATIBILITY + +// wxWindow's GetBestVirtualSize returns the actual window size, +// whereas we want to return the virtual size +wxSize wxGenericScrolledWindow::GetBestVirtualSize() const +{ + wxSize clientSize( GetClientSize() ); + if (GetSizer()) + { + wxSize minSize( GetSizer()->CalcMin() ); + + return wxSize( wxMax( clientSize.x, minSize.x ), wxMax( clientSize.y, minSize.y ) ); + } + else + return clientSize; +} + +// return the size best suited for the current window +// (this isn't a virtual size, this is a sensible size for the window) +wxSize wxGenericScrolledWindow::DoGetBestSize() const +{ + wxSize best; + + if ( GetSizer() ) + { + wxSize b = GetSizer()->GetMinSize(); + + // 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; + if ( GetMinSize().IsFullySpecified() ) + minSize = GetMinSize(); + else + minSize = GetSize(); + + if (ppuX > 0) + b.x = minSize.x; + if (ppuY > 0) + b.y = minSize.y; + best = b; + } + else + return wxWindow::DoGetBestSize(); + + // Add any difference between size and client size + wxSize diff = GetSize() - GetClientSize(); + best.x += wxMax(0, diff.x); + best.y += wxMax(0, diff.y); + + return best; +} + +void wxGenericScrolledWindow::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 + m_handler->ResetDrawnFlag(); + + event.Skip(); +} + +#ifdef __WXMSW__ +WXLRESULT +wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg, + WXWPARAM wParam, + WXLPARAM 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__ #endif // !wxGTK +// vi:sts=4:sw=4:et