X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/870c86bc51b30019f34d178ea415cafe7091759d..1c8e5c51f8a0a547a5183b1443d3ba059b65ce69:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index 7c21cb2f1d..00dac29274 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -1,6 +1,6 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: generic/scrolwin.cpp -// Purpose: wxGenericScrolledWindow implementation +// Name: src/generic/scrlwing.cpp +// Purpose: wxScrolledWindow implementation // Author: Julian Smart // Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement. // Ron Lee on 10.4.02: virtual size / auto scrollbars et al. @@ -18,14 +18,6 @@ // headers // ---------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "genscrolwin.h" -#endif - -#ifdef __VMS -#define XtDisplay XTDISPLAY -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -33,17 +25,21 @@ #pragma hdrstop #endif -#if !defined(__WXGTK__) || defined(__WXUNIVERSAL__) +#include "wx/scrolwin.h" -#include "wx/utils.h" -#include "wx/dcclient.h" +#ifndef WX_PRECOMP + #include "wx/utils.h" + #include "wx/panel.h" + #include "wx/dcclient.h" + #include "wx/timer.h" + #include "wx/sizer.h" + #include "wx/settings.h" +#endif -#include "wx/scrolwin.h" -#include "wx/panel.h" -#if wxUSE_TIMER -#include "wx/timer.h" +#ifdef __WXMAC__ +#include "wx/scrolbar.h" #endif -#include "wx/sizer.h" + #include "wx/recguard.h" #ifdef __WXMSW__ @@ -63,8 +59,6 @@ #endif #endif -IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) - /* TODO PROPERTIES style wxHSCROLL | wxVSCROLL @@ -230,22 +224,30 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) // 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 ) + if ( m_hasDrawnWindow || event.IsCommandEvent() ) { return true; } } - // reset the skipped flag to false as it might have been set to true in - // ProcessEvent() above - event.Skip(false); - if ( evType == wxEVT_PAINT ) { m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); return true; } + 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 || @@ -255,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 ) @@ -268,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; } // ---------------------------------------------------------------------------- @@ -288,6 +309,8 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) wxScrollHelper::wxScrollHelper(wxWindow *win) { + wxASSERT_MSG( win, _T("associated window can't be NULL in wxScrollHelper") ); + m_xScrollPixelsPerLine = m_yScrollPixelsPerLine = m_xScrollPosition = @@ -313,8 +336,12 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_handler = NULL; - if ( win ) - SetWindow(win); + m_win = win; + + m_win->SetScrollHelper( this ); + + // by default, the associated window is also the target window + DoSetTargetWindow(win); } wxScrollHelper::~wxScrollHelper() @@ -411,16 +438,6 @@ void wxScrollHelper::DeleteEvtHandler() } } -void wxScrollHelper::SetWindow(wxWindow *win) -{ - wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") ); - - m_win = win; - - // by default, the associated window is also the target window - DoSetTargetWindow(win); -} - void wxScrollHelper::DoSetTargetWindow(wxWindow *target) { m_targetWindow = target; @@ -471,21 +488,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 ) @@ -509,6 +515,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()); @@ -572,49 +602,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; + } } } @@ -655,7 +672,7 @@ void wxScrollHelper::AdjustScrollbars() do { iterationCount ++; - + GetTargetSize(&w, 0); // scroll lines per page: if 0, no scrolling is needed @@ -824,8 +841,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 ); } @@ -855,6 +881,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 ) @@ -882,50 +917,67 @@ void wxScrollHelper::Scroll( int x_pos, int y_pos ) if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && ((y_pos == -1) || (y_pos == m_yScrollPosition))) return; - int w, h; + 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() ); } } @@ -944,15 +996,6 @@ void wxScrollHelper::GetViewStart (int *x, int *y) const *y = m_yScrollPosition; } -#if WXWIN_COMPATIBILITY_2_2 - -void wxScrollHelper::ViewStart(int *x, int *y) const -{ - GetViewStart( x, y ); -} - -#endif // WXWIN_COMPATIBILITY_2_2 - void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const { if ( xx ) @@ -969,6 +1012,48 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine; } +// ---------------------------------------------------------------------------- +// geometry +// ---------------------------------------------------------------------------- + +bool wxScrollHelper::ScrollLayout() +{ + if ( m_win->GetSizer() && m_targetWindow == m_win ) + { + // If we're the scroll target, take into account the + // virtual size and scrolled position of the window. + + int x = 0, y = 0, w = 0, h = 0; + CalcScrolledPosition(0,0, &x,&y); + m_win->GetVirtualSize(&w, &h); + m_win->GetSizer()->SetDimension(x, y, w, h); + return true; + } + + // fall back to default for LayoutConstraints + return m_win->wxWindow::Layout(); +} + +void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y) +{ + m_win->wxWindow::DoSetVirtualSize( x, y ); + AdjustScrollbars(); + + if (m_win->GetAutoLayout()) + m_win->Layout(); +} + +// wxWindow's GetBestVirtualSize returns the actual window size, +// whereas we want to return the virtual size +wxSize wxScrollHelper::ScrollGetBestVirtualSize() const +{ + wxSize clientSize(m_win->GetClientSize()); + if ( m_win->GetSizer() ) + clientSize.IncTo(m_win->GetSizer()->CalcMin()); + + return clientSize; +} + // ---------------------------------------------------------------------------- // event handlers // ---------------------------------------------------------------------------- @@ -979,7 +1064,7 @@ void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) if ( m_targetWindow->GetAutoLayout() ) { wxSize size = m_targetWindow->GetBestVirtualSize(); - + // This will call ::Layout() and ::AdjustScrollbars() m_win->SetVirtualSize( size ); } @@ -1006,9 +1091,9 @@ void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event)) // this they always have the priority void wxScrollHelper::HandleOnChar(wxKeyEvent& event) { - int stx, sty, // view origin - szx, szy, // view size (total) - clix, cliy; // view size (on screen) + 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); @@ -1042,13 +1127,11 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event) switch ( event.GetKeyCode() ) { case WXK_PAGEUP: - case WXK_PRIOR: dsty = sty - (5 * cliy / 6); Scroll(-1, (dsty == -1) ? 0 : dsty); break; case WXK_PAGEDOWN: - case WXK_NEXT: Scroll(-1, sty + (5 * cliy / 6)); break; @@ -1083,18 +1166,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); } } @@ -1211,7 +1294,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()) @@ -1240,17 +1323,91 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) #endif // wxUSE_MOUSEWHEEL +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(); + + // find the immediate child under which the window receiving focus is: + wxWindow *win = event.GetWindow(); + + if ( win == m_targetWindow ) + return; // nothing to do + + while ( win->GetParent() != m_targetWindow ) + { + win = win->GetParent(); + if ( !win ) + return; // event is not from a child of the target window + } + + // if the child is not fully visible, try to scroll it into view: + int stepx, stepy; + GetScrollPixelsPerUnit(&stepx, &stepy); + + // NB: we don't call CalcScrolledPosition() on win->GetPosition() here, + // because children' positions are already scrolled + wxRect winrect(win->GetPosition(), win->GetSize()); + wxSize view(m_targetWindow->GetClientSize()); + + 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); +} + // ---------------------------------------------------------------------------- -// wxGenericScrolledWindow implementation +// wxScrolledWindow implementation // ---------------------------------------------------------------------------- -IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel) +IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel) -BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel) - EVT_PAINT(wxGenericScrolledWindow::OnPaint) +BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel) + EVT_PAINT(wxScrolledWindow::OnPaint) END_EVENT_TABLE() -bool wxGenericScrolledWindow::Create(wxWindow *parent, +bool wxScrolledWindow::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, @@ -1262,108 +1419,72 @@ bool wxGenericScrolledWindow::Create(wxWindow *parent, MacSetClipChildren( true ) ; #endif - bool ok = wxPanel::Create(parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name); + // 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; - return ok; -} + bool ok = wxPanel::Create(parent, id, pos, size, style, name); -wxGenericScrolledWindow::~wxGenericScrolledWindow() -{ + return ok; } -bool wxGenericScrolledWindow::Layout() +wxScrolledWindow::~wxScrolledWindow() { - if (GetSizer() && m_targetWindow == this) - { - // If we're the scroll target, take into account the - // virtual size and scrolled position of the window. - - int x, y, w, h; - CalcScrolledPosition(0,0, &x,&y); - GetVirtualSize(&w, &h); - GetSizer()->SetDimension(x, y, w, h); - return true; - } - - // fall back to default for LayoutConstraints - return wxPanel::Layout(); } -void wxGenericScrolledWindow::DoSetVirtualSize(int x, int y) +void wxScrolledWindow::OnPaint(wxPaintEvent& event) { - wxPanel::DoSetVirtualSize( x, y ); - AdjustScrollbars(); + // the user code didn't really draw the window if we got here, so set this + // flag to try to call OnDraw() later + m_handler->ResetDrawnFlag(); - if (GetAutoLayout()) - Layout(); + event.Skip(); } -// wxWindow's GetBestVirtualSize returns the actual window size, -// whereas we want to return the virtual size -wxSize wxGenericScrolledWindow::GetBestVirtualSize() const +wxSize wxScrolledWindow::DoGetBestSize() const { - wxSize clientSize( GetClientSize() ); - if (GetSizer()) - { - wxSize minSize( GetSizer()->CalcMin() ); + // 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). - return wxSize( wxMax( clientSize.x, minSize.x ), wxMax( clientSize.y, minSize.y ) ); - } - else - return clientSize; -} - -// return the size best suited for the current window -// (this isn't a virtual size, this is a sensible size for the window) -wxSize wxGenericScrolledWindow::DoGetBestSize() const -{ - wxSize best; + wxSize best = wxPanel::DoGetBestSize(); - if ( GetSizer() ) + if ( GetAutoLayout() ) { - wxSize b = GetSizer()->GetMinSize(); - // Only use the content to set the window size in the direction // where there's no scrolling; otherwise we're going to get a huge // window in the direction in which scrolling is enabled int ppuX, ppuY; - GetScrollPixelsPerUnit(& ppuX, & ppuY); - - wxSize minSize; - if ( GetMinSize().IsFullySpecified() ) - minSize = GetMinSize(); - else - minSize = GetSize(); + GetScrollPixelsPerUnit(&ppuX, &ppuY); - if (ppuX > 0) - b.x = minSize.x; - if (ppuY > 0) - b.y = minSize.y; - best = b; - } - else - return wxWindow::DoGetBestSize(); + // 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 - // Add any difference between size and client size - wxSize diff = GetSize() - GetClientSize(); - best.x += wxMax(0, diff.x); - best.y += wxMax(0, diff.y); + wxSize minSize = GetMinSize(); - return best; -} + if ( ppuX > 0 ) + best.x = minSize.x + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X); -void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event) -{ - // the user code didn't really draw the window if we got here, so set this - // flag to try to call OnDraw() later - m_handler->ResetDrawnFlag(); + if ( ppuY > 0 ) + best.y = minSize.y + wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y); + } - event.Skip(); + return best; } #ifdef __WXMSW__ -WXLRESULT -wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg, +WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) { @@ -1381,7 +1502,3 @@ wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg, } #endif // __WXMSW__ - -#endif // !wxGTK - -// vi:sts=4:sw=4:et