X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/987263fe1974dac46a38d6d623557ccf89a25992..d40a56d0db2e5249a65087b6af7d1ff7bfb378a6:/src/generic/scrlwing.cpp?ds=sidebyside diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index deea726fb6..7add087eda 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -6,7 +6,7 @@ // Ron Lee on 10.4.02: virtual size / auto scrollbars et al. // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team +// Copyright: (c) wxWidgets team // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -48,6 +48,7 @@ #ifdef __WXMSW__ #include // for DLGC_WANTARROWS + #include "wx/msw/winundef.h" #endif #ifdef __WXMOTIF__ @@ -65,8 +66,8 @@ IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) /* - TODO PROPERTIES - style wxHSCROLL | wxVSCROLL + TODO PROPERTIES + style wxHSCROLL | wxVSCROLL */ // ---------------------------------------------------------------------------- @@ -84,7 +85,7 @@ public: virtual bool ProcessEvent(wxEvent& event); - void ResetDrawnFlag() { m_hasDrawnWindow = FALSE; } + void ResetDrawnFlag() { m_hasDrawnWindow = false; } private: wxScrollHelper *m_scrollHelper; @@ -205,7 +206,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) // 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; + m_hasDrawnWindow = true; // pass it on to the real handler bool processed = wxEvtHandler::ProcessEvent(event); @@ -221,7 +222,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) { m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - return TRUE; + return true; } if ( processed ) @@ -231,18 +232,18 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) // OnDraw() below (from HandleOnPaint) if ( m_hasDrawnWindow ) { - return TRUE; + return true; } } - // reset the skipped flag to FALSE as it might have been set to TRUE in + // reset the skipped flag to false as it might have been set to true in // ProcessEvent() above - event.Skip(FALSE); + event.Skip(false); if ( evType == wxEVT_PAINT ) { m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); - return TRUE; + return true; } if ( evType == wxEVT_SCROLLWIN_TOP || @@ -278,7 +279,7 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) return !event.GetSkipped(); } - return FALSE; + return false; } // ---------------------------------------------------------------------------- @@ -297,7 +298,7 @@ wxScrollHelper::wxScrollHelper(wxWindow *win) m_yScrollLinesPerPage = 0; m_xScrollingEnabled = - m_yScrollingEnabled = TRUE; + m_yScrollingEnabled = true; m_scaleX = m_scaleY = 1.0; @@ -360,15 +361,18 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, // For better backward compatibility we set persisting limits // here not just the size. It makes SetScrollbars 'sticky' // emulating the old non-autoscroll behaviour. - - m_targetWindow->SetVirtualSizeHints( w, h ); + // m_targetWindow->SetVirtualSizeHints( w, h ); // The above should arguably be deprecated, this however we still need. - m_targetWindow->SetVirtualSize( w, h ); + // take care not to set 0 virtual size, 0 means that we don't have any + // scrollbars and hence we should use the real size instead of the virtual + // one which is indicated by using wxDefaultCoord + m_targetWindow->SetVirtualSize( w ? w : wxDefaultCoord, + h ? h : wxDefaultCoord); if (do_refresh && !noRefresh) - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); #ifndef __WXUNIVERSAL__ // If the target is not the same as the window with the scrollbars, @@ -476,7 +480,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition); } - bool needsRefresh = FALSE; + bool needsRefresh = false; int dx = 0, dy = 0; if (orient == wxHORIZONTAL) @@ -487,7 +491,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } else @@ -498,13 +502,13 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) } else { - needsRefresh = TRUE; + needsRefresh = true; } } if ( needsRefresh ) { - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } else { @@ -567,21 +571,23 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) { if (m_xScrollPixelsPerLine > 0) { - int w, h; - GetTargetSize(&w, &h); - - int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine; - int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 ); - if (noPositions < 0) - noPositions = 0; - - if ( (m_xScrollPosition + nScrollInc) < 0 ) - nScrollInc = -m_xScrollPosition; // As -ve as we can go - else if ( (m_xScrollPosition + nScrollInc) > noPositions ) - nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go + 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; + } + } } else - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } else { @@ -605,7 +611,7 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event) else { // VZ: why do we do this? (FIXME) - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } } @@ -644,37 +650,59 @@ void wxScrollHelper::AdjustScrollbars() { GetTargetSize(&w, 0); - if (m_xScrollPixelsPerLine == 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; - m_win->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); + linesPerPage = 0; } - else + else // might need scrolling { - m_xScrollLines = m_targetWindow->GetVirtualSize().GetWidth() / m_xScrollPixelsPerLine; + // 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 - int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 ); - if (noPagePositions < 1) noPagePositions = 1; - if ( noPagePositions > m_xScrollLines ) - noPagePositions = m_xScrollLines; - - // Correct position if greater than extent of canvas minus - // the visible portion of it or if below zero - m_xScrollPosition = wxMin( m_xScrollLines - noPagePositions, m_xScrollPosition); - m_xScrollPosition = wxMax( 0, m_xScrollPosition ); - - m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines); - // The amount by which we scroll when paging - SetScrollPageSize(wxHORIZONTAL, noPagePositions); + // 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 ( 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; + } } - GetTargetSize(0, &h); + m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, + linesPerPage, m_xScrollLines); - // scroll lines per page: if 0, no scrolling is needed - int linesPerPage; + // The amount by which we scroll when paging + SetScrollPageSize(wxHORIZONTAL, linesPerPage); + + GetTargetSize(0, &h); if ( m_yScrollPixelsPerLine == 0 ) { @@ -685,13 +713,19 @@ void wxScrollHelper::AdjustScrollbars() } else // might need scrolling { - int hVirt = m_targetWindow->GetVirtualSize().GetHeight(); - m_yScrollLines = hVirt / m_yScrollPixelsPerLine; + // 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 + // current client window. linesPerPage = h / m_yScrollPixelsPerLine; - if ( linesPerPage >= m_yScrollLines ) + + // 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 = @@ -766,7 +800,7 @@ void wxScrollHelper::AdjustScrollbars() m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0, GetScrollRect() ); else - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } if (oldYScroll != m_yScrollPosition) @@ -775,7 +809,7 @@ void wxScrollHelper::AdjustScrollbars() m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), GetScrollRect() ); else - m_targetWindow->Refresh(TRUE, GetScrollRect()); + m_targetWindow->Refresh(true, GetScrollRect()); } } @@ -902,6 +936,15 @@ 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 ) @@ -925,22 +968,17 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co // Default OnSize resets scrollbars, if any void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) { - if( m_win->GetAutoLayout() || m_targetWindow->GetAutoLayout() ) + if ( m_targetWindow->GetAutoLayout() ) { - if ( m_targetWindow != m_win ) - m_targetWindow->FitInside(); - - m_win->FitInside(); - - // FIXME: Something is really weird here... This should be - // called by FitInside above (and apparently is), yet the - // scrollsub sample will get the scrollbar wrong if resized - // quickly. This masks the bug, but is surely not the right - // answer at all. - AdjustScrollbars(); + wxSize size = m_targetWindow->GetBestVirtualSize(); + + // This will call ::Layout() and ::AdjustScrollbars() + m_win->SetVirtualSize( size ); } else + { AdjustScrollbars(); + } } // This calls OnDraw, having adjusted the origin according to the current @@ -1145,6 +1183,8 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) orient ); m_timerAutoScroll->Start(50); // FIXME: make configurable +#else + wxUnusedVar(pos); #endif } } @@ -1164,14 +1204,14 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) newEvent.SetPosition(0); newEvent.SetOrientation(wxVERTICAL); - newEvent.m_eventObject = m_win; + newEvent.SetEventObject(m_win); if (event.IsPageScroll()) { if (lines > 0) - newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP; + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP); else - newEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN; + newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN); m_win->GetEventHandler()->ProcessEvent(newEvent); } @@ -1179,9 +1219,9 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) { lines *= event.GetLinesPerAction(); if (lines > 0) - newEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP; + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP); else - newEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN; + newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN); int times = abs(lines); for (; times > 0; times--) @@ -1211,7 +1251,7 @@ bool wxGenericScrolledWindow::Create(wxWindow *parent, { m_targetWindow = this; - bool ok = wxPanel::Create(parent, id, pos, size, style, name); + bool ok = wxPanel::Create(parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name); return ok; } @@ -1231,7 +1271,7 @@ bool wxGenericScrolledWindow::Layout() CalcScrolledPosition(0,0, &x,&y); GetVirtualSize(&w, &h); GetSizer()->SetDimension(x, y, w, h); - return TRUE; + return true; } // fall back to default for LayoutConstraints @@ -1247,6 +1287,60 @@ void wxGenericScrolledWindow::DoSetVirtualSize(int x, int y) Layout(); } +// wxWindow's GetBestVirtualSize returns the actual window size, +// whereas we want to return the virtual size +wxSize wxGenericScrolledWindow::GetBestVirtualSize() const +{ + wxSize clientSize( GetClientSize() ); + if (GetSizer()) + { + wxSize minSize( GetSizer()->CalcMin() ); + + 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; + + if ( GetSizer() ) + { + 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(); + + if (ppuX > 0) + b.x = minSize.x; + if (ppuY > 0) + b.y = minSize.y; + best = b; + } + else + return wxWindow::DoGetBestSize(); + + // Add any difference between size and client size + wxSize diff = GetSize() - GetClientSize(); + best.x += wxMax(0, diff.x); + best.y += wxMax(0, diff.y); + + return best; +} + void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event) { // the user code didn't really draw the window if we got here, so set this @@ -1257,12 +1351,12 @@ void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event) } #ifdef __WXMSW__ -long +WXLRESULT wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) { - long rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam); + WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam); #ifndef __WXWINCE__ // we need to process arrows ourselves for scrolling