X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/2e9c0c010a375156eb72eaa1e2e4efcbb7ecf06b..83666e99093aa0b65c497f7e6c75d98a875667cc:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index 7db540e792..c3f25599f9 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,10 +31,9 @@ #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__ @@ -241,6 +236,12 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) return true; } + if ( evType == wxEVT_CHILD_FOCUS ) + { + m_scrollHelper->HandleOnChildFocus((wxChildFocusEvent &)event); + return true; + } + // reset the skipped flag (which might have been set to true in // ProcessEvent() above) to be able to test it below bool wasSkipped = event.GetSkipped(); @@ -277,10 +278,14 @@ 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 ) { @@ -433,6 +438,12 @@ void wxScrollHelper::DeleteEvtHandler() } } +void wxScrollHelper::ResetDrawnFlag() +{ + wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" ); + m_handler->ResetDrawnFlag(); +} + void wxScrollHelper::DoSetTargetWindow(wxWindow *target) { m_targetWindow = target; @@ -468,22 +479,6 @@ wxWindow *wxScrollHelper::GetTargetWindow() const return m_targetWindow; } -#ifdef __WXMAC__ -static bool wxScrolledWindowHasChildren(wxWindow* win) -{ - wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); - while ( node ) - { - wxWindow* child = node->GetData(); - if ( !child->IsKindOf(CLASSINFO(wxScrollBar)) ) - return true; - - node = node->GetNext(); - } - return false; -} -#endif - // ---------------------------------------------------------------------------- // scrolling implementation itself // ---------------------------------------------------------------------------- @@ -500,11 +495,6 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } bool needsRefresh = false; -#ifdef __WXMAC__ - // OS X blocks on immediate redraws, so make this a refresh - if (!wxScrolledWindowHasChildren(m_targetWindow)) - needsRefresh = true; -#endif int dx = 0, dy = 0; int orient = event.GetOrientation(); @@ -536,7 +526,12 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) // 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) @@ -649,7 +644,61 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) return nScrollInc; } -// Adjust the scrollbars - new version. +void +wxScrollHelper::AdjustScrollbar(int orient, + int clientSize, + int virtSize, + int& pixelsPerUnit, + int& scrollUnits, + int& scrollPosition) +{ + // scroll lines per page: if 0, no scrolling is needed + int unitsPerPage; + + // check if we need scrollbar in this direction at all + if ( pixelsPerUnit == 0 || clientSize >= virtSize ) + { + // scrolling is disabled or unnecessary + scrollUnits = + scrollPosition = 0; + unitsPerPage = 0; + } + else // might need scrolling + { + // Round up integer division to catch any "leftover" client space. + scrollUnits = (virtSize + pixelsPerUnit - 1) / pixelsPerUnit; + + // Calculate the number of fully scroll units + unitsPerPage = clientSize / pixelsPerUnit; + + if (unitsPerPage >= scrollUnits) + { + // we're big enough to not need scrolling + scrollUnits = + scrollPosition = 0; + unitsPerPage = 0; + } + else // we do need a scrollbar + { + if ( unitsPerPage < 1 ) + unitsPerPage = 1; + + // Correct position if greater than extent of canvas minus + // the visible portion of it or if below zero + const int posMax = scrollUnits - unitsPerPage; + if ( scrollPosition > posMax ) + scrollPosition = posMax; + else if ( scrollPosition < 0 ) + scrollPosition = 0; + } + } + + m_win->SetScrollbar(orient, scrollPosition, unitsPerPage, scrollUnits); + + // The amount by which we scroll when paging + SetScrollPageSize(orient, unitsPerPage); +} + void wxScrollHelper::AdjustScrollbars() { static wxRecursionGuardFlag s_flagReentrancy; @@ -665,137 +714,62 @@ void wxScrollHelper::AdjustScrollbars() 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 + // 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++ ) { - iterationCount ++; - - GetTargetSize(&w, 0); - - // scroll lines per page: if 0, no scrolling is needed - int linesPerPage; - - if ( m_xScrollPixelsPerLine == 0 ) - { - // scrolling is disabled - m_xScrollLines = 0; - m_xScrollPosition = 0; - linesPerPage = 0; - } - else // might need scrolling + 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 ) { - // Round up integer division to catch any "leftover" client space. - const int wVirt = m_targetWindow->GetVirtualSize().GetWidth(); - m_xScrollLines = (wVirt + m_xScrollPixelsPerLine - 1) / m_xScrollPixelsPerLine; - - // Calculate page size i.e. number of scroll units you get on the - // current client window. - linesPerPage = w / m_xScrollPixelsPerLine; - - // Special case. When client and virtual size are very close but - // the client is big enough, kill scrollbar. - if ((linesPerPage < m_xScrollLines) && (w >= wVirt)) ++linesPerPage; - - if (linesPerPage >= m_xScrollLines) - { - // we're big enough to not need scrolling - linesPerPage = - m_xScrollLines = - m_xScrollPosition = 0; - } - else // we do need a scrollbar + if ( availSize.x >= virtSize.x && availSize.y >= virtSize.y ) { - 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; + // 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; } } - m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, - linesPerPage, m_xScrollLines); - // The amount by which we scroll when paging - SetScrollPageSize(wxHORIZONTAL, linesPerPage); + AdjustScrollbar(wxHORIZONTAL, + clientSize.x, + virtSize.x, + m_xScrollPixelsPerLine, + m_xScrollLines, + m_xScrollPosition); - GetTargetSize(0, &h); + AdjustScrollbar(wxVERTICAL, + clientSize.y, + virtSize.y, + m_yScrollPixelsPerLine, + m_yScrollLines, + m_yScrollPosition); - if ( m_yScrollPixelsPerLine == 0 ) - { - // scrolling is disabled - m_yScrollLines = 0; - m_yScrollPosition = 0; - linesPerPage = 0; - } - else // might need scrolling - { - // Round up integer division to catch any "leftover" client space. - const int hVirt = m_targetWindow->GetVirtualSize().GetHeight(); - m_yScrollLines = ( hVirt + m_yScrollPixelsPerLine - 1 ) / m_yScrollPixelsPerLine; - - // Calculate page size i.e. number of scroll units you get on the - // current client window. - linesPerPage = h / m_yScrollPixelsPerLine; - // Special case. When client and virtual size are very close but - // the client is big enough, kill scrollbar. - if ((linesPerPage < m_yScrollLines) && (h >= hVirt)) ++linesPerPage; - - if (linesPerPage >= m_yScrollLines) - { - // we're big enough to not need scrolling - linesPerPage = - m_yScrollLines = - m_yScrollPosition = 0; - } - else // we do need a scrollbar - { - if ( linesPerPage < 1 ) - linesPerPage = 1; - - // Correct position if greater than extent of canvas minus - // the visible portion of it or if below zero - const int posMax = m_yScrollLines - linesPerPage; - if ( m_yScrollPosition > posMax ) - m_yScrollPosition = posMax; - else if ( m_yScrollPosition < 0 ) - m_yScrollPosition = 0; - } - } - - m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition, - linesPerPage, m_yScrollLines); - - // 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) ); + // 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 @@ -854,7 +828,7 @@ void wxScrollHelper::DoPrepareDC(wxDC& dc) wxPoint pt = dc.GetDeviceOrigin(); #ifdef __WXGTK__ // It may actually be correct to always query - // the m_sign from the DC here, but I leve the + // 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, @@ -1065,29 +1039,6 @@ 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 // ---------------------------------------------------------------------------- @@ -1200,18 +1151,18 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event) if ( m_xScrollPosition != xScrollOld ) { - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition, + wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition, wxHORIZONTAL); - event.SetEventObject(m_win); - m_win->GetEventHandler()->ProcessEvent(event); + evt.SetEventObject(m_win); + m_win->GetEventHandler()->ProcessEvent(evt); } if ( m_yScrollPosition != yScrollOld ) { - wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition, + wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition, wxVERTICAL); - event.SetEventObject(m_win); - m_win->GetEventHandler()->ProcessEvent(event); + evt.SetEventObject(m_win); + m_win->GetEventHandler()->ProcessEvent(evt); } } @@ -1357,59 +1308,177 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) #endif // wxUSE_MOUSEWHEEL -// ---------------------------------------------------------------------------- -// wxScrolledWindow implementation -// ---------------------------------------------------------------------------- +void wxScrollHelper::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(wxScrolledWindow, wxPanel) + // find the immediate child under which the window receiving focus is: + wxWindow *win = event.GetWindow(); -BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel) - EVT_PAINT(wxScrolledWindow::OnPaint) -END_EVENT_TABLE() + if ( win == m_targetWindow ) + return; // nothing to do -bool wxScrolledWindow::Create(wxWindow *parent, - wxWindowID id, - const wxPoint& pos, - const wxSize& size, - long style, - const wxString& name) -{ - m_targetWindow = this; #ifdef __WXMAC__ - MacSetClipChildren( true ) ; + if (wxDynamicCast(win, wxScrollBar)) + return; #endif - // by default, we're scrollable in both directions (but if one of the - // styles is specified explicitly, we shouldn't add the other one - // automatically) - if ( !(style & (wxHSCROLL | wxVSCROLL)) ) - style |= wxHSCROLL | wxVSCROLL; + // 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; + + wxSize view(m_targetWindow->GetClientSize()); + + // For composite controls such as wxComboCtrl we should try to fit the + // entire control inside the visible area of the target window, not just + // the focused child of the control. Otherwise we'd make only the textctrl + // part of a wxComboCtrl visible and the button would still be outside the + // scrolled area. But do so only if the parent fits *entirely* inside the + // scrolled window. In other situations, such as nested wxPanel or + // wxScrolledWindows, the parent might be way to big to fit inside the + // scrolled window. If that is the case, then make only the focused window + // visible + if ( win->GetParent() != m_targetWindow) + { + wxWindow *parent=win->GetParent(); + wxSize parent_size=parent->GetSize(); + if (parent_size.GetWidth() <= view.GetWidth() && + parent_size.GetHeight() <= view.GetHeight()) + // make the immediate parent visible instead of the focused control + win=parent; + } - bool ok = wxPanel::Create(parent, id, pos, size, style, name); + // if the child is not fully visible, try to scroll it into view: + int stepx, stepy; + GetScrollPixelsPerUnit(&stepx, &stepy); - return ok; -} + // 'win' position coordinates are relative to it's parent + // convert them so that they are relative to the m_targetWindow viewing area + wxRect winrect(m_targetWindow->ScreenToClient(win->GetScreenPosition()), + win->GetSize()); -wxScrolledWindow::~wxScrolledWindow() -{ + 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() > view.y ) + { + diff = winrect.GetBottom() - view.y + 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() > view.x ) + { + diff = winrect.GetRight() - view.x + 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); } -void wxScrolledWindow::OnPaint(wxPaintEvent& event) +// ---------------------------------------------------------------------------- +// wxScrolled and wxScrolledWindow implementation +// ---------------------------------------------------------------------------- + +wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win, + const wxScrollHelperNative *helper, + const wxSize& origBest) { - // 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(); + // 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). - event.Skip(); + 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 wxScrolledWindow::MSWWindowProc(WXUINT nMsg, - WXWPARAM wParam, - WXLPARAM lParam) +WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc) { - WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam); - #ifndef __WXWINCE__ // we need to process arrows ourselves for scrolling if ( nMsg == WM_GETDLGCODE ) @@ -1417,8 +1486,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)