X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c4513b23896c274eb859e0856d7e391b04f77819..4e15d1caa03346c126015019c1fdf093033ef40b:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index bf9a58d3fa..200608475c 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,14 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "genscrolwin.h" -#endif - -#ifdef __VMS -#define XtDisplay XTDISPLAY -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -33,20 +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" -#if wxUSE_TIMER -#include "wx/timer.h" +#ifdef __WXMAC__ +#include "wx/scrolbar.h" #endif -#include "wx/sizer.h" + +#include "wx/recguard.h" #ifdef __WXMSW__ #include // for DLGC_WANTARROWS + #include "wx/msw/winundef.h" #endif #ifdef __WXMOTIF__ @@ -61,11 +59,9 @@ #endif #endif -IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) - /* - TODO PROPERTIES - style wxHSCROLL | wxVSCROLL + TODO PROPERTIES + style wxHSCROLL | wxVSCROLL */ // ---------------------------------------------------------------------------- @@ -76,21 +72,17 @@ 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; } - private: - wxScrollHelper *m_scrollHelper; + wxScrollHelperBase *m_scrollHelper; - bool m_hasDrawnWindow; - - DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler) + wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler); }; #if wxUSE_TIMER @@ -102,7 +94,8 @@ private: class wxAutoScrollTimer : public wxTimer { public: - wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll, + wxAutoScrollTimer(wxWindow *winToScroll, + wxScrollHelperBase *scroll, wxEventType eventTypeToSend, int pos, int orient); @@ -110,12 +103,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); }; // ============================================================================ @@ -127,7 +120,7 @@ private: // ---------------------------------------------------------------------------- wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll, - wxScrollHelper *scroll, + wxScrollHelperBase *scroll, wxEventType eventTypeToSend, int pos, int orient) { @@ -150,12 +143,13 @@ void wxAutoScrollTimer::Notify() // first scroll the window if we are allowed to do it wxScrollWinEvent event1(m_eventType, m_pos, m_orient); event1.SetEventObject(m_win); + event1.SetId(m_win->GetId()); if ( m_scrollHelper->SendAutoScrollEvents(event1) && m_win->GetEventHandler()->ProcessEvent(event1) ) { // and then send a pseudo mouse-move event to refresh the selection wxMouseEvent event2(wxEVT_MOTION); - wxGetMousePosition(&event2.m_x, &event2.m_y); + event2.SetPosition(wxGetMousePosition()); // the mouse event coordinates should be client, not screen as // returned by wxGetMousePosition @@ -188,26 +182,13 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) { wxEventType evType = event.GetEventType(); - // the explanation of wxEVT_PAINT processing hack: for historic reasons - // there are 2 ways to process this event in classes deriving from - // wxScrolledWindow. The user code may - // - // 1. override wxScrolledWindow::OnDraw(dc) - // 2. define its own OnPaint() handler - // - // In addition, in wxUniversal wxWindow defines OnPaint() itself and - // always processes the draw event, so we can't just try the window - // OnPaint() first and call our HandleOnPaint() if it doesn't process it - // (the latter would never be called in wxUniversal). - // - // So the solution is to have a flag telling us whether the user code drew - // anything in the window. We set it to true here but reset it to false in - // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the - // user code defined OnPaint() in the derived class) - m_hasDrawnWindow = TRUE; - - // pass it on to the real handler - bool processed = wxEvtHandler::ProcessEvent(event); + // Pass it on to the real handler: notice that we must not call + // ProcessEvent() on this object itself as it wouldn't pass it to the next + // handler (i.e. the real window) if we're called from a previous handler + // (as indicated by "process here only" flag being set) and we do want to + // execute the handler defined in the window we're associated with right + // now, without waiting until TryAfter() is called from wxEvtHandler. + bool processed = m_nextHandler->ProcessEvent(event); // always process the size events ourselves, even if the user code handles // them as well, as we need to AdjustScrollbars() @@ -219,31 +200,42 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) if ( evType == wxEVT_SIZE ) { m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - - return TRUE; + return true; } - if ( processed ) + if ( processed && event.IsCommandEvent()) + return true; + + // For wxEVT_PAINT the user code can either handle this event as usual or + // override virtual OnDraw(), so if the event hasn't been handled we need + // to call this virtual function ourselves. + if ( +#ifndef __WXUNIVERSAL__ + // in wxUniversal "processed" will always be true, because + // all windows use the paint event to draw themselves. + // In this case we can't use this flag to determine if a custom + // paint event handler already drew our window and we just + // call OnDraw() anyway. + !processed && +#endif // !__WXUNIVERSAL__ + evType == wxEVT_PAINT ) { - // 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; - } + m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); + 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 ) + if ( evType == wxEVT_CHILD_FOCUS ) { - m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); - return TRUE; + 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 || @@ -253,8 +245,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 ) @@ -266,26 +266,53 @@ 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; + event.Skip(wasSkipped); + + // We called ProcessEvent() on the next handler, meaning that we explicitly + // worked around the request to process the event in this handler only. As + // explained above, this is unfortunately really necessary but the trouble + // is that the event will continue to be post-processed by the previous + // handler resulting in duplicate calls to event handlers. Call the special + // function below to prevent this from happening, base class DoTryChain() + // will check for it and behave accordingly. + // + // And if we're not called from DoTryChain(), this won't do anything anyhow. + event.DidntHonourProcessOnlyIn(); + + return processed; } +// ============================================================================ +// wxScrollHelperBase implementation +// ============================================================================ + // ---------------------------------------------------------------------------- -// wxScrollHelper construction +// wxScrollHelperBase construction // ---------------------------------------------------------------------------- -wxScrollHelper::wxScrollHelper(wxWindow *win) +wxScrollHelperBase::wxScrollHelperBase(wxWindow *win) { + wxASSERT_MSG( win, wxT("associated window can't be NULL in wxScrollHelper") ); + m_xScrollPixelsPerLine = m_yScrollPixelsPerLine = m_xScrollPosition = @@ -296,7 +323,9 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_yScrollLinesPerPage = 0; m_xScrollingEnabled = - m_yScrollingEnabled = TRUE; + m_yScrollingEnabled = true; + + m_kbdScrollingEnabled = true; m_scaleX = m_scaleY = 1.0; @@ -305,17 +334,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(); @@ -326,24 +359,25 @@ 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; + // Convert positions expressed in scroll units to positions in pixels. + int xPosInPixels = (xPos + m_xScrollPosition)*m_xScrollPixelsPerLine, + yPosInPixels = (yPos + m_yScrollPosition)*m_yScrollPixelsPerLine; - CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos); bool do_refresh = ( (noUnitsX != 0 && m_xScrollLines == 0) || - (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX * noUnitsX) || + (noUnitsX < m_xScrollLines && xPosInPixels > pixelsPerUnitX * noUnitsX) || (noUnitsY != 0 && m_yScrollLines == 0) || - (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY * noUnitsY) || + (noUnitsY < m_yScrollLines && yPosInPixels > pixelsPerUnitY * noUnitsY) || (xPos != m_xScrollPosition) || (yPos != m_yScrollPosition) ); @@ -359,15 +393,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, @@ -382,9 +419,6 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, else { // otherwise this has been done by AdjustScrollbars, above -#ifdef __WXMAC__ - m_targetWindow->Update() ; -#endif } #endif // !__WXUNIVERSAL__ } @@ -393,7 +427,7 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, // [target] window handling // ---------------------------------------------------------------------------- -void wxScrollHelper::DeleteEvtHandler() +void wxScrollHelperBase::DeleteEvtHandler() { // search for m_handler in the handler list if ( m_win && m_handler ) @@ -409,19 +443,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) +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 @@ -436,7 +463,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") ); @@ -446,7 +473,7 @@ void wxScrollHelper::SetTargetWindow(wxWindow *target) DoSetTargetWindow(target); } -wxWindow *wxScrollHelper::GetTargetWindow() const +wxWindow *wxScrollHelperBase::GetTargetWindow() const { return m_targetWindow; } @@ -455,7 +482,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 ) @@ -466,21 +493,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 ) @@ -489,7 +505,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } else @@ -500,25 +516,45 @@ 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) +int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event) { int pos = event.GetPosition(); int orient = event.GetOrientation(); @@ -571,224 +607,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, 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 - { - // VZ: why do we do this? (FIXME) - m_targetWindow->Refresh(TRUE, GetScrollRect()); - } } - - return nScrollInc; -} - -// Adjust the scrollbars - new version. -void wxScrollHelper::AdjustScrollbars() -{ -#ifdef __WXMAC__ - m_targetWindow->Update(); -#endif - - int w = 0, h = 0; - int oldw, oldh; - - int oldXScroll = m_xScrollPosition; - int oldYScroll = m_yScrollPosition; - - // 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 + else // wxVERTICAL { - 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); - - // scroll lines per page: if 0, no scrolling is needed - int linesPerPage; - - if ( m_yScrollPixelsPerLine == 0 ) + if ( m_yScrollPosition + nScrollInc < 0 ) { - // scrolling is disabled - m_yScrollLines = 0; - m_yScrollPosition = 0; - linesPerPage = 0; + // As -ve as we can go + nScrollInc = -m_yScrollPosition; } - else // might need scrolling + else // check for the other bound { - int hVirt = m_targetWindow->GetVirtualSize().GetHeight(); - m_yScrollLines = hVirt / m_yScrollPixelsPerLine; - - // Calculate page size i.e. number of scroll units you get on the - // current client window - linesPerPage = h / m_yScrollPixelsPerLine; - if ( linesPerPage >= m_yScrollLines ) - { - // we're big enough to not need scrolling - linesPerPage = - m_yScrollLines = - m_yScrollPosition = 0; - } - else // we do need a scrollbar + const int posMax = m_yScrollLines - m_yScrollLinesPerPage; + if ( m_yScrollPosition + nScrollInc > posMax ) { - 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; + // As +ve as we can go + nScrollInc = posMax - m_yScrollPosition; } } - - m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition, - linesPerPage, m_yScrollLines); - - // The amount by which we scroll when paging - 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 ) - { - 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 __WXMAC__ - m_targetWindow->Update(); -#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; @@ -806,7 +678,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; @@ -814,7 +686,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; @@ -822,7 +703,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; @@ -830,81 +711,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->Update(); -#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, - GetScrollRect() ); - } - } - 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, - GetScrollRect() ); - } - } - -#ifdef __WXMAC__ - m_targetWindow->Update(); -#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; @@ -912,7 +726,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; @@ -920,7 +735,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; @@ -929,33 +745,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() || m_targetWindow->GetAutoLayout() ) + if ( m_win->GetSizer() && m_targetWindow == m_win ) { - if ( m_targetWindow != m_win ) - m_targetWindow->FitInside(); - - m_win->FitInside(); + // If we're the scroll target, take into account the + // virtual size and scrolled position of the window. - // 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(); + 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 wxScrollHelperBase::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 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(); } - 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); @@ -968,97 +821,79 @@ 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) - - GetViewStart(&stx, &sty); - GetTargetSize(&clix, &cliy); - m_targetWindow->GetVirtualSize(&szx, &szy); - - if( m_xScrollPixelsPerLine ) - { - clix /= m_xScrollPixelsPerLine; - szx /= m_xScrollPixelsPerLine; - } - else - { - clix = 0; - szx = -1; - } - if( m_yScrollPixelsPerLine ) - { - cliy /= m_yScrollPixelsPerLine; - szy /= m_yScrollPixelsPerLine; - } - else + if ( !m_kbdScrollingEnabled ) { - cliy = 0; - szy = -1; + event.Skip(); + return; } - int xScrollOld = m_xScrollPosition, - yScrollOld = m_yScrollPosition; + // prepare the event this key press maps to + wxScrollWinEvent newEvent; + + newEvent.SetPosition(0); + newEvent.SetEventObject(m_win); + newEvent.SetId(m_win->GetId()); + + // this is the default, it's changed to wxHORIZONTAL below if needed + newEvent.SetOrientation(wxVERTICAL); + + // some key events result in scrolling in both horizontal and vertical + // direction, e.g. Ctrl-{Home,End}, if this flag is true we should generate + // a second event in horizontal direction in addition to the primary one + bool sendHorizontalToo = false; - int dsty; switch ( event.GetKeyCode() ) { case WXK_PAGEUP: - case WXK_PRIOR: - dsty = sty - (5 * cliy / 6); - Scroll(-1, (dsty == -1) ? 0 : dsty); + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP); break; case WXK_PAGEDOWN: - case WXK_NEXT: - Scroll(-1, sty + (5 * cliy / 6)); + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN); break; case WXK_HOME: - Scroll(0, event.ControlDown() ? 0 : -1); - break; + newEvent.SetEventType(wxEVT_SCROLLWIN_TOP); - case WXK_END: - Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1); + sendHorizontalToo = event.ControlDown(); break; - case WXK_UP: - Scroll(-1, sty - 1); - break; + case WXK_END: + newEvent.SetEventType(wxEVT_SCROLLWIN_BOTTOM); - case WXK_DOWN: - Scroll(-1, sty + 1); + sendHorizontalToo = event.ControlDown(); break; case WXK_LEFT: - Scroll(stx - 1, -1); + newEvent.SetOrientation(wxHORIZONTAL); + // fall through + + case WXK_UP: + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP); break; case WXK_RIGHT: - Scroll(stx + 1, -1); + newEvent.SetOrientation(wxHORIZONTAL); + // fall through + + case WXK_DOWN: + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN); break; default: - // not for us + // not a scrolling key event.Skip(); + return; } - if ( m_xScrollPosition != xScrollOld ) - { - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition, - wxHORIZONTAL); - event.SetEventObject(m_win); - m_win->GetEventHandler()->ProcessEvent(event); - } + m_win->ProcessWindowEvent(newEvent); - if ( m_yScrollPosition != yScrollOld ) + if ( sendHorizontalToo ) { - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition, - wxVERTICAL); - event.SetEventObject(m_win); - m_win->GetEventHandler()->ProcessEvent(event); + newEvent.SetOrientation(wxHORIZONTAL); + m_win->ProcessWindowEvent(newEvent); } } @@ -1067,32 +902,28 @@ 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; - } + wxDELETE(m_timerAutoScroll); #endif } -void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event) +void wxScrollHelperBase::HandleOnMouseEnter(wxMouseEvent& event) { StopAutoScrolling(); event.Skip(); } -void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) +void wxScrollHelperBase::HandleOnMouseLeave(wxMouseEvent& event) { // don't prevent the usual processing of the event from taking place event.Skip(); @@ -1133,7 +964,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) // but seems to happen sometimes under wxMSW - maybe it's a bug // there but for now just ignore it - //wxFAIL_MSG( _T("can't understand where has mouse gone") ); + //wxFAIL_MSG( wxT("can't understand where has mouse gone") ); return; } @@ -1155,13 +986,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(); @@ -1173,15 +1006,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); } @@ -1189,9 +1022,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--) @@ -1202,111 +1035,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 -bool wxGenericScrolledWindow::Create(wxWindow *parent, - wxWindowID id, - const wxPoint& pos, - const wxSize& size, - long style, - const wxString& name) -{ - m_targetWindow = this; +#if defined( __WXOSX__ ) && wxUSE_SCROLLBAR + 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 too big to fit inside the + // scrolled window. If that is the case, then make only the focused window + // visible + if ( win->GetParent() != m_targetWindow) + { + 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; + } + + + // do make the window fit inside the view area by scrolling to it + int stepx, stepy; + GetScrollPixelsPerUnit(&stepx, &stepy); + + 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; + } - bool ok = wxPanel::Create(parent, id, pos, size, style, name); + starty = (starty * stepy + diff) / stepy; + } - return ok; + // 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; -#ifndef __WXWINCE__ - // 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 ); } -#endif + 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)