wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
d89cfb8610
gecko/layout/generic/nsGfxScrollFrame.h
Ryan VanderMeulen 2bf6dfd88c Backed out 6 changesets (bug 982141) for Windows and OSX bustage. CLOSED TREE 
Backed out changeset 16540ab2d2cb (bug 982141)
Backed out changeset 2ad9ce9d904e (bug 982141)
Backed out changeset af219bb49c06 (bug 982141)
Backed out changeset ffe51d96e86e (bug 982141)
Backed out changeset 6642718ad3bb (bug 982141)
Backed out changeset 95b341d26f7b (bug 982141)
2014-04-10 15:27:42 -04:00

1031 lines
38 KiB
C++
Raw Blame History

/* -*- 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/. */
/* rendering object to wrap rendering objects that should be scrollable */
#ifndef nsGfxScrollFrame_h___
#define nsGfxScrollFrame_h___
#include "mozilla/Attributes.h"
#include "nsContainerFrame.h"
#include "nsIAnonymousContentCreator.h"
#include "nsBoxFrame.h"
#include "nsIScrollableFrame.h"
#include "nsIStatefulFrame.h"
#include "nsThreadUtils.h"
#include "nsIReflowCallback.h"
#include "nsBoxLayoutState.h"
#include "nsQueryFrame.h"
#include "nsExpirationTracker.h"
class nsPresContext;
class nsIPresShell;
class nsIContent;
class nsIAtom;
class nsIScrollFrameInternal;
class nsPresState;
class nsIScrollPositionListener;
struct ScrollReflowState;
namespace mozilla {
namespace layout {
class ScrollbarActivity;
}
}
namespace mozilla {
class ScrollFrameHelper : public nsIReflowCallback {
public:
typedef mozilla::CSSIntPoint CSSIntPoint;
typedef mozilla::layout::ScrollbarActivity ScrollbarActivity;
class AsyncScroll;
ScrollFrameHelper(nsContainerFrame* aOuter, bool aIsRoot);
~ScrollFrameHelper();
mozilla::ScrollbarStyles GetScrollbarStylesFromFrame() const;
// If a child frame was added or removed on the scrollframe,
// reload our child frame list.
// We need this if a scrollbar frame is recreated.
void ReloadChildFrames();
nsresult CreateAnonymousContent(
nsTArray<nsIAnonymousContentCreator::ContentInfo>& aElements);
void AppendAnonymousContentTo(nsBaseContentList& aElements, uint32_t aFilter);
nsresult FireScrollPortEvent();
void PostOverflowEvent();
void Destroy();
void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists);
void AppendScrollPartsTo(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists,
bool& aCreateLayer,
bool aPositioned);
bool GetBorderRadii(nscoord aRadii[8]) const;
// nsIReflowCallback
virtual bool ReflowFinished() MOZ_OVERRIDE;
virtual void ReflowCallbackCanceled() MOZ_OVERRIDE;
/**
* @note This method might destroy the frame, pres shell and other objects.
* Called when the 'curpos' attribute on one of the scrollbars changes.
*/
void CurPosAttributeChanged(nsIContent* aChild);
void PostScrollEvent();
void FireScrollEvent();
void PostScrolledAreaEvent();
void FireScrolledAreaEvent();
class ScrollEvent : public nsRunnable {
public:
NS_DECL_NSIRUNNABLE
ScrollEvent(ScrollFrameHelper *helper) : mHelper(helper) {}
void Revoke() { mHelper = nullptr; }
private:
ScrollFrameHelper *mHelper;
};
class AsyncScrollPortEvent : public nsRunnable {
public:
NS_DECL_NSIRUNNABLE
AsyncScrollPortEvent(ScrollFrameHelper *helper) : mHelper(helper) {}
void Revoke() { mHelper = nullptr; }
private:
ScrollFrameHelper *mHelper;
};
class ScrolledAreaEvent : public nsRunnable {
public:
NS_DECL_NSIRUNNABLE
ScrolledAreaEvent(ScrollFrameHelper *helper) : mHelper(helper) {}
void Revoke() { mHelper = nullptr; }
private:
ScrollFrameHelper *mHelper;
};
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void FinishReflowForScrollbar(nsIContent* aContent, nscoord aMinXY,
nscoord aMaxXY, nscoord aCurPosXY,
nscoord aPageIncrement,
nscoord aIncrement);
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void SetScrollbarEnabled(nsIContent* aContent, nscoord aMaxPos);
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void SetCoordAttribute(nsIContent* aContent, nsIAtom* aAtom, nscoord aSize);
nscoord GetCoordAttribute(nsIFrame* aFrame, nsIAtom* aAtom, nscoord aDefaultValue,
nscoord* aRangeStart, nscoord* aRangeLength);
/**
* @note This method might destroy the frame, pres shell and other objects.
* Update scrollbar curpos attributes to reflect current scroll position
*/
void UpdateScrollbarPosition();
nsRect GetScrollPortRect() const { return mScrollPort; }
nsPoint GetScrollPosition() const {
return mScrollPort.TopLeft() - mScrolledFrame->GetPosition();
}
/**
* For LTR frames, the logical scroll position is the offset of the top left
* corner of the frame from the top left corner of the scroll port (same as
* GetScrollPosition).
* For RTL frames, it is the offset of the top right corner of the frame from
* the top right corner of the scroll port
*/
nsPoint GetLogicalScrollPosition() const {
nsPoint pt;
pt.x = IsLTR() ?
mScrollPort.x - mScrolledFrame->GetPosition().x :
mScrollPort.XMost() - mScrolledFrame->GetRect().XMost();
pt.y = mScrollPort.y - mScrolledFrame->GetPosition().y;
return pt;
}
nsRect GetScrollRange() const;
// Get the scroll range assuming the scrollport has size (aWidth, aHeight).
nsRect GetScrollRange(nscoord aWidth, nscoord aHeight) const;
nsSize GetScrollPositionClampingScrollPortSize() const;
protected:
nsRect GetScrollRangeForClamping() const;
public:
static void AsyncScrollCallback(void* anInstance, mozilla::TimeStamp aTime);
/**
* @note This method might destroy the frame, pres shell and other objects.
* aRange is the range of allowable scroll positions around the desired
* aScrollPosition. Null means only aScrollPosition is allowed.
* This is a closed-ended range --- aRange.XMost()/aRange.YMost() are allowed.
*/
void ScrollTo(nsPoint aScrollPosition, nsIScrollableFrame::ScrollMode aMode,
const nsRect* aRange = nullptr) {
ScrollToWithOrigin(aScrollPosition, aMode, nsGkAtoms::other, aRange);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void ScrollToCSSPixels(const CSSIntPoint& aScrollPosition);
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void ScrollToCSSPixelsApproximate(const mozilla::CSSPoint& aScrollPosition,
nsIAtom* aOrigin = nullptr);
CSSIntPoint GetScrollPositionCSSPixels();
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void ScrollToImpl(nsPoint aScrollPosition, const nsRect& aRange, nsIAtom* aOrigin = nullptr);
void ScrollVisual(nsPoint aOldScrolledFramePosition);
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void ScrollBy(nsIntPoint aDelta, nsIScrollableFrame::ScrollUnit aUnit,
nsIScrollableFrame::ScrollMode aMode, nsIntPoint* aOverflow, nsIAtom *aOrigin = nullptr);
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void ScrollToRestoredPosition();
nsSize GetLineScrollAmount() const;
nsSize GetPageScrollAmount() const;
nsPresState* SaveState();
void RestoreState(nsPresState* aState);
nsIFrame* GetScrolledFrame() const { return mScrolledFrame; }
nsIFrame* GetScrollbarBox(bool aVertical) const {
return aVertical ? mVScrollbarBox : mHScrollbarBox;
}
void AddScrollPositionListener(nsIScrollPositionListener* aListener) {
mListeners.AppendElement(aListener);
}
void RemoveScrollPositionListener(nsIScrollPositionListener* aListener) {
mListeners.RemoveElement(aListener);
}
static void SetScrollbarVisibility(nsIFrame* aScrollbar, bool aVisible);
/**
* GetScrolledRect is designed to encapsulate deciding which
* directions of overflow should be reachable by scrolling and which
* should not. Callers should NOT depend on it having any particular
* behavior (although nsXULScrollFrame currently does).
*
* This should only be called when the scrolled frame has been
* reflowed with the scroll port size given in mScrollPort.
*
* Currently it allows scrolling down and to the right for
* nsHTMLScrollFrames with LTR directionality and for all
* nsXULScrollFrames, and allows scrolling down and to the left for
* nsHTMLScrollFrames with RTL directionality.
*/
nsRect GetScrolledRect() const;
/**
* GetScrolledRectInternal is designed to encapsulate deciding which
* directions of overflow should be reachable by scrolling and which
* should not. Callers should NOT depend on it having any particular
* behavior (although nsXULScrollFrame currently does).
*
* Currently it allows scrolling down and to the right for
* nsHTMLScrollFrames with LTR directionality and for all
* nsXULScrollFrames, and allows scrolling down and to the left for
* nsHTMLScrollFrames with RTL directionality.
*/
nsRect GetScrolledRectInternal(const nsRect& aScrolledOverflowArea,
const nsSize& aScrollPortSize) const;
uint32_t GetScrollbarVisibility() const {
return (mHasVerticalScrollbar ? nsIScrollableFrame::VERTICAL : 0) |
(mHasHorizontalScrollbar ? nsIScrollableFrame::HORIZONTAL : 0);
}
nsMargin GetActualScrollbarSizes() const;
nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState);
nscoord GetNondisappearingScrollbarWidth(nsBoxLayoutState* aState);
bool IsLTR() const;
bool IsScrollbarOnRight() const;
bool IsScrollingActive() const { return mScrollingActive || mShouldBuildScrollableLayer; }
bool IsProcessingAsyncScroll() const { return mAsyncScroll != nullptr; }
void ResetScrollPositionForLayerPixelAlignment()
{
mScrollPosForLayerPixelAlignment = GetScrollPosition();
}
bool UpdateOverflow();
void UpdateSticky();
bool IsRectNearlyVisible(const nsRect& aRect) const;
// adjust the scrollbar rectangle aRect to account for any visible resizer.
// aHasResizer specifies if there is a content resizer, however this method
// will also check if a widget resizer is present as well.
void AdjustScrollbarRectForResizer(nsIFrame* aFrame, nsPresContext* aPresContext,
nsRect& aRect, bool aHasResizer, bool aVertical);
// returns true if a resizer should be visible
bool HasResizer() { return mResizerBox && !mCollapsedResizer; }
void LayoutScrollbars(nsBoxLayoutState& aState,
const nsRect& aContentArea,
const nsRect& aOldScrollArea);
bool IsIgnoringViewportClipping() const;
bool ShouldClampScrollPosition() const;
bool IsAlwaysActive() const;
void MarkActive();
void MarkInactive();
nsExpirationState* GetExpirationState() { return &mActivityExpirationState; }
void ScheduleSyntheticMouseMove();
static void ScrollActivityCallback(nsITimer *aTimer, void* anInstance);
void HandleScrollbarStyleSwitching();
nsIAtom* OriginOfLastScroll() const { return mOriginOfLastScroll; }
uint32_t CurrentScrollGeneration() const { return mScrollGeneration; }
void ResetOriginIfScrollAtGeneration(uint32_t aGeneration) {
if (aGeneration == mScrollGeneration) {
mOriginOfLastScroll = nullptr;
}
}
bool WantAsyncScroll() const;
// owning references to the nsIAnonymousContentCreator-built content
nsCOMPtr<nsIContent> mHScrollbarContent;
nsCOMPtr<nsIContent> mVScrollbarContent;
nsCOMPtr<nsIContent> mScrollCornerContent;
nsCOMPtr<nsIContent> mResizerContent;
nsRevocableEventPtr<ScrollEvent> mScrollEvent;
nsRevocableEventPtr<AsyncScrollPortEvent> mAsyncScrollPortEvent;
nsRevocableEventPtr<ScrolledAreaEvent> mScrolledAreaEvent;
nsIFrame* mHScrollbarBox;
nsIFrame* mVScrollbarBox;
nsIFrame* mScrolledFrame;
nsIFrame* mScrollCornerBox;
nsIFrame* mResizerBox;
nsContainerFrame* mOuter;
nsRefPtr<AsyncScroll> mAsyncScroll;
nsRefPtr<ScrollbarActivity> mScrollbarActivity;
nsTArray<nsIScrollPositionListener*> mListeners;
nsIAtom* mOriginOfLastScroll;
uint32_t mScrollGeneration;
nsRect mScrollPort;
// Where we're currently scrolling to, if we're scrolling asynchronously.
// If we're not in the middle of an asynchronous scroll then this is
// just the current scroll position. ScrollBy will choose its
// destination based on this value.
nsPoint mDestination;
nsPoint mScrollPosAtLastPaint;
// A goal position to try to scroll to as content loads. As long as mLastPos
// matches the current logical scroll position, we try to scroll to mRestorePos
// after every reflow --- because after each time content is loaded/added to the
// scrollable element, there will be a reflow.
nsPoint mRestorePos;
// The last logical position we scrolled to while trying to restore mRestorePos, or
// 0,0 when this is a new frame. Set to -1,-1 once we've scrolled for any reason
// other than trying to restore mRestorePos.
nsPoint mLastPos;
nsExpirationState mActivityExpirationState;
nsCOMPtr<nsITimer> mScrollActivityTimer;
nsPoint mScrollPosForLayerPixelAlignment;
// The scroll position where we last updated image visibility.
nsPoint mLastUpdateImagesPos;
bool mNeverHasVerticalScrollbar:1;
bool mNeverHasHorizontalScrollbar:1;
bool mHasVerticalScrollbar:1;
bool mHasHorizontalScrollbar:1;
bool mFrameIsUpdatingScrollbar:1;
bool mDidHistoryRestore:1;
// Is this the scrollframe for the document's viewport?
bool mIsRoot:1;
// True if we should clip all descendants, false if we should only clip
// descendants for which we are the containing block.
bool mClipAllDescendants:1;
// If true, don't try to layout the scrollbars in Reflow(). This can be
// useful if multiple passes are involved, because we don't want to place the
// scrollbars at the wrong size.
bool mSupppressScrollbarUpdate:1;
// If true, we skipped a scrollbar layout due to mSupppressScrollbarUpdate
// being set at some point. That means we should lay out scrollbars even if
// it might not strictly be needed next time mSupppressScrollbarUpdate is
// false.
bool mSkippedScrollbarLayout:1;
bool mHadNonInitialReflow:1;
// State used only by PostScrollEvents so we know
// which overflow states have changed.
bool mHorizontalOverflow:1;
bool mVerticalOverflow:1;
bool mPostedReflowCallback:1;
bool mMayHaveDirtyFixedChildren:1;
// If true, need to actually update our scrollbar attributes in the
// reflow callback.
bool mUpdateScrollbarAttributes:1;
// If true, we should be prepared to scroll using this scrollframe
// by placing descendant content into its own layer(s)
bool mScrollingActive:1;
// If true, the resizer is collapsed and not displayed
bool mCollapsedResizer:1;
// If true, the layer should always be active because we always build a
// scrollable layer. Used for asynchronous scrolling.
bool mShouldBuildScrollableLayer:1;
// True if this frame has been scrolled at least once
bool mHasBeenScrolled:1;
protected:
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
void ScrollToWithOrigin(nsPoint aScrollPosition,
nsIScrollableFrame::ScrollMode aMode,
nsIAtom *aOrigin, // nullptr indicates "other" origin
const nsRect* aRange);
nsRect ExpandRect(const nsRect& aRect) const;
static void EnsureImageVisPrefsCached();
static bool sImageVisPrefsCached;
// The number of scrollports wide/high to expand when looking for images.
static uint32_t sHorzExpandScrollPort;
static uint32_t sVertExpandScrollPort;
// The fraction of the scrollport we allow to scroll by before we schedule
// an update of image visibility.
static int32_t sHorzScrollFraction;
static int32_t sVertScrollFraction;
};
}
/**
* The scroll frame creates and manages the scrolling view
*
* It only supports having a single child frame that typically is an area
* frame, but doesn't have to be. The child frame must have a view, though
*
* Scroll frames don't support incremental changes, i.e. you can't replace
* or remove the scrolled frame
*/
class nsHTMLScrollFrame : public nsContainerFrame,
public nsIScrollableFrame,
public nsIAnonymousContentCreator,
public nsIStatefulFrame {
public:
typedef mozilla::ScrollFrameHelper ScrollFrameHelper;
typedef mozilla::CSSIntPoint CSSIntPoint;
friend nsIFrame* NS_NewHTMLScrollFrame(nsIPresShell* aPresShell, nsStyleContext* aContext, bool aIsRoot);
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// Called to set the child frames. We typically have three: the scroll area,
// the vertical scrollbar, and the horizontal scrollbar.
virtual nsresult SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE {
mHelper.BuildDisplayList(aBuilder, aDirtyRect, aLists);
}
bool TryLayout(ScrollReflowState* aState,
nsHTMLReflowMetrics* aKidMetrics,
bool aAssumeVScroll, bool aAssumeHScroll,
bool aForce, nsresult* aResult);
bool ScrolledContentDependsOnHeight(ScrollReflowState* aState);
nsresult ReflowScrolledFrame(ScrollReflowState* aState,
bool aAssumeHScroll,
bool aAssumeVScroll,
nsHTMLReflowMetrics* aMetrics,
bool aFirstPass);
nsresult ReflowContents(ScrollReflowState* aState,
const nsHTMLReflowMetrics& aDesiredSize);
void PlaceScrollArea(const ScrollReflowState& aState,
const nsPoint& aScrollPosition);
nscoord GetIntrinsicVScrollbarWidth(nsRenderingContext *aRenderingContext);
virtual bool GetBorderRadii(nscoord aRadii[8]) const MOZ_OVERRIDE {
return mHelper.GetBorderRadii(aRadii);
}
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nsresult GetPadding(nsMargin& aPadding) MOZ_OVERRIDE;
virtual bool IsCollapsed() MOZ_OVERRIDE;
virtual nsresult Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool UpdateOverflow() MOZ_OVERRIDE {
return mHelper.UpdateOverflow();
}
// Because there can be only one child frame, these two function return
// NS_ERROR_FAILURE
virtual nsresult AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual nsresult RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) MOZ_OVERRIDE;
virtual nsIScrollableFrame* GetScrollTargetFrame() MOZ_OVERRIDE {
return this;
}
virtual nsIFrame* GetContentInsertionFrame() MOZ_OVERRIDE {
return mHelper.GetScrolledFrame()->GetContentInsertionFrame();
}
virtual bool DoesClipChildren() MOZ_OVERRIDE { return true; }
virtual nsSplittableType GetSplittableType() const MOZ_OVERRIDE;
virtual nsPoint GetPositionOfChildIgnoringScrolling(nsIFrame* aChild) MOZ_OVERRIDE
{ nsPoint pt = aChild->GetPosition();
if (aChild == mHelper.GetScrolledFrame()) pt += GetScrollPosition();
return pt;
}
// nsIAnonymousContentCreator
virtual nsresult CreateAnonymousContent(nsTArray<ContentInfo>& aElements) MOZ_OVERRIDE;
virtual void AppendAnonymousContentTo(nsBaseContentList& aElements,
uint32_t aFilter) MOZ_OVERRIDE;
// nsIScrollbarOwner
virtual nsIFrame* GetScrollbarBox(bool aVertical) MOZ_OVERRIDE {
return mHelper.GetScrollbarBox(aVertical);
}
virtual void ScrollbarActivityStarted() const MOZ_OVERRIDE;
virtual void ScrollbarActivityStopped() const MOZ_OVERRIDE;
// nsIScrollableFrame
virtual nsIFrame* GetScrolledFrame() const MOZ_OVERRIDE {
return mHelper.GetScrolledFrame();
}
virtual mozilla::ScrollbarStyles GetScrollbarStyles() const MOZ_OVERRIDE {
return mHelper.GetScrollbarStylesFromFrame();
}
virtual uint32_t GetScrollbarVisibility() const MOZ_OVERRIDE {
return mHelper.GetScrollbarVisibility();
}
virtual nsMargin GetActualScrollbarSizes() const MOZ_OVERRIDE {
return mHelper.GetActualScrollbarSizes();
}
virtual nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState) MOZ_OVERRIDE {
return mHelper.GetDesiredScrollbarSizes(aState);
}
virtual nsMargin GetDesiredScrollbarSizes(nsPresContext* aPresContext,
nsRenderingContext* aRC) MOZ_OVERRIDE {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return GetDesiredScrollbarSizes(&bls);
}
virtual nscoord GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
nsRenderingContext* aRC) MOZ_OVERRIDE {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return mHelper.GetNondisappearingScrollbarWidth(&bls);
}
virtual nsRect GetScrolledRect() const MOZ_OVERRIDE {
return mHelper.GetScrolledRect();
}
virtual nsRect GetScrollPortRect() const MOZ_OVERRIDE {
return mHelper.GetScrollPortRect();
}
virtual nsPoint GetScrollPosition() const MOZ_OVERRIDE {
return mHelper.GetScrollPosition();
}
virtual nsPoint GetLogicalScrollPosition() const MOZ_OVERRIDE {
return mHelper.GetLogicalScrollPosition();
}
virtual nsRect GetScrollRange() const MOZ_OVERRIDE {
return mHelper.GetScrollRange();
}
virtual nsSize GetScrollPositionClampingScrollPortSize() const MOZ_OVERRIDE {
return mHelper.GetScrollPositionClampingScrollPortSize();
}
virtual nsSize GetLineScrollAmount() const MOZ_OVERRIDE {
return mHelper.GetLineScrollAmount();
}
virtual nsSize GetPageScrollAmount() const MOZ_OVERRIDE {
return mHelper.GetPageScrollAmount();
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollTo(nsPoint aScrollPosition, ScrollMode aMode,
const nsRect* aRange = nullptr) MOZ_OVERRIDE {
mHelper.ScrollTo(aScrollPosition, aMode, aRange);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollToCSSPixels(const CSSIntPoint& aScrollPosition) MOZ_OVERRIDE {
mHelper.ScrollToCSSPixels(aScrollPosition);
}
virtual void ScrollToCSSPixelsApproximate(const mozilla::CSSPoint& aScrollPosition,
nsIAtom* aOrigin = nullptr) MOZ_OVERRIDE {
mHelper.ScrollToCSSPixelsApproximate(aScrollPosition, aOrigin);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual CSSIntPoint GetScrollPositionCSSPixels() MOZ_OVERRIDE {
return mHelper.GetScrollPositionCSSPixels();
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollBy(nsIntPoint aDelta, ScrollUnit aUnit, ScrollMode aMode,
nsIntPoint* aOverflow, nsIAtom *aOrigin = nullptr) MOZ_OVERRIDE {
mHelper.ScrollBy(aDelta, aUnit, aMode, aOverflow, aOrigin);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollToRestoredPosition() MOZ_OVERRIDE {
mHelper.ScrollToRestoredPosition();
}
virtual void AddScrollPositionListener(nsIScrollPositionListener* aListener) MOZ_OVERRIDE {
mHelper.AddScrollPositionListener(aListener);
}
virtual void RemoveScrollPositionListener(nsIScrollPositionListener* aListener) MOZ_OVERRIDE {
mHelper.RemoveScrollPositionListener(aListener);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void CurPosAttributeChanged(nsIContent* aChild) MOZ_OVERRIDE {
mHelper.CurPosAttributeChanged(aChild);
}
NS_IMETHOD PostScrolledAreaEventForCurrentArea() MOZ_OVERRIDE {
mHelper.PostScrolledAreaEvent();
return NS_OK;
}
virtual bool IsScrollingActive() MOZ_OVERRIDE {
return mHelper.IsScrollingActive();
}
virtual bool IsProcessingAsyncScroll() MOZ_OVERRIDE {
return mHelper.IsProcessingAsyncScroll();
}
virtual void ResetScrollPositionForLayerPixelAlignment() MOZ_OVERRIDE {
mHelper.ResetScrollPositionForLayerPixelAlignment();
}
virtual bool DidHistoryRestore() MOZ_OVERRIDE {
return mHelper.mDidHistoryRestore;
}
virtual void ClearDidHistoryRestore() MOZ_OVERRIDE {
mHelper.mDidHistoryRestore = false;
}
virtual bool IsRectNearlyVisible(const nsRect& aRect) MOZ_OVERRIDE {
return mHelper.IsRectNearlyVisible(aRect);
}
virtual nsIAtom* OriginOfLastScroll() MOZ_OVERRIDE {
return mHelper.OriginOfLastScroll();
}
virtual uint32_t CurrentScrollGeneration() MOZ_OVERRIDE {
return mHelper.CurrentScrollGeneration();
}
virtual void ResetOriginIfScrollAtGeneration(uint32_t aGeneration) MOZ_OVERRIDE {
mHelper.ResetOriginIfScrollAtGeneration(aGeneration);
}
virtual bool WantAsyncScroll() const MOZ_OVERRIDE {
return mHelper.WantAsyncScroll();
}
// nsIStatefulFrame
NS_IMETHOD SaveState(nsPresState** aState) MOZ_OVERRIDE {
NS_ENSURE_ARG_POINTER(aState);
*aState = mHelper.SaveState();
return NS_OK;
}
NS_IMETHOD RestoreState(nsPresState* aState) MOZ_OVERRIDE {
NS_ENSURE_ARG_POINTER(aState);
mHelper.RestoreState(aState);
return NS_OK;
}
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::scrollFrame
*/
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
#endif
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
#endif
protected:
nsHTMLScrollFrame(nsIPresShell* aShell, nsStyleContext* aContext, bool aIsRoot);
void SetSuppressScrollbarUpdate(bool aSuppress) {
mHelper.mSupppressScrollbarUpdate = aSuppress;
}
bool GuessHScrollbarNeeded(const ScrollReflowState& aState);
bool GuessVScrollbarNeeded(const ScrollReflowState& aState);
bool IsScrollbarUpdateSuppressed() const {
return mHelper.mSupppressScrollbarUpdate;
}
// Return whether we're in an "initial" reflow. Some reflows with
// NS_FRAME_FIRST_REFLOW set are NOT "initial" as far as we're concerned.
bool InInitialReflow() const;
/**
* Override this to return false if computed height/min-height/max-height
* should NOT be propagated to child content.
* nsListControlFrame uses this.
*/
virtual bool ShouldPropagateComputedHeightToScrolledContent() const { return true; }
private:
friend class mozilla::ScrollFrameHelper;
ScrollFrameHelper mHelper;
};
/**
* The scroll frame creates and manages the scrolling view
*
* It only supports having a single child frame that typically is an area
* frame, but doesn't have to be. The child frame must have a view, though
*
* Scroll frames don't support incremental changes, i.e. you can't replace
* or remove the scrolled frame
*/
class nsXULScrollFrame : public nsBoxFrame,
public nsIScrollableFrame,
public nsIAnonymousContentCreator,
public nsIStatefulFrame {
public:
typedef mozilla::ScrollFrameHelper ScrollFrameHelper;
typedef mozilla::CSSIntPoint CSSIntPoint;
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewXULScrollFrame(nsIPresShell* aPresShell, nsStyleContext* aContext,
bool aIsRoot, bool aClipAllDescendants);
// Called to set the child frames. We typically have three: the scroll area,
// the vertical scrollbar, and the horizontal scrollbar.
virtual nsresult SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE {
mHelper.BuildDisplayList(aBuilder, aDirtyRect, aLists);
}
// XXXldb Is this actually used?
#if 0
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
#endif
virtual bool UpdateOverflow() MOZ_OVERRIDE {
return mHelper.UpdateOverflow();
}
// Because there can be only one child frame, these two function return
// NS_ERROR_FAILURE
virtual nsresult AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual nsresult RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) MOZ_OVERRIDE;
virtual nsIScrollableFrame* GetScrollTargetFrame() MOZ_OVERRIDE {
return this;
}
virtual nsIFrame* GetContentInsertionFrame() MOZ_OVERRIDE {
return mHelper.GetScrolledFrame()->GetContentInsertionFrame();
}
virtual bool DoesClipChildren() MOZ_OVERRIDE { return true; }
virtual nsSplittableType GetSplittableType() const MOZ_OVERRIDE;
virtual nsPoint GetPositionOfChildIgnoringScrolling(nsIFrame* aChild) MOZ_OVERRIDE
{ nsPoint pt = aChild->GetPosition();
if (aChild == mHelper.GetScrolledFrame())
pt += mHelper.GetLogicalScrollPosition();
return pt;
}
// nsIAnonymousContentCreator
virtual nsresult CreateAnonymousContent(nsTArray<ContentInfo>& aElements) MOZ_OVERRIDE;
virtual void AppendAnonymousContentTo(nsBaseContentList& aElements,
uint32_t aFilter) MOZ_OVERRIDE;
virtual nsSize GetMinSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nsSize GetPrefSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nscoord GetBoxAscent(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nsresult GetPadding(nsMargin& aPadding) MOZ_OVERRIDE;
virtual bool GetBorderRadii(nscoord aRadii[8]) const MOZ_OVERRIDE {
return mHelper.GetBorderRadii(aRadii);
}
nsresult Layout(nsBoxLayoutState& aState);
void LayoutScrollArea(nsBoxLayoutState& aState, const nsPoint& aScrollPosition);
static bool AddRemoveScrollbar(bool& aHasScrollbar,
nscoord& aXY,
nscoord& aSize,
nscoord aSbSize,
bool aOnRightOrBottom,
bool aAdd);
bool AddRemoveScrollbar(nsBoxLayoutState& aState,
bool aOnRightOrBottom,
bool aHorizontal,
bool aAdd);
bool AddHorizontalScrollbar (nsBoxLayoutState& aState, bool aOnBottom);
bool AddVerticalScrollbar (nsBoxLayoutState& aState, bool aOnRight);
void RemoveHorizontalScrollbar(nsBoxLayoutState& aState, bool aOnBottom);
void RemoveVerticalScrollbar (nsBoxLayoutState& aState, bool aOnRight);
static void AdjustReflowStateForPrintPreview(nsBoxLayoutState& aState, bool& aSetBack);
static void AdjustReflowStateBack(nsBoxLayoutState& aState, bool aSetBack);
// nsIScrollbarOwner
virtual nsIFrame* GetScrollbarBox(bool aVertical) MOZ_OVERRIDE {
return mHelper.GetScrollbarBox(aVertical);
}
virtual void ScrollbarActivityStarted() const MOZ_OVERRIDE;
virtual void ScrollbarActivityStopped() const MOZ_OVERRIDE;
// nsIScrollableFrame
virtual nsIFrame* GetScrolledFrame() const MOZ_OVERRIDE {
return mHelper.GetScrolledFrame();
}
virtual mozilla::ScrollbarStyles GetScrollbarStyles() const MOZ_OVERRIDE {
return mHelper.GetScrollbarStylesFromFrame();
}
virtual uint32_t GetScrollbarVisibility() const MOZ_OVERRIDE {
return mHelper.GetScrollbarVisibility();
}
virtual nsMargin GetActualScrollbarSizes() const MOZ_OVERRIDE {
return mHelper.GetActualScrollbarSizes();
}
virtual nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState) MOZ_OVERRIDE {
return mHelper.GetDesiredScrollbarSizes(aState);
}
virtual nsMargin GetDesiredScrollbarSizes(nsPresContext* aPresContext,
nsRenderingContext* aRC) MOZ_OVERRIDE {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return GetDesiredScrollbarSizes(&bls);
}
virtual nscoord GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
nsRenderingContext* aRC) MOZ_OVERRIDE {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return mHelper.GetNondisappearingScrollbarWidth(&bls);
}
virtual nsRect GetScrolledRect() const MOZ_OVERRIDE {
return mHelper.GetScrolledRect();
}
virtual nsRect GetScrollPortRect() const MOZ_OVERRIDE {
return mHelper.GetScrollPortRect();
}
virtual nsPoint GetScrollPosition() const MOZ_OVERRIDE {
return mHelper.GetScrollPosition();
}
virtual nsPoint GetLogicalScrollPosition() const MOZ_OVERRIDE {
return mHelper.GetLogicalScrollPosition();
}
virtual nsRect GetScrollRange() const MOZ_OVERRIDE {
return mHelper.GetScrollRange();
}
virtual nsSize GetScrollPositionClampingScrollPortSize() const MOZ_OVERRIDE {
return mHelper.GetScrollPositionClampingScrollPortSize();
}
virtual nsSize GetLineScrollAmount() const MOZ_OVERRIDE {
return mHelper.GetLineScrollAmount();
}
virtual nsSize GetPageScrollAmount() const MOZ_OVERRIDE {
return mHelper.GetPageScrollAmount();
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollTo(nsPoint aScrollPosition, ScrollMode aMode,
const nsRect* aRange = nullptr) MOZ_OVERRIDE {
mHelper.ScrollTo(aScrollPosition, aMode, aRange);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollToCSSPixels(const CSSIntPoint& aScrollPosition) MOZ_OVERRIDE {
mHelper.ScrollToCSSPixels(aScrollPosition);
}
virtual void ScrollToCSSPixelsApproximate(const mozilla::CSSPoint& aScrollPosition,
nsIAtom* aOrigin = nullptr) MOZ_OVERRIDE {
mHelper.ScrollToCSSPixelsApproximate(aScrollPosition, aOrigin);
}
virtual CSSIntPoint GetScrollPositionCSSPixels() MOZ_OVERRIDE {
return mHelper.GetScrollPositionCSSPixels();
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollBy(nsIntPoint aDelta, ScrollUnit aUnit, ScrollMode aMode,
nsIntPoint* aOverflow, nsIAtom* aOrigin = nullptr) MOZ_OVERRIDE {
mHelper.ScrollBy(aDelta, aUnit, aMode, aOverflow, aOrigin);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void ScrollToRestoredPosition() MOZ_OVERRIDE {
mHelper.ScrollToRestoredPosition();
}
virtual void AddScrollPositionListener(nsIScrollPositionListener* aListener) MOZ_OVERRIDE {
mHelper.AddScrollPositionListener(aListener);
}
virtual void RemoveScrollPositionListener(nsIScrollPositionListener* aListener) MOZ_OVERRIDE {
mHelper.RemoveScrollPositionListener(aListener);
}
/**
* @note This method might destroy the frame, pres shell and other objects.
*/
virtual void CurPosAttributeChanged(nsIContent* aChild) MOZ_OVERRIDE {
mHelper.CurPosAttributeChanged(aChild);
}
NS_IMETHOD PostScrolledAreaEventForCurrentArea() MOZ_OVERRIDE {
mHelper.PostScrolledAreaEvent();
return NS_OK;
}
virtual bool IsScrollingActive() MOZ_OVERRIDE {
return mHelper.IsScrollingActive();
}
virtual bool IsProcessingAsyncScroll() MOZ_OVERRIDE {
return mHelper.IsProcessingAsyncScroll();
}
virtual void ResetScrollPositionForLayerPixelAlignment() MOZ_OVERRIDE {
mHelper.ResetScrollPositionForLayerPixelAlignment();
}
virtual bool DidHistoryRestore() MOZ_OVERRIDE {
return mHelper.mDidHistoryRestore;
}
virtual void ClearDidHistoryRestore() MOZ_OVERRIDE {
mHelper.mDidHistoryRestore = false;
}
virtual bool IsRectNearlyVisible(const nsRect& aRect) MOZ_OVERRIDE {
return mHelper.IsRectNearlyVisible(aRect);
}
virtual nsIAtom* OriginOfLastScroll() MOZ_OVERRIDE {
return mHelper.OriginOfLastScroll();
}
virtual uint32_t CurrentScrollGeneration() MOZ_OVERRIDE {
return mHelper.CurrentScrollGeneration();
}
virtual void ResetOriginIfScrollAtGeneration(uint32_t aGeneration) MOZ_OVERRIDE {
mHelper.ResetOriginIfScrollAtGeneration(aGeneration);
}
virtual bool WantAsyncScroll() const MOZ_OVERRIDE {
return mHelper.WantAsyncScroll();
}
// nsIStatefulFrame
NS_IMETHOD SaveState(nsPresState** aState) MOZ_OVERRIDE {
NS_ENSURE_ARG_POINTER(aState);
*aState = mHelper.SaveState();
return NS_OK;
}
NS_IMETHOD RestoreState(nsPresState* aState) MOZ_OVERRIDE {
NS_ENSURE_ARG_POINTER(aState);
mHelper.RestoreState(aState);
return NS_OK;
}
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::scrollFrame
*/
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
{
// Override bogus IsFrameOfType in nsBoxFrame.
if (aFlags & (nsIFrame::eReplacedContainsBlock | nsIFrame::eReplaced))
return false;
return nsBoxFrame::IsFrameOfType(aFlags);
}
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
#endif
protected:
nsXULScrollFrame(nsIPresShell* aShell, nsStyleContext* aContext, bool aIsRoot,
bool aClipAllDescendants);
void ClampAndSetBounds(nsBoxLayoutState& aState,
nsRect& aRect,
nsPoint aScrollPosition,
bool aRemoveOverflowAreas = false) {
/*
* For RTL frames, restore the original scrolled position of the right
* edge, then subtract the current width to find the physical position.
*/
if (!mHelper.IsLTR()) {
aRect.x = mHelper.mScrollPort.XMost() - aScrollPosition.x - aRect.width;
}
mHelper.mScrolledFrame->SetBounds(aState, aRect, aRemoveOverflowAreas);
}
private:
friend class mozilla::ScrollFrameHelper;
ScrollFrameHelper mHelper;
};
#endif /* nsGfxScrollFrame_h___ */
Reference in New Issue View Git Blame Copy Permalink