X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c0badb709a86b91a203416784b649e3d00c699c7..8a28cd66a63ce30c75173e10948e9d49d366d218:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index e2aced4a81..921c5961ca 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -18,10 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __VMS -#define XtDisplay XTDISPLAY -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -35,12 +31,15 @@ #include "wx/utils.h" #include "wx/panel.h" #include "wx/dcclient.h" - #if wxUSE_TIMER - #include "wx/timer.h" - #endif + #include "wx/timer.h" + #include "wx/sizer.h" + #include "wx/settings.h" +#endif + +#ifdef __WXMAC__ +#include "wx/scrolbar.h" #endif -#include "wx/sizer.h" #include "wx/recguard.h" #ifdef __WXMSW__ @@ -73,21 +72,17 @@ 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 @@ -99,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); @@ -107,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); }; // ============================================================================ @@ -124,7 +120,7 @@ private: // ---------------------------------------------------------------------------- wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll, - wxScrollHelper *scroll, + wxScrollHelperBase *scroll, wxEventType eventTypeToSend, int pos, int orient) { @@ -147,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 @@ -165,7 +162,16 @@ void wxAutoScrollTimer::Notify() event2.SetEventObject(m_win); - // FIXME: we don't fill in the other members - ok? + wxMouseState mouseState = wxGetMouseState(); + + event2.m_leftDown = mouseState.LeftIsDown(); + event2.m_middleDown = mouseState.MiddleIsDown(); + event2.m_rightDown = mouseState.RightIsDown(); + + event2.m_shiftDown = mouseState.ShiftDown(); + event2.m_controlDown = mouseState.ControlDown(); + event2.m_altDown = mouseState.AltDown(); + event2.m_metaDown = mouseState.MetaDown(); m_win->GetEventHandler()->ProcessEvent(event2); } @@ -185,26 +191,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() @@ -216,31 +209,42 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) if ( evType == wxEVT_SIZE ) { m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - 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 || event.IsCommandEvent() ) - { - 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); + 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 || @@ -250,8 +254,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 ) @@ -263,27 +275,52 @@ 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, _T("associated window can't be NULL in wxScrollHelper") ); + wxASSERT_MSG( win, wxT("associated window can't be NULL in wxScrollHelper") ); m_xScrollPixelsPerLine = m_yScrollPixelsPerLine = @@ -297,6 +334,8 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_xScrollingEnabled = m_yScrollingEnabled = true; + m_kbdScrollingEnabled = true; + m_scaleX = m_scaleY = 1.0; #if wxUSE_MOUSEWHEEL @@ -304,19 +343,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; 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(); @@ -327,24 +368,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) ); @@ -394,7 +436,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 ) @@ -410,7 +452,7 @@ void wxScrollHelper::DeleteEvtHandler() } } -void wxScrollHelper::DoSetTargetWindow(wxWindow *target) +void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target) { m_targetWindow = target; #ifdef __WXMAC__ @@ -430,7 +472,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") ); @@ -440,7 +482,7 @@ void wxScrollHelper::SetTargetWindow(wxWindow *target) DoSetTargetWindow(target); } -wxWindow *wxScrollHelper::GetTargetWindow() const +wxWindow *wxScrollHelperBase::GetTargetWindow() const { return m_targetWindow; } @@ -449,7 +491,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 ) @@ -460,21 +502,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; int dx = 0, dy = 0; + int orient = event.GetOrientation(); if (orient == wxHORIZONTAL) { if ( m_xScrollingEnabled ) @@ -498,6 +529,30 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } } + 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()); @@ -508,7 +563,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } } -int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) +int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event) { int pos = event.GetPosition(); int orient = event.GetOrientation(); @@ -561,264 +616,60 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) if (orient == wxHORIZONTAL) { - if (m_xScrollPixelsPerLine > 0) + if ( m_xScrollPosition + nScrollInc < 0 ) { - 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; - } - } + // 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() -{ - 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; - - 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 - // JACS: Stop potential infinite loop by limiting number of iterations - int iterationCount = 0; - const int iterationMax = 5; - do + else // wxVERTICAL { - iterationCount ++; - - GetTargetSize(&w, 0); - - // scroll lines per page: if 0, no scrolling is needed - int linesPerPage; - - if ( m_xScrollPixelsPerLine == 0 ) + if ( m_yScrollPosition + nScrollInc < 0 ) { - // scrolling is disabled - m_xScrollLines = 0; - m_xScrollPosition = 0; - linesPerPage = 0; + // As -ve as we can go + nScrollInc = -m_yScrollPosition; } - else // might need scrolling + else // check for the other bound { - // 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) + const int posMax = m_yScrollLines - m_yScrollLinesPerPage; + if ( m_yScrollPosition + nScrollInc > posMax ) { - // we're big enough to not need scrolling - linesPerPage = - m_xScrollLines = - m_xScrollPosition = 0; + // As +ve as we can go + nScrollInc = posMax - m_yScrollPosition; } - 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); - - // The amount by which we scroll when paging - SetScrollPageSize(wxHORIZONTAL, linesPerPage); - - GetTargetSize(0, &h); - - 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); - - // 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) && (iterationCount < iterationMax) ); - -#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()); - } + 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; @@ -836,7 +687,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; @@ -844,7 +695,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; @@ -852,7 +712,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; @@ -860,72 +720,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; - - int w = 0, h = 0; - 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() ); - } - } -} - -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; @@ -933,7 +735,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; @@ -941,7 +744,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; @@ -953,7 +757,7 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co // geometry // ---------------------------------------------------------------------------- -bool wxScrollHelper::ScrollLayout() +bool wxScrollHelperBase::ScrollLayout() { if ( m_win->GetSizer() && m_targetWindow == m_win ) { @@ -971,7 +775,7 @@ bool wxScrollHelper::ScrollLayout() return m_win->wxWindow::Layout(); } -void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y) +void wxScrollHelperBase::ScrollDoSetVirtualSize(int x, int y) { m_win->wxWindow::DoSetVirtualSize( x, y ); AdjustScrollbars(); @@ -982,7 +786,7 @@ void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y) // wxWindow's GetBestVirtualSize returns the actual window size, // whereas we want to return the virtual size -wxSize wxScrollHelper::ScrollGetBestVirtualSize() const +wxSize wxScrollHelperBase::ScrollGetBestVirtualSize() const { wxSize clientSize(m_win->GetClientSize()); if ( m_win->GetSizer() ) @@ -991,35 +795,12 @@ wxSize wxScrollHelper::ScrollGetBestVirtualSize() const 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 // ---------------------------------------------------------------------------- // Default OnSize resets scrollbars, if any -void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) +void wxScrollHelperBase::HandleOnSize(wxSizeEvent& WXUNUSED(event)) { if ( m_targetWindow->GetAutoLayout() ) { @@ -1036,7 +817,7 @@ void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) // 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); @@ -1049,95 +830,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 = 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); - m_targetWindow->GetVirtualSize(&szx, &szy); - - if( m_xScrollPixelsPerLine ) - { - clix /= m_xScrollPixelsPerLine; - szx /= m_xScrollPixelsPerLine; - } - else - { - clix = 0; - szx = -1; - } - if( m_yScrollPixelsPerLine ) + if ( !m_kbdScrollingEnabled ) { - cliy /= m_yScrollPixelsPerLine; - szy /= m_yScrollPixelsPerLine; - } - else - { - 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: - dsty = sty - (5 * cliy / 6); - Scroll(-1, (dsty == -1) ? 0 : dsty); + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP); break; case WXK_PAGEDOWN: - Scroll(-1, sty + (5 * cliy / 6)); + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN); break; case WXK_HOME: - Scroll(0, event.ControlDown() ? 0 : -1); - break; + newEvent.SetEventType(wxEVT_SCROLLWIN_TOP); - case WXK_END: - Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1); + sendHorizontalToo = event.ControlDown(); break; - case WXK_UP: - Scroll(-1, sty - 1); - break; + case WXK_END: + newEvent.SetEventType(wxEVT_SCROLLWIN_BOTTOM); - case WXK_DOWN: - Scroll(-1, sty + 1); + sendHorizontalToo = event.ControlDown(); break; case WXK_LEFT: - Scroll(stx - 1, -1); + newEvent.SetOrientation(wxHORIZONTAL); + // fall through + + case WXK_UP: + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP); break; case WXK_RIGHT: - Scroll(stx + 1, -1); + newEvent.SetOrientation(wxHORIZONTAL); + // fall through + + case WXK_DOWN: + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN); break; default: - // not for us + // not a scrolling key event.Skip(); + return; } - if ( m_xScrollPosition != xScrollOld ) - { - wxScrollWinEvent 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); } } @@ -1146,32 +911,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(); @@ -1212,7 +973,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; } @@ -1242,7 +1003,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) #if wxUSE_MOUSEWHEEL -void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) +void wxScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event) { m_wheelRotation += event.GetWheelRotation(); int lines = m_wheelRotation / event.GetWheelDelta(); @@ -1254,7 +1015,7 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) wxScrollWinEvent newEvent; newEvent.SetPosition(0); - newEvent.SetOrientation(wxVERTICAL); + newEvent.SetOrientation( event.GetWheelAxis() == 0 ? wxVERTICAL : wxHORIZONTAL); newEvent.SetEventObject(m_win); if (event.IsPageScroll()) @@ -1283,53 +1044,500 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) #endif // wxUSE_MOUSEWHEEL +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(); + + // find the immediate child under which the window receiving focus is: + wxWindow *win = event.GetWindow(); + + if ( win == m_targetWindow ) + return; // nothing to do + +#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; + } + + starty = (starty * stepy + diff) / stepy; + } + + // then horizontal: + if ( stepx > 0 ) + { + int diff = 0; + + if ( winRect.GetLeft() < 0 ) + { + diff = winRect.GetLeft(); + } + else if ( winRect.GetRight() > viewRect.GetWidth() ) + { + diff = winRect.GetRight() - viewRect.GetWidth() + 1; + // round up to next scroll step if we can't get exact position, + // so that the window is fully visible: + diff += stepx - 1; + } + + startx = (startx * stepx + diff) / stepx; + } + + Scroll(startx, starty); +} + + +#ifdef wxHAS_GENERIC_SCROLLWIN + // ---------------------------------------------------------------------------- -// wxScrolledWindow implementation +// wxScrollHelper implementation // ---------------------------------------------------------------------------- -IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel) +wxScrollHelper::wxScrollHelper(wxWindow *winToScroll) + : wxScrollHelperBase(winToScroll) +{ + m_xVisibility = + m_yVisibility = wxSHOW_SB_DEFAULT; +} + +void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz, + wxScrollbarVisibility vert) +{ + if ( horz != m_xVisibility || vert != m_yVisibility ) + { + m_xVisibility = horz; + m_yVisibility = vert; -BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel) - EVT_PAINT(wxScrolledWindow::OnPaint) -END_EVENT_TABLE() + AdjustScrollbars(); + } +} -bool wxScrolledWindow::Create(wxWindow *parent, - wxWindowID id, - const wxPoint& pos, - const wxSize& size, - long style, - const wxString& name) +void +wxScrollHelper::DoAdjustScrollbar(int orient, + int clientSize, + int virtSize, + int pixelsPerUnit, + int& scrollUnits, + int& scrollPosition, + int& scrollLinesPerPage, + wxScrollbarVisibility visibility) { - m_targetWindow = this; -#ifdef __WXMAC__ - MacSetClipChildren( true ) ; -#endif + // 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; - bool ok = wxPanel::Create(parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name); + // Calculate the number of fully scroll units + scrollLinesPerPage = clientSize / pixelsPerUnit; - return ok; + 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); } -wxScrolledWindow::~wxScrolledWindow() +void wxScrollHelper::AdjustScrollbars() { + static wxRecursionGuardFlag s_flagReentrancy; + wxRecursionGuard guard(s_flagReentrancy); + if ( guard.IsInside() ) + { + // don't reenter AdjustScrollbars() while another call to + // AdjustScrollbars() is in progress because this may lead to calling + // ScrollWindow() twice and this can really happen under MSW if + // SetScrollbar() call below adds or removes the scrollbar which + // changes the window size and hence results in another + // AdjustScrollbars() call + return; + } + + int oldXScroll = m_xScrollPosition; + int oldYScroll = m_yScrollPosition; + + // we may need to readjust the scrollbars several times as enabling one of + // them reduces the area available for the window contents and so can make + // the other scrollbar necessary now although it wasn't necessary before + // + // VZ: normally this loop should be over in at most 2 iterations, I don't + // know why do we need 5 of them + for ( int iterationCount = 0; iterationCount < 5; iterationCount++ ) + { + wxSize clientSize = GetTargetSize(); + const wxSize virtSize = m_targetWindow->GetVirtualSize(); + + // this block of code tries to work around the following problem: the + // window could have been just resized to have enough space to show its + // full contents without the scrollbars, but its client size could be + // not big enough because it does have the scrollbars right now and so + // the scrollbars would remain even though we don't need them any more + // + // to prevent this from happening, check if we have enough space for + // everything without the scrollbars and explicitly disable them then + const wxSize availSize = GetSizeAvailableForScrollTarget( + m_win->GetSize() - m_win->GetWindowBorderSize()); + if ( availSize != clientSize ) + { + if ( availSize.x >= virtSize.x && availSize.y >= virtSize.y ) + { + // this will be enough to make the scrollbars disappear below + // and then the client size will indeed become equal to the + // full available size + clientSize = availSize; + } + } + + + DoAdjustScrollbar(wxHORIZONTAL, + clientSize.x, + virtSize.x, + m_xScrollPixelsPerLine, + m_xScrollLines, + m_xScrollPosition, + m_xScrollLinesPerPage, + m_xVisibility); + + DoAdjustScrollbar(wxVERTICAL, + clientSize.y, + virtSize.y, + m_yScrollPixelsPerLine, + m_yScrollLines, + m_yScrollPosition, + m_yScrollLinesPerPage, + m_yVisibility); + + + // If a scrollbar (dis)appeared as a result of this, we need to adjust + // them again but if the client size didn't change, then we're done + if ( GetTargetSize() == clientSize ) + break; + } + +#ifdef __WXMOTIF__ + // Sorry, some Motif-specific code to implement a backing pixmap + // for the wxRETAINED style. Implementing a backing store can't + // be entirely generic because it relies on the wxWindowDC implementation + // to duplicate X drawing calls for the backing pixmap. + + if ( m_targetWindow->GetWindowStyle() & wxRETAINED ) + { + Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget()); + + int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine; + int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine; + if (m_targetWindow->GetBackingPixmap() && + !((m_targetWindow->GetPixmapWidth() == totalPixelWidth) && + (m_targetWindow->GetPixmapHeight() == totalPixelHeight))) + { + XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap()); + m_targetWindow->SetBackingPixmap((WXPixmap) 0); + } + + if (!m_targetWindow->GetBackingPixmap() && + (m_xScrollLines != 0) && (m_yScrollLines != 0)) + { + int depth = wxDisplayDepth(); + m_targetWindow->SetPixmapWidth(totalPixelWidth); + m_targetWindow->SetPixmapHeight(totalPixelHeight); + m_targetWindow->SetBackingPixmap((WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)), + m_targetWindow->GetPixmapWidth(), m_targetWindow->GetPixmapHeight(), depth)); + } + + } +#endif // Motif + + if (oldXScroll != m_xScrollPosition) + { + if (m_xScrollingEnabled) + m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0, + GetScrollRect() ); + else + m_targetWindow->Refresh(true, GetScrollRect()); + } + + if (oldYScroll != m_yScrollPosition) + { + if (m_yScrollingEnabled) + m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), + GetScrollRect() ); + else + m_targetWindow->Refresh(true, GetScrollRect()); + } } -void wxScrolledWindow::OnPaint(wxPaintEvent& event) +void wxScrollHelper::DoScroll( int x_pos, int y_pos ) { - // 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(); + if (!m_targetWindow) + return; - event.Skip(); + if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && + ((y_pos == -1) || (y_pos == m_yScrollPosition))) return; + + int w = 0, h = 0; + GetTargetSize(&w, &h); + + // compute new position: + int new_x = m_xScrollPosition; + int new_y = m_yScrollPosition; + + if ((x_pos != -1) && (m_xScrollPixelsPerLine)) + { + new_x = x_pos; + + // Calculate page size i.e. number of scroll units you get on the + // current client window + int noPagePositions = w/m_xScrollPixelsPerLine; + if (noPagePositions < 1) noPagePositions = 1; + + // Correct position if greater than extent of canvas minus + // the visible portion of it or if below zero + new_x = wxMin( m_xScrollLines-noPagePositions, new_x ); + new_x = wxMax( 0, new_x ); + } + if ((y_pos != -1) && (m_yScrollPixelsPerLine)) + { + new_y = y_pos; + + // Calculate page size i.e. number of scroll units you get on the + // current client window + int noPagePositions = h/m_yScrollPixelsPerLine; + if (noPagePositions < 1) noPagePositions = 1; + + // Correct position if greater than extent of canvas minus + // the visible portion of it or if below zero + new_y = wxMin( m_yScrollLines-noPagePositions, new_y ); + new_y = wxMax( 0, new_y ); + } + + if ( new_x == m_xScrollPosition && new_y == m_yScrollPosition ) + return; // nothing to do, the position didn't change + + // flush all pending repaints before we change m_{x,y}ScrollPosition, as + // otherwise invalidated area could be updated incorrectly later when + // ScrollWindow() makes sure they're repainted before scrolling them + m_targetWindow->Update(); + + // update the position and scroll the window now: + if (m_xScrollPosition != new_x) + { + int old_x = m_xScrollPosition; + m_xScrollPosition = new_x; + m_win->SetScrollPos( wxHORIZONTAL, new_x ); + m_targetWindow->ScrollWindow( (old_x-new_x)*m_xScrollPixelsPerLine, 0, + GetScrollRect() ); + } + + if (m_yScrollPosition != new_y) + { + int old_y = m_yScrollPosition; + m_yScrollPosition = new_y; + m_win->SetScrollPos( wxVERTICAL, new_y ); + m_targetWindow->ScrollWindow( 0, (old_y-new_y)*m_yScrollPixelsPerLine, + GetScrollRect() ); + } } -#ifdef __WXMSW__ -WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg, - WXWPARAM wParam, - WXLPARAM lParam) +#endif // wxHAS_GENERIC_SCROLLWIN + +// ---------------------------------------------------------------------------- +// wxScrolled and wxScrolledWindow implementation +// ---------------------------------------------------------------------------- + +wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win, + const wxScrollHelper *helper, + const wxSize& origBest) { - WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam); + // 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; +} + +#ifdef __WXMSW__ +WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc) +{ #ifndef __WXWINCE__ // we need to process arrows ourselves for scrolling if ( nMsg == WM_GETDLGCODE ) @@ -1337,8 +1545,10 @@ WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg, rc |= DLGC_WANTARROWS; } #endif - return rc; } - #endif // __WXMSW__ + +// NB: skipping wxScrolled in wxRTTI information because being a templte, +// it doesn't and can't implement wxRTTI support +IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)