X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/de6185e212ebc37ff11ff70278e3c4f68419b097..298c25c3a5b9d5d6b92310a54f860cd48627888b:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index 69c534470d..ec5d404f50 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: src/generic/scrolwin.cpp +// Name: src/generic/scrlwing.cpp // Purpose: wxScrolledWindow implementation // Author: Julian Smart // Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement. @@ -18,10 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __VMS -#define XtDisplay XTDISPLAY -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -33,15 +29,17 @@ #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/dcclient.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__ @@ -232,16 +230,24 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) } } - // reset the skipped flag to false as it might have been set to true in - // ProcessEvent() above - event.Skip(false); - if ( evType == wxEVT_PAINT ) { m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); return true; } + 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(); + if ( wasSkipped ) + event.Skip(false); + if ( evType == wxEVT_SCROLLWIN_TOP || evType == wxEVT_SCROLLWIN_BOTTOM || evType == wxEVT_SCROLLWIN_LINEUP || @@ -251,8 +257,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 ) @@ -264,18 +278,29 @@ 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; + if ( processed ) + event.Skip(wasSkipped); + + return processed; } // ---------------------------------------------------------------------------- @@ -312,6 +337,8 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_handler = NULL; m_win = win; + + m_win->SetScrollHelper( this ); // by default, the associated window is also the target window DoSetTargetWindow(win); @@ -411,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; @@ -461,21 +494,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 ) @@ -499,6 +521,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()); @@ -562,49 +608,36 @@ 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 + // 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 ) { - 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 = posMax - m_xScrollPosition; } } - else - m_targetWindow->Refresh(true, GetScrollRect()); } - else + else // wxVERTICAL { - if ( m_yScrollPixelsPerLine > 0 ) + if ( m_yScrollPosition + nScrollInc < 0 ) { - if ( m_yScrollPosition + nScrollInc < 0 ) - { - // As -ve as we can go - nScrollInc = -m_yScrollPosition; - } - else // check for the other bound - { - const int posMax = m_yScrollLines - m_yScrollLinesPerPage; - if ( m_yScrollPosition + nScrollInc > posMax ) - { - // As +ve as we can go - nScrollInc = posMax - m_yScrollPosition; - } - } + // As -ve as we can go + nScrollInc = -m_yScrollPosition; } - else + else // check for the other bound { - // VZ: why do we do this? (FIXME) - m_targetWindow->Refresh(true, GetScrollRect()); + const int posMax = m_yScrollLines - m_yScrollLinesPerPage; + if ( m_yScrollPosition + nScrollInc > posMax ) + { + // As +ve as we can go + nScrollInc = posMax - m_yScrollPosition; + } } } @@ -814,8 +847,17 @@ void wxScrollHelper::AdjustScrollbars() void wxScrollHelper::DoPrepareDC(wxDC& dc) { wxPoint pt = dc.GetDeviceOrigin(); - dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine, - pt.y - m_yScrollPosition * m_yScrollPixelsPerLine ); +#ifdef __WXGTK__ + // It may actually be correct to always query + // the m_sign from the DC here, but I leve the + // #ifdef GTK for now. + if (m_win->GetLayoutDirection() == wxLayout_RightToLeft) + dc.SetDeviceOrigin( pt.x + m_xScrollPosition * m_xScrollPixelsPerLine, + pt.y - m_yScrollPosition * m_yScrollPixelsPerLine ); + else +#endif + dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine, + pt.y - m_yScrollPosition * m_yScrollPixelsPerLine ); dc.SetUserScale( m_scaleX, m_scaleY ); } @@ -845,6 +887,15 @@ void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const *y_unit = m_yScrollPixelsPerLine; } + +int wxScrollHelper::GetScrollLines( int orient ) const +{ + if ( orient == wxHORIZONTAL ) + return m_xScrollLines; + else + return m_yScrollLines; +} + int wxScrollHelper::GetScrollPageSize(int orient) const { if ( orient == wxHORIZONTAL ) @@ -875,47 +926,64 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos ) int w = 0, h = 0; GetTargetSize(&w, &h); + // compute new position: + int new_x = m_xScrollPosition; + int new_y = m_yScrollPosition; + if ((x_pos != -1) && (m_xScrollPixelsPerLine)) { - int old_x = m_xScrollPosition; - m_xScrollPosition = x_pos; + new_x = x_pos; // Calculate page size i.e. number of scroll units you get on the // current client window - int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 ); + int noPagePositions = w/m_xScrollPixelsPerLine; if (noPagePositions < 1) noPagePositions = 1; // Correct position if greater than extent of canvas minus // the visible portion of it or if below zero - m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition ); - m_xScrollPosition = wxMax( 0, m_xScrollPosition ); - - if (old_x != m_xScrollPosition) { - m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition ); - m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0, - GetScrollRect() ); - } + new_x = wxMin( m_xScrollLines-noPagePositions, new_x ); + new_x = wxMax( 0, new_x ); } if ((y_pos != -1) && (m_yScrollPixelsPerLine)) { - int old_y = m_yScrollPosition; - m_yScrollPosition = y_pos; + new_y = y_pos; // Calculate page size i.e. number of scroll units you get on the // current client window - int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 ); + int noPagePositions = h/m_yScrollPixelsPerLine; if (noPagePositions < 1) noPagePositions = 1; // Correct position if greater than extent of canvas minus // the visible portion of it or if below zero - m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition ); - m_yScrollPosition = wxMax( 0, m_yScrollPosition ); + new_y = wxMin( m_yScrollLines-noPagePositions, new_y ); + new_y = wxMax( 0, new_y ); + } - if (old_y != m_yScrollPosition) { - m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition ); - m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine, - GetScrollRect() ); - } + 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() ); } } @@ -992,29 +1060,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 // ---------------------------------------------------------------------------- @@ -1127,18 +1172,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); } } @@ -1255,7 +1300,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()) @@ -1284,53 +1329,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 - bool ok = wxPanel::Create(parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name); + // 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; + } - return ok; -} + // if the child is not fully visible, try to scroll it into view: + int stepx, stepy; + GetScrollPixelsPerUnit(&stepx, &stepy); -wxScrolledWindow::~wxScrolledWindow() -{ + // '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()); + + 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 ) @@ -1338,8 +1507,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)