/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "nsListBoxBodyFrame.h" #include "nsListBoxLayout.h" #include "mozilla/MathAlgorithms.h" #include "nsCOMPtr.h" #include "nsGridRowGroupLayout.h" #include "nsIServiceManager.h" #include "nsGkAtoms.h" #include "nsIContent.h" #include "nsNameSpaceManager.h" #include "nsIDocument.h" #include "nsIDOMMouseEvent.h" #include "nsIDOMElement.h" #include "nsIDOMNodeList.h" #include "nsCSSFrameConstructor.h" #include "nsIScrollableFrame.h" #include "nsScrollbarFrame.h" #include "nsView.h" #include "nsViewManager.h" #include "nsStyleContext.h" #include "nsFontMetrics.h" #include "nsITimer.h" #include "mozilla/StyleSetHandle.h" #include "mozilla/StyleSetHandleInlines.h" #include "nsPIBoxObject.h" #include "nsLayoutUtils.h" #include "nsPIListBoxObject.h" #include "nsContentUtils.h" #include "ChildIterator.h" #include "nsRenderingContext.h" #include "prtime.h" #include <algorithm> #ifdef ACCESSIBILITY #include "nsAccessibilityService.h" #endif using namespace mozilla; using namespace mozilla::dom; /////////////// nsListScrollSmoother ////////////////// /* A mediator used to smooth out scrolling. It works by seeing if * we have time to scroll the amount of rows requested. This is determined * by measuring how long it takes to scroll a row. If we can scroll the * rows in time we do so. If not we start a timer and skip the request. We * do this until the timer finally first because the user has stopped moving * the mouse. Then do all the queued requests in on shot. */ // the longest amount of time that can go by before the use // notices it as a delay. #define USER_TIME_THRESHOLD 150000 // how long it takes to layout a single row initial value. // we will time this after we scroll a few rows. #define TIME_PER_ROW_INITAL 50000 // if we decide we can't layout the rows in the amount of time. How long // do we wait before checking again? #define SMOOTH_INTERVAL 100 class nsListScrollSmoother final : public nsITimerCallback { private: virtual ~nsListScrollSmoother(); public: NS_DECL_ISUPPORTS explicit nsListScrollSmoother(nsListBoxBodyFrame* aOuter); // nsITimerCallback NS_DECL_NSITIMERCALLBACK void Start(); void Stop(); bool IsRunning(); nsCOMPtr<nsITimer> mRepeatTimer; int32_t mDelta; nsListBoxBodyFrame* mOuter; }; nsListScrollSmoother::nsListScrollSmoother(nsListBoxBodyFrame* aOuter) { mDelta = 0; mOuter = aOuter; } nsListScrollSmoother::~nsListScrollSmoother() { Stop(); } NS_IMETHODIMP nsListScrollSmoother::Notify(nsITimer *timer) { Stop(); NS_ASSERTION(mOuter, "mOuter is null, see bug #68365"); if (!mOuter) return NS_OK; // actually do some work. mOuter->InternalPositionChangedCallback(); return NS_OK; } bool nsListScrollSmoother::IsRunning() { return mRepeatTimer ? true : false; } void nsListScrollSmoother::Start() { Stop(); mRepeatTimer = do_CreateInstance("@mozilla.org/timer;1"); mRepeatTimer->InitWithCallback(this, SMOOTH_INTERVAL, nsITimer::TYPE_ONE_SHOT); } void nsListScrollSmoother::Stop() { if ( mRepeatTimer ) { mRepeatTimer->Cancel(); mRepeatTimer = nullptr; } } NS_IMPL_ISUPPORTS(nsListScrollSmoother, nsITimerCallback) /////////////// nsListBoxBodyFrame ////////////////// nsListBoxBodyFrame::nsListBoxBodyFrame(nsStyleContext* aContext, nsBoxLayout* aLayoutManager) : nsBoxFrame(aContext, false, aLayoutManager), mTopFrame(nullptr), mBottomFrame(nullptr), mLinkupFrame(nullptr), mScrollSmoother(nullptr), mRowsToPrepend(0), mRowCount(-1), mRowHeight(0), mAvailableHeight(0), mStringWidth(-1), mCurrentIndex(0), mOldIndex(0), mYPosition(0), mTimePerRow(TIME_PER_ROW_INITAL), mRowHeightWasSet(false), mScrolling(false), mAdjustScroll(false), mReflowCallbackPosted(false) { } nsListBoxBodyFrame::~nsListBoxBodyFrame() { NS_IF_RELEASE(mScrollSmoother); #if USE_TIMER_TO_DELAY_SCROLLING StopScrollTracking(); mAutoScrollTimer = nullptr; #endif } NS_QUERYFRAME_HEAD(nsListBoxBodyFrame) NS_QUERYFRAME_ENTRY(nsIScrollbarMediator) NS_QUERYFRAME_ENTRY(nsListBoxBodyFrame) NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame) ////////// nsIFrame ///////////////// void nsListBoxBodyFrame::Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) { nsBoxFrame::Init(aContent, aParent, aPrevInFlow); // Don't call nsLayoutUtils::GetScrollableFrameFor since we are not its // scrollframe child yet. nsIScrollableFrame* scrollFrame = do_QueryFrame(aParent); if (scrollFrame) { nsIFrame* verticalScrollbar = scrollFrame->GetScrollbarBox(true); nsScrollbarFrame* scrollbarFrame = do_QueryFrame(verticalScrollbar); if (scrollbarFrame) { scrollbarFrame->SetScrollbarMediatorContent(GetContent()); } } RefPtr<nsFontMetrics> fm = nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f); mRowHeight = fm->MaxHeight(); } void nsListBoxBodyFrame::DestroyFrom(nsIFrame* aDestructRoot) { // make sure we cancel any posted callbacks. if (mReflowCallbackPosted) PresContext()->PresShell()->CancelReflowCallback(this); // Revoke any pending position changed events for (uint32_t i = 0; i < mPendingPositionChangeEvents.Length(); ++i) { mPendingPositionChangeEvents[i]->Revoke(); } // Make sure we tell our listbox's box object we're being destroyed. if (mBoxObject) { mBoxObject->ClearCachedValues(); } nsBoxFrame::DestroyFrom(aDestructRoot); } nsresult nsListBoxBodyFrame::AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) { nsresult rv = NS_OK; if (aAttribute == nsGkAtoms::rows) { PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); } else rv = nsBoxFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType); return rv; } /* virtual */ void nsListBoxBodyFrame::MarkIntrinsicISizesDirty() { mStringWidth = -1; nsBoxFrame::MarkIntrinsicISizesDirty(); } /////////// nsBox /////////////// NS_IMETHODIMP nsListBoxBodyFrame::DoXULLayout(nsBoxLayoutState& aBoxLayoutState) { if (mScrolling) aBoxLayoutState.SetPaintingDisabled(true); nsresult rv = nsBoxFrame::DoXULLayout(aBoxLayoutState); // determine the real height for the scrollable area from the total number // of rows, since non-visible rows don't yet have frames nsRect rect(nsPoint(0, 0), GetSize()); nsOverflowAreas overflow(rect, rect); if (mLayoutManager) { nsIFrame* childFrame = mFrames.FirstChild(); while (childFrame) { ConsiderChildOverflow(overflow, childFrame); childFrame = childFrame->GetNextSibling(); } nsSize prefSize = mLayoutManager->GetXULPrefSize(this, aBoxLayoutState); NS_FOR_FRAME_OVERFLOW_TYPES(otype) { nsRect& o = overflow.Overflow(otype); o.height = std::max(o.height, prefSize.height); } } FinishAndStoreOverflow(overflow, GetSize()); if (mScrolling) aBoxLayoutState.SetPaintingDisabled(false); // if we are scrolled and the row height changed // make sure we are scrolled to a correct index. if (mAdjustScroll) PostReflowCallback(); return rv; } nsSize nsListBoxBodyFrame::GetXULMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState) { nsSize result(0, 0); if (nsContentUtils::HasNonEmptyAttr(GetContent(), kNameSpaceID_None, nsGkAtoms::sizemode)) { result = GetXULPrefSize(aBoxLayoutState); result.height = 0; nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); if (scrollFrame && scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) { nsMargin scrollbars = scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState); result.width += scrollbars.left + scrollbars.right; } } return result; } nsSize nsListBoxBodyFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) { nsSize pref = nsBoxFrame::GetXULPrefSize(aBoxLayoutState); int32_t size = GetFixedRowSize(); if (size > -1) pref.height = size*GetRowHeightAppUnits(); nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); if (scrollFrame && scrollFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_AUTO) { nsMargin scrollbars = scrollFrame->GetDesiredScrollbarSizes(&aBoxLayoutState); pref.width += scrollbars.left + scrollbars.right; } return pref; } ///////////// nsIScrollbarMediator /////////////// void nsListBoxBodyFrame::ScrollByPage(nsScrollbarFrame* aScrollbar, int32_t aDirection, nsIScrollbarMediator::ScrollSnapMode aSnap) { // CSS Scroll Snapping is not enabled for XUL, aSnap is ignored MOZ_ASSERT(aScrollbar != nullptr); aScrollbar->SetIncrementToPage(aDirection); nsWeakFrame weakFrame(this); int32_t newPos = aScrollbar->MoveToNewPosition(); if (!weakFrame.IsAlive()) { return; } UpdateIndex(newPos); } void nsListBoxBodyFrame::ScrollByWhole(nsScrollbarFrame* aScrollbar, int32_t aDirection, nsIScrollbarMediator::ScrollSnapMode aSnap) { // CSS Scroll Snapping is not enabled for XUL, aSnap is ignored MOZ_ASSERT(aScrollbar != nullptr); aScrollbar->SetIncrementToWhole(aDirection); nsWeakFrame weakFrame(this); int32_t newPos = aScrollbar->MoveToNewPosition(); if (!weakFrame.IsAlive()) { return; } UpdateIndex(newPos); } void nsListBoxBodyFrame::ScrollByLine(nsScrollbarFrame* aScrollbar, int32_t aDirection, nsIScrollbarMediator::ScrollSnapMode aSnap) { // CSS Scroll Snapping is not enabled for XUL, aSnap is ignored MOZ_ASSERT(aScrollbar != nullptr); aScrollbar->SetIncrementToLine(aDirection); nsWeakFrame weakFrame(this); int32_t newPos = aScrollbar->MoveToNewPosition(); if (!weakFrame.IsAlive()) { return; } UpdateIndex(newPos); } void nsListBoxBodyFrame::RepeatButtonScroll(nsScrollbarFrame* aScrollbar) { nsWeakFrame weakFrame(this); int32_t newPos = aScrollbar->MoveToNewPosition(); if (!weakFrame.IsAlive()) { return; } UpdateIndex(newPos); } int32_t nsListBoxBodyFrame::ToRowIndex(nscoord aPos) const { return NS_roundf(float(std::max(aPos, 0)) / mRowHeight); } void nsListBoxBodyFrame::ThumbMoved(nsScrollbarFrame* aScrollbar, nscoord aOldPos, nscoord aNewPos) { if (mScrolling || mRowHeight == 0) return; int32_t newIndex = ToRowIndex(aNewPos); if (newIndex == mCurrentIndex) { return; } int32_t rowDelta = newIndex - mCurrentIndex; nsListScrollSmoother* smoother = GetSmoother(); // if we can't scroll the rows in time then start a timer. We will eat // events until the user stops moving and the timer stops. if (smoother->IsRunning() || Abs(rowDelta)*mTimePerRow > USER_TIME_THRESHOLD) { smoother->Stop(); smoother->mDelta = rowDelta; smoother->Start(); return; } smoother->Stop(); mCurrentIndex = newIndex; smoother->mDelta = 0; if (mCurrentIndex < 0) { mCurrentIndex = 0; return; } InternalPositionChanged(rowDelta < 0, Abs(rowDelta)); } void nsListBoxBodyFrame::VisibilityChanged(bool aVisible) { if (mRowHeight == 0) return; int32_t lastPageTopRow = GetRowCount() - (GetAvailableHeight() / mRowHeight); if (lastPageTopRow < 0) lastPageTopRow = 0; int32_t delta = mCurrentIndex - lastPageTopRow; if (delta > 0) { mCurrentIndex = lastPageTopRow; InternalPositionChanged(true, delta); } } nsIFrame* nsListBoxBodyFrame::GetScrollbarBox(bool aVertical) { nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); return scrollFrame ? scrollFrame->GetScrollbarBox(true) : nullptr; } void nsListBoxBodyFrame::UpdateIndex(int32_t aNewPos) { int32_t newIndex = ToRowIndex(nsPresContext::CSSPixelsToAppUnits(aNewPos)); if (newIndex == mCurrentIndex) { return; } bool up = newIndex < mCurrentIndex; int32_t indexDelta = Abs(newIndex - mCurrentIndex); mCurrentIndex = newIndex; InternalPositionChanged(up, indexDelta); } ///////////// nsIReflowCallback /////////////// bool nsListBoxBodyFrame::ReflowFinished() { nsAutoScriptBlocker scriptBlocker; // now create or destroy any rows as needed CreateRows(); // keep scrollbar in sync if (mAdjustScroll) { VerticalScroll(mYPosition); mAdjustScroll = false; } // if the row height changed then mark everything as a style change. // That will dirty the entire listbox if (mRowHeightWasSet) { PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY); int32_t pos = mCurrentIndex * mRowHeight; if (mYPosition != pos) mAdjustScroll = true; mRowHeightWasSet = false; } mReflowCallbackPosted = false; return true; } void nsListBoxBodyFrame::ReflowCallbackCanceled() { mReflowCallbackPosted = false; } ///////// ListBoxObject /////////////// int32_t nsListBoxBodyFrame::GetNumberOfVisibleRows() { return mRowHeight ? GetAvailableHeight() / mRowHeight : 0; } int32_t nsListBoxBodyFrame::GetIndexOfFirstVisibleRow() { return mCurrentIndex; } nsresult nsListBoxBodyFrame::EnsureIndexIsVisible(int32_t aRowIndex) { if (aRowIndex < 0) return NS_ERROR_ILLEGAL_VALUE; int32_t rows = 0; if (mRowHeight) rows = GetAvailableHeight()/mRowHeight; if (rows <= 0) rows = 1; int32_t bottomIndex = mCurrentIndex + rows; // if row is visible, ignore if (mCurrentIndex <= aRowIndex && aRowIndex < bottomIndex) return NS_OK; int32_t delta; bool up = aRowIndex < mCurrentIndex; if (up) { delta = mCurrentIndex - aRowIndex; mCurrentIndex = aRowIndex; } else { // Check to be sure we're not scrolling off the bottom of the tree if (aRowIndex >= GetRowCount()) return NS_ERROR_ILLEGAL_VALUE; // Bring it just into view. delta = 1 + (aRowIndex-bottomIndex); mCurrentIndex += delta; } // Safe to not go off an event here, since this is coming from the // box object. DoInternalPositionChangedSync(up, delta); return NS_OK; } nsresult nsListBoxBodyFrame::ScrollByLines(int32_t aNumLines) { int32_t scrollIndex = GetIndexOfFirstVisibleRow(), visibleRows = GetNumberOfVisibleRows(); scrollIndex += aNumLines; if (scrollIndex < 0) scrollIndex = 0; else { int32_t numRows = GetRowCount(); int32_t lastPageTopRow = numRows - visibleRows; if (scrollIndex > lastPageTopRow) scrollIndex = lastPageTopRow; } ScrollToIndex(scrollIndex); return NS_OK; } // walks the DOM to get the zero-based row index of the content nsresult nsListBoxBodyFrame::GetIndexOfItem(nsIDOMElement* aItem, int32_t* _retval) { if (aItem) { *_retval = 0; nsCOMPtr<nsIContent> itemContent(do_QueryInterface(aItem)); FlattenedChildIterator iter(mContent); for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { // we hit a list row, count it if (child->IsXULElement(nsGkAtoms::listitem)) { // is this it? if (child == itemContent) return NS_OK; ++(*_retval); } } } // not found *_retval = -1; return NS_OK; } nsresult nsListBoxBodyFrame::GetItemAtIndex(int32_t aIndex, nsIDOMElement** aItem) { *aItem = nullptr; if (aIndex < 0) return NS_OK; int32_t itemCount = 0; FlattenedChildIterator iter(mContent); for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { // we hit a list row, check if it is the one we are looking for if (child->IsXULElement(nsGkAtoms::listitem)) { // is this it? if (itemCount == aIndex) { return CallQueryInterface(child, aItem); } ++itemCount; } } // not found return NS_OK; } /////////// nsListBoxBodyFrame /////////////// int32_t nsListBoxBodyFrame::GetRowCount() { if (mRowCount < 0) ComputeTotalRowCount(); return mRowCount; } int32_t nsListBoxBodyFrame::GetFixedRowSize() { nsresult dummy; nsAutoString rows; mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::rows, rows); if (!rows.IsEmpty()) return rows.ToInteger(&dummy); mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::size, rows); if (!rows.IsEmpty()) return rows.ToInteger(&dummy); return -1; } void nsListBoxBodyFrame::SetRowHeight(nscoord aRowHeight) { if (aRowHeight > mRowHeight) { mRowHeight = aRowHeight; // signal we need to dirty everything // and we want to be notified after reflow // so we can create or destory rows as needed mRowHeightWasSet = true; PostReflowCallback(); } } nscoord nsListBoxBodyFrame::GetAvailableHeight() { nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); if (scrollFrame) { return scrollFrame->GetScrollPortRect().height; } return 0; } nscoord nsListBoxBodyFrame::GetYPosition() { return mYPosition; } nscoord nsListBoxBodyFrame::ComputeIntrinsicISize(nsBoxLayoutState& aBoxLayoutState) { if (mStringWidth != -1) return mStringWidth; nscoord largestWidth = 0; int32_t index = 0; nsCOMPtr<nsIDOMElement> firstRowEl; GetItemAtIndex(index, getter_AddRefs(firstRowEl)); nsCOMPtr<nsIContent> firstRowContent(do_QueryInterface(firstRowEl)); if (firstRowContent) { RefPtr<nsStyleContext> styleContext; nsPresContext *presContext = aBoxLayoutState.PresContext(); styleContext = presContext->StyleSet()-> ResolveStyleFor(firstRowContent->AsElement(), nullptr); nscoord width = 0; nsMargin margin(0,0,0,0); if (styleContext->StylePadding()->GetPadding(margin)) width += margin.LeftRight(); width += styleContext->StyleBorder()->GetComputedBorder().LeftRight(); if (styleContext->StyleMargin()->GetMargin(margin)) width += margin.LeftRight(); FlattenedChildIterator iter(mContent); for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { if (child->IsXULElement(nsGkAtoms::listitem)) { nsRenderingContext* rendContext = aBoxLayoutState.GetRenderingContext(); if (rendContext) { nsAutoString value; uint32_t textCount = child->GetChildCount(); for (uint32_t j = 0; j < textCount; ++j) { nsIContent* text = child->GetChildAt(j); if (text && text->IsNodeOfType(nsINode::eTEXT)) { text->AppendTextTo(value); } } RefPtr<nsFontMetrics> fm = nsLayoutUtils::GetFontMetricsForStyleContext(styleContext); nscoord textWidth = nsLayoutUtils::AppUnitWidthOfStringBidi(value, this, *fm, *rendContext); textWidth += width; if (textWidth > largestWidth) largestWidth = textWidth; } } } } mStringWidth = largestWidth; return mStringWidth; } void nsListBoxBodyFrame::ComputeTotalRowCount() { mRowCount = 0; FlattenedChildIterator iter(mContent); for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { if (child->IsXULElement(nsGkAtoms::listitem)) { ++mRowCount; } } } void nsListBoxBodyFrame::PostReflowCallback() { if (!mReflowCallbackPosted) { mReflowCallbackPosted = true; PresContext()->PresShell()->PostReflowCallback(this); } } ////////// scrolling nsresult nsListBoxBodyFrame::ScrollToIndex(int32_t aRowIndex) { if (( aRowIndex < 0 ) || (mRowHeight == 0)) return NS_OK; int32_t newIndex = aRowIndex; int32_t delta = mCurrentIndex > newIndex ? mCurrentIndex - newIndex : newIndex - mCurrentIndex; bool up = newIndex < mCurrentIndex; // Check to be sure we're not scrolling off the bottom of the tree int32_t lastPageTopRow = GetRowCount() - (GetAvailableHeight() / mRowHeight); if (lastPageTopRow < 0) lastPageTopRow = 0; if (aRowIndex > lastPageTopRow) return NS_OK; mCurrentIndex = newIndex; nsWeakFrame weak(this); // Since we're going to flush anyway, we need to not do this off an event DoInternalPositionChangedSync(up, delta); if (!weak.IsAlive()) { return NS_OK; } // This change has to happen immediately. // Flush any pending reflow commands. // XXXbz why, exactly? mContent->GetComposedDoc()->FlushPendingNotifications(Flush_Layout); return NS_OK; } nsresult nsListBoxBodyFrame::InternalPositionChangedCallback() { nsListScrollSmoother* smoother = GetSmoother(); if (smoother->mDelta == 0) return NS_OK; mCurrentIndex += smoother->mDelta; if (mCurrentIndex < 0) mCurrentIndex = 0; return DoInternalPositionChangedSync(smoother->mDelta < 0, smoother->mDelta < 0 ? -smoother->mDelta : smoother->mDelta); } nsresult nsListBoxBodyFrame::InternalPositionChanged(bool aUp, int32_t aDelta) { RefPtr<nsPositionChangedEvent> ev = new nsPositionChangedEvent(this, aUp, aDelta); nsresult rv = NS_DispatchToCurrentThread(ev); if (NS_SUCCEEDED(rv)) { if (!mPendingPositionChangeEvents.AppendElement(ev)) { rv = NS_ERROR_OUT_OF_MEMORY; ev->Revoke(); } } return rv; } nsresult nsListBoxBodyFrame::DoInternalPositionChangedSync(bool aUp, int32_t aDelta) { nsWeakFrame weak(this); // Process all the pending position changes first nsTArray< RefPtr<nsPositionChangedEvent> > temp; temp.SwapElements(mPendingPositionChangeEvents); for (uint32_t i = 0; i < temp.Length(); ++i) { if (weak.IsAlive()) { temp[i]->Run(); } temp[i]->Revoke(); } if (!weak.IsAlive()) { return NS_OK; } return DoInternalPositionChanged(aUp, aDelta); } nsresult nsListBoxBodyFrame::DoInternalPositionChanged(bool aUp, int32_t aDelta) { if (aDelta == 0) return NS_OK; RefPtr<nsPresContext> presContext(PresContext()); nsBoxLayoutState state(presContext); // begin timing how long it takes to scroll a row PRTime start = PR_Now(); nsWeakFrame weakThis(this); mContent->GetComposedDoc()->FlushPendingNotifications(Flush_Layout); if (!weakThis.IsAlive()) { return NS_OK; } { nsAutoScriptBlocker scriptBlocker; int32_t visibleRows = 0; if (mRowHeight) visibleRows = GetAvailableHeight()/mRowHeight; if (aDelta < visibleRows) { int32_t loseRows = aDelta; if (aUp) { // scrolling up, destroy rows from the bottom downwards ReverseDestroyRows(loseRows); mRowsToPrepend += aDelta; mLinkupFrame = nullptr; } else { // scrolling down, destroy rows from the top upwards DestroyRows(loseRows); mRowsToPrepend = 0; } } else { // We have scrolled so much that all of our current frames will // go off screen, so blow them all away. Weeee! nsIFrame *currBox = mFrames.FirstChild(); nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor(); fc->BeginUpdate(); while (currBox) { nsIFrame *nextBox = currBox->GetNextSibling(); RemoveChildFrame(state, currBox); currBox = nextBox; } fc->EndUpdate(); } // clear frame markers so that CreateRows will re-create mTopFrame = mBottomFrame = nullptr; mYPosition = mCurrentIndex*mRowHeight; mScrolling = true; presContext->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eResize, NS_FRAME_HAS_DIRTY_CHILDREN); } if (!weakThis.IsAlive()) { return NS_OK; } // Flush calls CreateRows // XXXbz there has to be a better way to do this than flushing! presContext->PresShell()->FlushPendingNotifications(Flush_Layout); if (!weakThis.IsAlive()) { return NS_OK; } mScrolling = false; VerticalScroll(mYPosition); PRTime end = PR_Now(); int32_t newTime = int32_t(end - start) / aDelta; // average old and new mTimePerRow = (newTime + mTimePerRow)/2; return NS_OK; } nsListScrollSmoother* nsListBoxBodyFrame::GetSmoother() { if (!mScrollSmoother) { mScrollSmoother = new nsListScrollSmoother(this); NS_ASSERTION(mScrollSmoother, "out of memory"); NS_IF_ADDREF(mScrollSmoother); } return mScrollSmoother; } void nsListBoxBodyFrame::VerticalScroll(int32_t aPosition) { nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); if (!scrollFrame) { return; } nsPoint scrollPosition = scrollFrame->GetScrollPosition(); nsWeakFrame weakFrame(this); scrollFrame->ScrollTo(nsPoint(scrollPosition.x, aPosition), nsIScrollableFrame::INSTANT); if (!weakFrame.IsAlive()) { return; } mYPosition = aPosition; } ////////// frame and box retrieval nsIFrame* nsListBoxBodyFrame::GetFirstFrame() { mTopFrame = mFrames.FirstChild(); return mTopFrame; } nsIFrame* nsListBoxBodyFrame::GetLastFrame() { return mFrames.LastChild(); } bool nsListBoxBodyFrame::SupportsOrdinalsInChildren() { return false; } ////////// lazy row creation and destruction void nsListBoxBodyFrame::CreateRows() { // Get our client rect. nsRect clientRect; GetXULClientRect(clientRect); // Get the starting y position and the remaining available // height. nscoord availableHeight = GetAvailableHeight(); if (availableHeight <= 0) { bool fixed = (GetFixedRowSize() != -1); if (fixed) availableHeight = 10; else return; } // get the first tree box. If there isn't one create one. bool created = false; nsIFrame* box = GetFirstItemBox(0, &created); nscoord rowHeight = GetRowHeightAppUnits(); while (box) { if (created && mRowsToPrepend > 0) --mRowsToPrepend; // if the row height is 0 then fail. Wait until someone // laid out and sets the row height. if (rowHeight == 0) return; availableHeight -= rowHeight; // should we continue? Is the enought height? if (!ContinueReflow(availableHeight)) break; // get the next tree box. Create one if needed. box = GetNextItemBox(box, 0, &created); } mRowsToPrepend = 0; mLinkupFrame = nullptr; } void nsListBoxBodyFrame::DestroyRows(int32_t& aRowsToLose) { // We need to destroy frames until our row count has been properly // reduced. A reflow will then pick up and create the new frames. nsIFrame* childFrame = GetFirstFrame(); nsBoxLayoutState state(PresContext()); nsCSSFrameConstructor* fc = PresContext()->PresShell()->FrameConstructor(); fc->BeginUpdate(); while (childFrame && aRowsToLose > 0) { --aRowsToLose; nsIFrame* nextFrame = childFrame->GetNextSibling(); RemoveChildFrame(state, childFrame); mTopFrame = childFrame = nextFrame; } fc->EndUpdate(); PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } void nsListBoxBodyFrame::ReverseDestroyRows(int32_t& aRowsToLose) { // We need to destroy frames until our row count has been properly // reduced. A reflow will then pick up and create the new frames. nsIFrame* childFrame = GetLastFrame(); nsBoxLayoutState state(PresContext()); nsCSSFrameConstructor* fc = PresContext()->PresShell()->FrameConstructor(); fc->BeginUpdate(); while (childFrame && aRowsToLose > 0) { --aRowsToLose; nsIFrame* prevFrame; prevFrame = childFrame->GetPrevSibling(); RemoveChildFrame(state, childFrame); mBottomFrame = childFrame = prevFrame; } fc->EndUpdate(); PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } static bool IsListItemChild(nsListBoxBodyFrame* aParent, nsIContent* aChild, nsIFrame** aChildFrame) { *aChildFrame = nullptr; if (!aChild->IsXULElement(nsGkAtoms::listitem)) { return false; } nsIFrame* existingFrame = aChild->GetPrimaryFrame(); if (existingFrame && existingFrame->GetParent() != aParent) { return false; } *aChildFrame = existingFrame; return true; } // // Get the nsIFrame for the first visible listitem, and if none exists, // create one. // nsIFrame* nsListBoxBodyFrame::GetFirstItemBox(int32_t aOffset, bool* aCreated) { if (aCreated) *aCreated = false; // Clear ourselves out. mBottomFrame = mTopFrame; if (mTopFrame) { return mTopFrame->IsXULBoxFrame() ? mTopFrame : nullptr; } // top frame was cleared out mTopFrame = GetFirstFrame(); mBottomFrame = mTopFrame; if (mTopFrame && mRowsToPrepend <= 0) { return mTopFrame->IsXULBoxFrame() ? mTopFrame : nullptr; } // At this point, we either have no frames at all, // or the user has scrolled upwards, leaving frames // to be created at the top. Let's determine which // content needs a new frame first. nsCOMPtr<nsIContent> startContent; if (mTopFrame && mRowsToPrepend > 0) { // We need to insert rows before the top frame nsIContent* topContent = mTopFrame->GetContent(); nsIContent* topParent = topContent->GetParent(); int32_t contentIndex = topParent->IndexOf(topContent); contentIndex -= aOffset; if (contentIndex < 0) return nullptr; startContent = topParent->GetChildAt(contentIndex - mRowsToPrepend); } else { // This will be the first item frame we create. Use the content // at the current index, which is the first index scrolled into view GetListItemContentAt(mCurrentIndex+aOffset, getter_AddRefs(startContent)); } if (startContent) { nsIFrame* existingFrame; if (!IsListItemChild(this, startContent, &existingFrame)) { return GetFirstItemBox(++aOffset, aCreated); } if (existingFrame) { return existingFrame->IsXULBoxFrame() ? existingFrame : nullptr; } // Either append the new frame, or prepend it (at index 0) // XXX check here if frame was even created, it may not have been if // display: none was on listitem content bool isAppend = mRowsToPrepend <= 0; nsPresContext* presContext = PresContext(); nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor(); nsIFrame* topFrame = nullptr; fc->CreateListBoxContent(this, nullptr, startContent, &topFrame, isAppend); mTopFrame = topFrame; if (mTopFrame) { if (aCreated) *aCreated = true; mBottomFrame = mTopFrame; return mTopFrame->IsXULBoxFrame() ? mTopFrame : nullptr; } else return GetFirstItemBox(++aOffset, 0); } return nullptr; } // // Get the nsIFrame for the next visible listitem after aBox, and if none // exists, create one. // nsIFrame* nsListBoxBodyFrame::GetNextItemBox(nsIFrame* aBox, int32_t aOffset, bool* aCreated) { if (aCreated) *aCreated = false; nsIFrame* result = aBox->GetNextSibling(); if (!result || result == mLinkupFrame || mRowsToPrepend > 0) { // No result found. See if there's a content node that wants a frame. nsIContent* prevContent = aBox->GetContent(); nsIContent* parentContent = prevContent->GetParent(); int32_t i = parentContent->IndexOf(prevContent); uint32_t childCount = parentContent->GetChildCount(); if (((uint32_t)i + aOffset + 1) < childCount) { // There is a content node that wants a frame. nsIContent *nextContent = parentContent->GetChildAt(i + aOffset + 1); nsIFrame* existingFrame; if (!IsListItemChild(this, nextContent, &existingFrame)) { return GetNextItemBox(aBox, ++aOffset, aCreated); } if (!existingFrame) { // Either append the new frame, or insert it after the current frame bool isAppend = result != mLinkupFrame && mRowsToPrepend <= 0; nsIFrame* prevFrame = isAppend ? nullptr : aBox; nsPresContext* presContext = PresContext(); nsCSSFrameConstructor* fc = presContext->PresShell()->FrameConstructor(); fc->CreateListBoxContent(this, prevFrame, nextContent, &result, isAppend); if (result) { if (aCreated) *aCreated = true; } else return GetNextItemBox(aBox, ++aOffset, aCreated); } else { result = existingFrame; } mLinkupFrame = nullptr; } } if (!result) return nullptr; mBottomFrame = result; NS_ASSERTION(!result->IsXULBoxFrame() || result->GetParent() == this, "returning frame that is not in childlist"); return result->IsXULBoxFrame() ? result : nullptr; } bool nsListBoxBodyFrame::ContinueReflow(nscoord height) { #ifdef ACCESSIBILITY if (nsIPresShell::IsAccessibilityActive()) { // Create all the frames at once so screen readers and // onscreen keyboards can see the full list right away return true; } #endif if (height <= 0) { nsIFrame* lastChild = GetLastFrame(); nsIFrame* startingPoint = mBottomFrame; if (startingPoint == nullptr) { // We just want to delete everything but the first item. startingPoint = GetFirstFrame(); } if (lastChild != startingPoint) { // We have some hangers on (probably caused by shrinking the size of the window). // Nuke them. nsIFrame* currFrame = startingPoint->GetNextSibling(); nsBoxLayoutState state(PresContext()); nsCSSFrameConstructor* fc = PresContext()->PresShell()->FrameConstructor(); fc->BeginUpdate(); while (currFrame) { nsIFrame* nextFrame = currFrame->GetNextSibling(); RemoveChildFrame(state, currFrame); currFrame = nextFrame; } fc->EndUpdate(); PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } return false; } else return true; } NS_IMETHODIMP nsListBoxBodyFrame::ListBoxAppendFrames(nsFrameList& aFrameList) { // append them after nsBoxLayoutState state(PresContext()); const nsFrameList::Slice& newFrames = mFrames.AppendFrames(nullptr, aFrameList); if (mLayoutManager) mLayoutManager->ChildrenAppended(this, state, newFrames); PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); return NS_OK; } NS_IMETHODIMP nsListBoxBodyFrame::ListBoxInsertFrames(nsIFrame* aPrevFrame, nsFrameList& aFrameList) { // insert the frames to our info list nsBoxLayoutState state(PresContext()); const nsFrameList::Slice& newFrames = mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList); if (mLayoutManager) mLayoutManager->ChildrenInserted(this, state, aPrevFrame, newFrames); PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); return NS_OK; } // // Called by nsCSSFrameConstructor when a new listitem content is inserted. // void nsListBoxBodyFrame::OnContentInserted(nsIContent* aChildContent) { if (mRowCount >= 0) ++mRowCount; // The RDF content builder will build content nodes such that they are all // ready when OnContentInserted is first called, meaning the first call // to CreateRows will create all the frames, but OnContentInserted will // still be called again for each content node - so we need to make sure // that the frame for each content node hasn't already been created. nsIFrame* childFrame = aChildContent->GetPrimaryFrame(); if (childFrame) return; int32_t siblingIndex; nsCOMPtr<nsIContent> nextSiblingContent; GetListItemNextSibling(aChildContent, getter_AddRefs(nextSiblingContent), siblingIndex); // if we're inserting our item before the first visible content, // then we need to shift all rows down by one if (siblingIndex >= 0 && siblingIndex-1 <= mCurrentIndex) { mTopFrame = nullptr; mRowsToPrepend = 1; } else if (nextSiblingContent) { // we may be inserting before a frame that is on screen nsIFrame* nextSiblingFrame = nextSiblingContent->GetPrimaryFrame(); mLinkupFrame = nextSiblingFrame; } CreateRows(); PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } // // Called by nsCSSFrameConstructor when listitem content is removed. // void nsListBoxBodyFrame::OnContentRemoved(nsPresContext* aPresContext, nsIContent* aContainer, nsIFrame* aChildFrame, nsIContent* aOldNextSibling) { NS_ASSERTION(!aChildFrame || aChildFrame->GetParent() == this, "Removing frame that's not our child... Not good"); if (mRowCount >= 0) --mRowCount; if (aContainer) { if (!aChildFrame) { // The row we are removing is out of view, so we need to try to // determine the index of its next sibling. int32_t siblingIndex = -1; if (aOldNextSibling) { nsCOMPtr<nsIContent> nextSiblingContent; GetListItemNextSibling(aOldNextSibling, getter_AddRefs(nextSiblingContent), siblingIndex); } // if the row being removed is off-screen and above the top frame, we need to // adjust our top index and tell the scrollbar to shift up one row. if (siblingIndex >= 0 && siblingIndex-1 < mCurrentIndex) { NS_PRECONDITION(mCurrentIndex > 0, "mCurrentIndex > 0"); --mCurrentIndex; mYPosition = mCurrentIndex*mRowHeight; nsWeakFrame weakChildFrame(aChildFrame); VerticalScroll(mYPosition); if (!weakChildFrame.IsAlive()) { return; } } } else if (mCurrentIndex > 0) { // At this point, we know we have a scrollbar, and we need to know // if we are scrolled to the last row. In this case, the behavior // of the scrollbar is to stay locked to the bottom. Since we are // removing visible content, the first visible row will have to move // down by one, and we will have to insert a new frame at the top. // if the last content node has a frame, we are scrolled to the bottom nsIContent* lastChild = nullptr; FlattenedChildIterator iter(mContent); for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { lastChild = child; } if (lastChild) { nsIFrame* lastChildFrame = lastChild->GetPrimaryFrame(); if (lastChildFrame) { mTopFrame = nullptr; mRowsToPrepend = 1; --mCurrentIndex; mYPosition = mCurrentIndex*mRowHeight; nsWeakFrame weakChildFrame(aChildFrame); VerticalScroll(mYPosition); if (!weakChildFrame.IsAlive()) { return; } } } } } // if we're removing the top row, the new top row is the next row if (mTopFrame && mTopFrame == aChildFrame) mTopFrame = mTopFrame->GetNextSibling(); // Go ahead and delete the frame. nsBoxLayoutState state(aPresContext); if (aChildFrame) { RemoveChildFrame(state, aChildFrame); } PresContext()->PresShell()-> FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_HAS_DIRTY_CHILDREN); } void nsListBoxBodyFrame::GetListItemContentAt(int32_t aIndex, nsIContent** aContent) { *aContent = nullptr; int32_t itemsFound = 0; FlattenedChildIterator iter(mContent); for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { if (child->IsXULElement(nsGkAtoms::listitem)) { ++itemsFound; if (itemsFound-1 == aIndex) { *aContent = child; NS_IF_ADDREF(*aContent); return; } } } } void nsListBoxBodyFrame::GetListItemNextSibling(nsIContent* aListItem, nsIContent** aContent, int32_t& aSiblingIndex) { *aContent = nullptr; aSiblingIndex = -1; nsIContent *prevKid = nullptr; FlattenedChildIterator iter(mContent); for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { if (child->IsXULElement(nsGkAtoms::listitem)) { ++aSiblingIndex; if (prevKid == aListItem) { *aContent = child; NS_IF_ADDREF(*aContent); return; } } prevKid = child; } aSiblingIndex = -1; // no match, so there is no next sibling } void nsListBoxBodyFrame::RemoveChildFrame(nsBoxLayoutState &aState, nsIFrame *aFrame) { MOZ_ASSERT(mFrames.ContainsFrame(aFrame)); MOZ_ASSERT(aFrame != GetContentInsertionFrame()); #ifdef ACCESSIBILITY nsAccessibilityService* accService = nsIPresShell::AccService(); if (accService) { nsIContent* content = aFrame->GetContent(); accService->ContentRemoved(PresContext()->PresShell(), content); } #endif mFrames.RemoveFrame(aFrame); if (mLayoutManager) mLayoutManager->ChildrenRemoved(this, aState, aFrame); aFrame->Destroy(); } // Creation Routines /////////////////////////////////////////////////////////////////////// already_AddRefed<nsBoxLayout> NS_NewListBoxLayout(); nsIFrame* NS_NewListBoxBodyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext) { nsCOMPtr<nsBoxLayout> layout = NS_NewListBoxLayout(); return new (aPresShell) nsListBoxBodyFrame(aContext, layout); } NS_IMPL_FRAMEARENA_HELPERS(nsListBoxBodyFrame)