/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* 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/. */ /* base class of all rendering objects */ #ifndef nsFrame_h___ #define nsFrame_h___ #include "mozilla/Attributes.h" #include "mozilla/EventForwards.h" #include "mozilla/Likely.h" #include "nsBox.h" #include "mozilla/Logging.h" #include "nsIPresShell.h" #include "mozilla/ReflowInput.h" #include "nsHTMLParts.h" #include "nsISelectionDisplay.h" namespace mozilla { enum class TableSelection : uint32_t; } // namespace mozilla /** * nsFrame logging constants. We redefine the nspr * PRLogModuleInfo.level field to be a bitfield. Each bit controls a * specific type of logging. Each logging operation has associated * inline methods defined below. * * Due to the redefinition of the level field we cannot use MOZ_LOG directly * as that will cause assertions due to invalid log levels. */ #define NS_FRAME_TRACE_CALLS 0x1 #define NS_FRAME_TRACE_PUSH_PULL 0x2 #define NS_FRAME_TRACE_CHILD_REFLOW 0x4 #define NS_FRAME_TRACE_NEW_FRAMES 0x8 #define NS_FRAME_LOG_TEST(_lm, _bit) \ (int(((mozilla::LogModule*)_lm)->Level()) & (_bit)) #ifdef DEBUG # define NS_FRAME_LOG(_bit, _args) \ PR_BEGIN_MACRO \ if (NS_FRAME_LOG_TEST(nsFrame::sFrameLogModule, _bit)) { \ printf_stderr _args; \ } \ PR_END_MACRO #else # define NS_FRAME_LOG(_bit, _args) #endif // XXX Need to rework this so that logging is free when it's off #ifdef DEBUG # define NS_FRAME_TRACE_IN(_method) Trace(_method, true) # define NS_FRAME_TRACE_OUT(_method) Trace(_method, false) // XXX remove me # define NS_FRAME_TRACE_MSG(_bit, _args) \ PR_BEGIN_MACRO \ if (NS_FRAME_LOG_TEST(nsFrame::sFrameLogModule, _bit)) { \ TraceMsg _args; \ } \ PR_END_MACRO # define NS_FRAME_TRACE(_bit, _args) \ PR_BEGIN_MACRO \ if (NS_FRAME_LOG_TEST(nsFrame::sFrameLogModule, _bit)) { \ TraceMsg _args; \ } \ PR_END_MACRO # define NS_FRAME_TRACE_REFLOW_IN(_method) Trace(_method, true) # define NS_FRAME_TRACE_REFLOW_OUT(_method, _status) \ Trace(_method, false, _status) #else # define NS_FRAME_TRACE(_bits, _args) # define NS_FRAME_TRACE_IN(_method) # define NS_FRAME_TRACE_OUT(_method) # define NS_FRAME_TRACE_MSG(_bits, _args) # define NS_FRAME_TRACE_REFLOW_IN(_method) # define NS_FRAME_TRACE_REFLOW_OUT(_method, _status) #endif // Frame allocation boilerplate macros. Every subclass of nsFrame must // either use NS_{DECL,IMPL}_FRAMEARENA_HELPERS pair for allocating // memory correctly, or use NS_DECL_ABSTRACT_FRAME to declare a frame // class abstract and stop it from being instantiated. If a frame class // without its own operator new and GetFrameId gets instantiated, the // per-frame recycler lists in nsPresArena will not work correctly, // with potentially catastrophic consequences (not enough memory is // allocated for a frame object). #define NS_DECL_FRAMEARENA_HELPERS(class) \ NS_DECL_QUERYFRAME_TARGET(class) \ static constexpr nsIFrame::ClassID kClassID = nsIFrame::ClassID::class##_id; \ void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE; \ nsQueryFrame::FrameIID GetFrameId() override MOZ_MUST_OVERRIDE { \ return nsQueryFrame::class##_id; \ } #define NS_IMPL_FRAMEARENA_HELPERS(class) \ void* class ::operator new(size_t sz, nsIPresShell* aShell) { \ return aShell->AllocateFrame(nsQueryFrame::class##_id, sz); \ } #define NS_DECL_ABSTRACT_FRAME(class) \ void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE = delete; \ virtual nsQueryFrame::FrameIID GetFrameId() override MOZ_MUST_OVERRIDE = 0; //---------------------------------------------------------------------- struct nsBoxLayoutMetrics; struct nsRect; /** * Implementation of a simple frame that's not splittable and has no * child frames. * * Sets the NS_FRAME_SYNCHRONIZE_FRAME_AND_VIEW bit, so the default * behavior is to keep the frame and view position and size in sync. */ class nsFrame : public nsBox { public: /** * Create a new "empty" frame that maps a given piece of content into a * 0,0 area. */ friend nsIFrame* NS_NewEmptyFrame(nsIPresShell* aShell, ComputedStyle* aStyle); private: // Left undefined; nsFrame objects are never allocated from the heap. void* operator new(size_t sz) CPP_THROW_NEW; protected: // Overridden to prevent the global delete from being called, since // the memory came out of an arena instead of the heap. // // Ideally this would be private and undefined, like the normal // operator new. Unfortunately, the C++ standard requires an // overridden operator delete to be accessible to any subclass that // defines a virtual destructor, so we can only make it protected; // worse, some C++ compilers will synthesize calls to this function // from the "deleting destructors" that they emit in case of // delete-expressions, so it can't even be undefined. void operator delete(void* aPtr, size_t sz); public: // nsQueryFrame NS_DECL_QUERYFRAME NS_DECL_QUERYFRAME_TARGET(nsFrame) virtual nsQueryFrame::FrameIID GetFrameId() MOZ_MUST_OVERRIDE { return kFrameIID; } void* operator new(size_t, nsIPresShell*) MOZ_MUST_OVERRIDE; // nsIFrame void Init(nsIContent* aContent, nsContainerFrame* aParent, nsIFrame* aPrevInFlow) override; void DestroyFrom(nsIFrame* aDestructRoot, PostDestroyData& aPostDestroyData) override; ComputedStyle* GetAdditionalComputedStyle(int32_t aIndex) const override; void SetAdditionalComputedStyle(int32_t aIndex, ComputedStyle* aComputedStyle) override; nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override; const nsFrameList& GetChildList(ChildListID aListID) const override; void GetChildLists(nsTArray* aLists) const override; nsresult HandleEvent(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus) override; nsresult GetContentForEvent(mozilla::WidgetEvent* aEvent, nsIContent** aContent) override; nsresult GetCursor(const nsPoint& aPoint, nsIFrame::Cursor& aCursor) override; nsresult GetPointFromOffset(int32_t inOffset, nsPoint* outPoint) override; nsresult GetCharacterRectsInRange(int32_t aInOffset, int32_t aLength, nsTArray& aOutRect) override; nsresult GetChildFrameContainingOffset(int32_t inContentOffset, bool inHint, int32_t* outFrameContentOffset, nsIFrame** outChildFrame) override; static nsresult GetNextPrevLineFromeBlockFrame(nsPresContext* aPresContext, nsPeekOffsetStruct* aPos, nsIFrame* aBlockFrame, int32_t aLineStart, int8_t aOutSideLimit); nsresult CharacterDataChanged(const CharacterDataChangeInfo& aInfo) override; nsresult AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute, int32_t aModType) override; nsIFrame* GetPrevContinuation() const override; void SetPrevContinuation(nsIFrame*) override; nsIFrame* GetNextContinuation() const override; void SetNextContinuation(nsIFrame*) override; nsIFrame* GetPrevInFlowVirtual() const override; void SetPrevInFlow(nsIFrame*) override; nsIFrame* GetNextInFlowVirtual() const override; void SetNextInFlow(nsIFrame*) override; nsresult GetSelectionController(nsPresContext* aPresContext, nsISelectionController** aSelCon) override; FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) override; FrameSearchResult PeekOffsetCharacter( bool aForward, int32_t* aOffset, PeekOffsetCharacterOptions aOptions = PeekOffsetCharacterOptions()) override; FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect, int32_t* aOffset, PeekWordState* aState) override; /** * Check whether we should break at a boundary between punctuation and * non-punctuation. Only call it at a punctuation boundary * (i.e. exactly one of the previous and next characters are punctuation). * @param aForward true if we're moving forward in content order * @param aPunctAfter true if the next character is punctuation * @param aWhitespaceAfter true if the next character is whitespace */ bool BreakWordBetweenPunctuation(const PeekWordState* aState, bool aForward, bool aPunctAfter, bool aWhitespaceAfter, bool aIsKeyboardSelect); nsresult CheckVisibility(nsPresContext* aContext, int32_t aStartIndex, int32_t aEndIndex, bool aRecurse, bool* aFinished, bool* _retval) override; nsresult GetOffsets(int32_t& aStart, int32_t& aEnd) const override; void ChildIsDirty(nsIFrame* aChild) override; #ifdef ACCESSIBILITY mozilla::a11y::AccType AccessibleType() override; #endif ComputedStyle* GetParentComputedStyle( nsIFrame** aProviderFrame) const override { return DoGetParentComputedStyle(aProviderFrame); } /** * Do the work for getting the parent ComputedStyle frame so that * other frame's |GetParentComputedStyle| methods can call this * method on *another* frame. (This function handles out-of-flow * frames by using the frame manager's placeholder map and it also * handles block-within-inline and generated content wrappers.) * * @param aProviderFrame (out) the frame associated with the returned value * or null if the ComputedStyle is for display:contents content. * @return The ComputedStyle that should be the parent of this frame's * ComputedStyle. Null is permitted, and means that this frame's * ComputedStyle should be the root of the ComputedStyle tree. */ ComputedStyle* DoGetParentComputedStyle(nsIFrame** aProviderFrame) const; bool IsEmpty() override; bool IsSelfEmpty() override; void MarkIntrinsicISizesDirty() override; nscoord GetMinISize(gfxContext* aRenderingContext) override; nscoord GetPrefISize(gfxContext* aRenderingContext) override; void AddInlineMinISize(gfxContext* aRenderingContext, InlineMinISizeData* aData) override; void AddInlinePrefISize(gfxContext* aRenderingContext, InlinePrefISizeData* aData) override; IntrinsicISizeOffsetData IntrinsicISizeOffsets( nscoord aPercentageBasis = NS_UNCONSTRAINEDSIZE) override; mozilla::IntrinsicSize GetIntrinsicSize() override; nsSize GetIntrinsicRatio() override; mozilla::LogicalSize ComputeSize( gfxContext* aRenderingContext, mozilla::WritingMode aWM, const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags) override; /** * Calculate the used values for 'width' and 'height' for a replaced element. * http://www.w3.org/TR/CSS21/visudet.html#min-max-widths */ mozilla::LogicalSize ComputeSizeWithIntrinsicDimensions( gfxContext* aRenderingContext, mozilla::WritingMode aWM, const mozilla::IntrinsicSize& aIntrinsicSize, nsSize aIntrinsicRatio, const mozilla::LogicalSize& aCBSize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags); // Compute tight bounds assuming this frame honours its border, background // and outline, its children's tight bounds, and nothing else. nsRect ComputeSimpleTightBounds(mozilla::gfx::DrawTarget* aDrawTarget) const; /** * A helper, used by |nsFrame::ComputeSize| (for frames that need to * override only this part of ComputeSize), that computes the size * that should be returned when 'width', 'height', and * min/max-width/height are all 'auto' or equivalent. * * In general, frames that can accept any computed width/height should * override only ComputeAutoSize, and frames that cannot do so need to * override ComputeSize to enforce their width/height invariants. * * Implementations may optimize by returning a garbage width if * StylePosition()->mWidth.GetUnit() != eStyleUnit_Auto, and * likewise for height, since in such cases the result is guaranteed * to be unused. */ virtual mozilla::LogicalSize ComputeAutoSize( gfxContext* aRenderingContext, mozilla::WritingMode aWM, const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize, const mozilla::LogicalSize& aMargin, const mozilla::LogicalSize& aBorder, const mozilla::LogicalSize& aPadding, ComputeSizeFlags aFlags); /** * Utility function for ComputeAutoSize implementations. Return * max(GetMinISize(), min(aISizeInCB, GetPrefISize())) */ nscoord ShrinkWidthToFit(gfxContext* aRenderingContext, nscoord aISizeInCB, ComputeSizeFlags aFlags); /** * Calculates the size of this frame after reflowing (calling Reflow on, and * updating the size and position of) its children, as necessary. The * calculated size is returned to the caller via the ReflowOutput * outparam. (The caller is responsible for setting the actual size and * position of this frame.) * * A frame's children must _all_ be reflowed if the frame is dirty (the * NS_FRAME_IS_DIRTY bit is set on it). Otherwise, individual children * must be reflowed if they are dirty or have the NS_FRAME_HAS_DIRTY_CHILDREN * bit set on them. Otherwise, whether children need to be reflowed depends * on the frame's type (it's up to individual Reflow methods), and on what * has changed. For example, a change in the width of the frame may require * all of its children to be reflowed (even those without dirty bits set on * them), whereas a change in its height might not. * (ReflowInput::ShouldReflowAllKids may be helpful in deciding whether * to reflow all the children, but for some frame types it might result in * over-reflow.) * * Note: if it's only the overflow rect(s) of a frame that need to be * updated, then UpdateOverflow should be called instead of Reflow. */ void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, const ReflowInput& aReflowInput, nsReflowStatus& aStatus) override; void DidReflow(nsPresContext* aPresContext, const ReflowInput* aReflowInput) override; /** * NOTE: aStatus is assumed to be already-initialized. The reflow statuses of * any reflowed absolute children will be merged into aStatus; aside from * that, this method won't modify aStatus. */ void ReflowAbsoluteFrames(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, const ReflowInput& aReflowInput, nsReflowStatus& aStatus, bool aConstrainBSize = true); void FinishReflowWithAbsoluteFrames(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, const ReflowInput& aReflowInput, nsReflowStatus& aStatus, bool aConstrainBSize = true); /* * If this frame is dirty, marks all absolutely-positioned children of this * frame dirty. If this frame isn't dirty, or if there are no * absolutely-positioned children, does nothing. * * It's necessary to use PushDirtyBitToAbsoluteFrames() when you plan to * reflow this frame's absolutely-positioned children after the dirty bit on * this frame has already been cleared, which prevents ReflowInput from * propagating the dirty bit normally. This situation generally only arises * when a multipass layout algorithm is used. */ void PushDirtyBitToAbsoluteFrames(); bool CanContinueTextRun() const override; bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override; void UnionChildOverflow(nsOverflowAreas& aOverflowAreas) override; // Selection Methods NS_IMETHOD HandlePress(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus); NS_IMETHOD HandleMultiplePress(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus, bool aControlHeld); NS_IMETHOD HandleDrag(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus); NS_IMETHOD HandleRelease(nsPresContext* aPresContext, mozilla::WidgetGUIEvent* aEvent, nsEventStatus* aEventStatus); enum { SELECT_ACCUMULATE = 0x01 }; nsresult PeekBackwardAndForward(nsSelectionAmount aAmountBack, nsSelectionAmount aAmountForward, int32_t aStartPos, bool aJumpLines, uint32_t aSelectFlags); nsresult SelectByTypeAtPoint(nsPresContext* aPresContext, const nsPoint& aPoint, nsSelectionAmount aBeginAmountType, nsSelectionAmount aEndAmountType, uint32_t aSelectFlags); // Helper for GetContentAndOffsetsFromPoint; calculation of content offsets // in this function assumes there is no child frame that can be targeted. virtual ContentOffsets CalcContentOffsetsFromFramePoint( const nsPoint& aPoint); // Box layout methods nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override; nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override; nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override; nscoord GetXULFlex() override; nscoord GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) override; // We compute and store the HTML content's overflow area. So don't // try to compute it in the box code. bool ComputesOwnOverflowArea() override { return true; } //-------------------------------------------------- // Additional methods // Helper function that tests if the frame tree is too deep; if it is // it marks the frame as "unflowable", zeroes out the metrics, sets // the reflow status, and returns true. Otherwise, the frame is // unmarked "unflowable" and the metrics and reflow status are not // touched and false is returned. bool IsFrameTreeTooDeep(const ReflowInput& aReflowInput, ReflowOutput& aMetrics, nsReflowStatus& aStatus); // Incorporate the child overflow areas into aOverflowAreas. // If the child does not have a overflow, use the child area. void ConsiderChildOverflow(nsOverflowAreas& aOverflowAreas, nsIFrame* aChildFrame); /** * @return true if we should avoid a page/column break in this frame. */ bool ShouldAvoidBreakInside(const ReflowInput& aReflowInput) const; #ifdef DEBUG /** * Tracing method that writes a method enter/exit routine to the * nspr log using the nsIFrame log module. The tracing is only * done when the NS_FRAME_TRACE_CALLS bit is set in the log module's * level field. */ void Trace(const char* aMethod, bool aEnter); void Trace(const char* aMethod, bool aEnter, const nsReflowStatus& aStatus); void TraceMsg(const char* fmt, ...) MOZ_FORMAT_PRINTF(2, 3); // Helper function that verifies that each frame in the list has the // NS_FRAME_IS_DIRTY bit set static void VerifyDirtyBitSet(const nsFrameList& aFrameList); // Display Reflow Debugging static void* DisplayReflowEnter(nsPresContext* aPresContext, nsIFrame* aFrame, const ReflowInput& aReflowInput); static void* DisplayLayoutEnter(nsIFrame* aFrame); static void* DisplayIntrinsicISizeEnter(nsIFrame* aFrame, const char* aType); static void* DisplayIntrinsicSizeEnter(nsIFrame* aFrame, const char* aType); static void DisplayReflowExit(nsPresContext* aPresContext, nsIFrame* aFrame, ReflowOutput& aMetrics, const nsReflowStatus& aStatus, void* aFrameTreeNode); static void DisplayLayoutExit(nsIFrame* aFrame, void* aFrameTreeNode); static void DisplayIntrinsicISizeExit(nsIFrame* aFrame, const char* aType, nscoord aResult, void* aFrameTreeNode); static void DisplayIntrinsicSizeExit(nsIFrame* aFrame, const char* aType, nsSize aResult, void* aFrameTreeNode); static void DisplayReflowStartup(); static void DisplayReflowShutdown(); #endif /** * Adds display items for standard CSS background if necessary. * Does not check IsVisibleForPainting. * @param aForceBackground draw the background even if the frame * background style appears to have no background --- this is useful * for frames that might receive a propagated background via * nsCSSRendering::FindBackground * @return whether a themed background item was created. */ bool DisplayBackgroundUnconditional(nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists, bool aForceBackground); /** * Adds display items for standard CSS borders, background and outline for * for this frame, as necessary. Checks IsVisibleForPainting and won't * display anything if the frame is not visible. * @param aForceBackground draw the background even if the frame * background style appears to have no background --- this is useful * for frames that might receive a propagated background via * nsCSSRendering::FindBackground */ void DisplayBorderBackgroundOutline(nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists, bool aForceBackground = false); /** * Add a display item for the CSS outline. Does not check visibility. */ void DisplayOutlineUnconditional(nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists); /** * Add a display item for the CSS outline, after calling * IsVisibleForPainting to confirm we are visible. */ void DisplayOutline(nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists); /** * Adjust the given parent frame to the right ComputedStyle parent frame for * the child, given the pseudo-type of the prospective child. This handles * things like walking out of table pseudos and so forth. * * @param aProspectiveParent what GetParent() on the child returns. * Must not be null. * @param aChildPseudo the child's pseudo type, if any. */ static nsIFrame* CorrectStyleParentFrame(nsIFrame* aProspectiveParent, nsAtom* aChildPseudo); protected: // Protected constructor and destructor nsFrame(ComputedStyle* aStyle, ClassID aID); explicit nsFrame(ComputedStyle* aStyle) : nsFrame(aStyle, ClassID::nsFrame_id) {} virtual ~nsFrame(); /** * To be called by |BuildDisplayLists| of this class or derived classes to add * a translucent overlay if this frame's content is selected. * @param aContentType an nsISelectionDisplay DISPLAY_ constant identifying * which kind of content this is for */ void DisplaySelectionOverlay( nsDisplayListBuilder* aBuilder, nsDisplayList* aList, uint16_t aContentType = nsISelectionDisplay::DISPLAY_FRAMES); int16_t DisplaySelection(nsPresContext* aPresContext, bool isOkToTurnOn = false); // Style post processing hook void DidSetComputedStyle(ComputedStyle* aOldComputedStyle) override; public: /** * Helper method to create a view for a frame. Only used by a few sub-classes * that need a view. */ void CreateView(); // given a frame five me the first/last leaf available // XXX Robert O'Callahan wants to move these elsewhere static void GetLastLeaf(nsPresContext* aPresContext, nsIFrame** aFrame); static void GetFirstLeaf(nsPresContext* aPresContext, nsIFrame** aFrame); // Return the line number of the aFrame, and (optionally) the containing block // frame. // If aScrollLock is true, don't break outside scrollframes when looking for a // containing block frame. static int32_t GetLineNumber(nsIFrame* aFrame, bool aLockScroll, nsIFrame** aContainingBlock = nullptr); /** * Returns true if aFrame should apply overflow clipping. */ static bool ShouldApplyOverflowClipping(const nsIFrame* aFrame, const nsStyleDisplay* aDisp) { // clip overflow:-moz-hidden-unscrollable, except for nsListControlFrame, // which is an nsHTMLScrollFrame. if (MOZ_UNLIKELY(aDisp->mOverflowX == mozilla::StyleOverflow::MozHiddenUnscrollable && !aFrame->IsListControlFrame())) { return true; } // contain: paint, which we interpret as -moz-hidden-unscrollable // Exception: for scrollframes, we don't need contain:paint to add any // clipping, because the scrollable frame will already clip overflowing // content, and because contain:paint should prevent all means of escaping // that clipping (e.g. because it forms a fixed-pos containing block). if (aDisp->IsContainPaint() && !aFrame->IsScrollFrame()) { return true; } // and overflow:hidden that we should interpret as -moz-hidden-unscrollable if (aDisp->mOverflowX == mozilla::StyleOverflow::Hidden && aDisp->mOverflowY == mozilla::StyleOverflow::Hidden) { // REVIEW: these are the frame types that set up clipping. mozilla::LayoutFrameType type = aFrame->Type(); if (type == mozilla::LayoutFrameType::Table || type == mozilla::LayoutFrameType::TableCell || type == mozilla::LayoutFrameType::BCTableCell || type == mozilla::LayoutFrameType::SVGOuterSVG || type == mozilla::LayoutFrameType::SVGInnerSVG || type == mozilla::LayoutFrameType::SVGSymbol || type == mozilla::LayoutFrameType::SVGForeignObject) { return true; } if (aFrame->IsFrameOfType(nsIFrame::eReplacedContainsBlock)) { if (type == mozilla::LayoutFrameType::TextInput) { // It always has an anonymous scroll frame that handles any overflow. return false; } return true; } } if ((aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT)) { return false; } // If we're paginated and a block, and have NS_BLOCK_CLIP_PAGINATED_OVERFLOW // set, then we want to clip our overflow. return (aFrame->GetStateBits() & NS_BLOCK_CLIP_PAGINATED_OVERFLOW) != 0 && aFrame->PresContext()->IsPaginated() && aFrame->IsBlockFrame(); } nsILineIterator* GetLineIterator() override; protected: // Test if we are selecting a table object: // Most table/cell selection requires that Ctrl (Cmd on Mac) key is down // during a mouse click or drag. Exception is using Shift+click when // already in "table/cell selection mode" to extend a block selection // Get the parent content node and offset of the frame // of the enclosing cell or table (if not inside a cell) // aTarget tells us what table element to select (currently only cell and // table supported) (enums for this are defined in nsIFrame.h) nsresult GetDataForTableSelection(const nsFrameSelection* aFrameSelection, nsIPresShell* aPresShell, mozilla::WidgetMouseEvent* aMouseEvent, nsIContent** aParentContent, int32_t* aContentOffset, mozilla::TableSelection* aTarget); // Fills aCursor with the appropriate information from ui static void FillCursorInformationFromStyle(const nsStyleUI* ui, nsIFrame::Cursor& aCursor); NS_IMETHOD DoXULLayout(nsBoxLayoutState& aBoxLayoutState) override; nsBoxLayoutMetrics* BoxMetrics() const; // Fire DOM event. If no aContent argument use frame's mContent. void FireDOMEvent(const nsAString& aDOMEventName, nsIContent* aContent = nullptr); private: void BoxReflow(nsBoxLayoutState& aState, nsPresContext* aPresContext, ReflowOutput& aDesiredSize, gfxContext* aRenderingContext, nscoord aX, nscoord aY, nscoord aWidth, nscoord aHeight, bool aMoveFrame = true); NS_IMETHODIMP RefreshSizeCache(nsBoxLayoutState& aState); // Returns true if this frame has any kind of CSS animations. bool HasCSSAnimations(); // Returns true if this frame has any kind of CSS transitions. bool HasCSSTransitions(); public: #ifdef DEBUG_FRAME_DUMP /** * Get a printable from of the name of the frame type. * XXX This should be eliminated and we use GetType() instead... */ nsresult GetFrameName(nsAString& aResult) const override; nsresult MakeFrameName(const nsAString& aKind, nsAString& aResult) const; // Helper function to return the index in parent of the frame's content // object. Returns -1 on error or if the frame doesn't have a content object static int32_t ContentIndexInContainer(const nsIFrame* aFrame); #endif #ifdef DEBUG static mozilla::LazyLogModule sFrameLogModule; // Show frame borders when rendering static void ShowFrameBorders(bool aEnable); static bool GetShowFrameBorders(); // Show frame border of event target static void ShowEventTargetFrameBorder(bool aEnable); static bool GetShowEventTargetFrameBorder(); #endif static void PrintDisplayList(nsDisplayListBuilder* aBuilder, const nsDisplayList& aList, bool aDumpHtml = false) { std::stringstream ss; PrintDisplayList(aBuilder, aList, ss, aDumpHtml); fprintf_stderr(stderr, "%s", ss.str().c_str()); } static void PrintDisplayList(nsDisplayListBuilder* aBuilder, const nsDisplayList& aList, std::stringstream& aStream, bool aDumpHtml = false); static void PrintDisplayItem(nsDisplayListBuilder* aBuilder, nsDisplayItem* aItem, std::stringstream& aStream, uint32_t aIndent = 0, bool aDumpSublist = false, bool aDumpHtml = false); static void PrintDisplayListSet(nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aList, std::stringstream& aStream, bool aDumpHtml = false); }; // Start Display Reflow Debugging #ifdef DEBUG struct DR_cookie { DR_cookie(nsPresContext* aPresContext, nsIFrame* aFrame, const mozilla::ReflowInput& aReflowInput, mozilla::ReflowOutput& aMetrics, nsReflowStatus& aStatus); ~DR_cookie(); void Change() const; nsPresContext* mPresContext; nsIFrame* mFrame; const mozilla::ReflowInput& mReflowInput; mozilla::ReflowOutput& mMetrics; nsReflowStatus& mStatus; void* mValue; }; struct DR_layout_cookie { explicit DR_layout_cookie(nsIFrame* aFrame); ~DR_layout_cookie(); nsIFrame* mFrame; void* mValue; }; struct DR_intrinsic_inline_size_cookie { DR_intrinsic_inline_size_cookie(nsIFrame* aFrame, const char* aType, nscoord& aResult); ~DR_intrinsic_inline_size_cookie(); nsIFrame* mFrame; const char* mType; nscoord& mResult; void* mValue; }; struct DR_intrinsic_size_cookie { DR_intrinsic_size_cookie(nsIFrame* aFrame, const char* aType, nsSize& aResult); ~DR_intrinsic_size_cookie(); nsIFrame* mFrame; const char* mType; nsSize& mResult; void* mValue; }; struct DR_init_constraints_cookie { DR_init_constraints_cookie(nsIFrame* aFrame, mozilla::ReflowInput* aState, nscoord aCBWidth, nscoord aCBHeight, const nsMargin* aBorder, const nsMargin* aPadding); ~DR_init_constraints_cookie(); nsIFrame* mFrame; mozilla::ReflowInput* mState; void* mValue; }; struct DR_init_offsets_cookie { DR_init_offsets_cookie(nsIFrame* aFrame, mozilla::SizeComputationInput* aState, nscoord aPercentBasis, mozilla::WritingMode aCBWritingMode, const nsMargin* aBorder, const nsMargin* aPadding); ~DR_init_offsets_cookie(); nsIFrame* mFrame; mozilla::SizeComputationInput* mState; void* mValue; }; struct DR_init_type_cookie { DR_init_type_cookie(nsIFrame* aFrame, mozilla::ReflowInput* aState); ~DR_init_type_cookie(); nsIFrame* mFrame; mozilla::ReflowInput* mState; void* mValue; }; # define DISPLAY_REFLOW(dr_pres_context, dr_frame, dr_rf_state, \ dr_rf_metrics, dr_rf_status) \ DR_cookie dr_cookie(dr_pres_context, dr_frame, dr_rf_state, dr_rf_metrics, \ dr_rf_status); # define DISPLAY_REFLOW_CHANGE() dr_cookie.Change(); # define DISPLAY_LAYOUT(dr_frame) DR_layout_cookie dr_cookie(dr_frame); # define DISPLAY_MIN_INLINE_SIZE(dr_frame, dr_result) \ DR_intrinsic_inline_size_cookie dr_cookie(dr_frame, "Min", dr_result) # define DISPLAY_PREF_INLINE_SIZE(dr_frame, dr_result) \ DR_intrinsic_inline_size_cookie dr_cookie(dr_frame, "Pref", dr_result) # define DISPLAY_PREF_SIZE(dr_frame, dr_result) \ DR_intrinsic_size_cookie dr_cookie(dr_frame, "Pref", dr_result) # define DISPLAY_MIN_SIZE(dr_frame, dr_result) \ DR_intrinsic_size_cookie dr_cookie(dr_frame, "Min", dr_result) # define DISPLAY_MAX_SIZE(dr_frame, dr_result) \ DR_intrinsic_size_cookie dr_cookie(dr_frame, "Max", dr_result) # define DISPLAY_INIT_CONSTRAINTS(dr_frame, dr_state, dr_cbw, dr_cbh, dr_bdr, \ dr_pad) \ DR_init_constraints_cookie dr_cookie(dr_frame, dr_state, dr_cbw, dr_cbh, \ dr_bdr, dr_pad) # define DISPLAY_INIT_OFFSETS(dr_frame, dr_state, dr_pb, dr_cbwm, dr_bdr, \ dr_pad) \ DR_init_offsets_cookie dr_cookie(dr_frame, dr_state, dr_pb, dr_cbwm, \ dr_bdr, dr_pad) # define DISPLAY_INIT_TYPE(dr_frame, dr_result) \ DR_init_type_cookie dr_cookie(dr_frame, dr_result) #else # define DISPLAY_REFLOW(dr_pres_context, dr_frame, dr_rf_state, \ dr_rf_metrics, dr_rf_status) # define DISPLAY_REFLOW_CHANGE() # define DISPLAY_LAYOUT(dr_frame) PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_MIN_INLINE_SIZE(dr_frame, dr_result) \ PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_PREF_INLINE_SIZE(dr_frame, dr_result) \ PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_PREF_SIZE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_MIN_SIZE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_MAX_SIZE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_INIT_CONSTRAINTS(dr_frame, dr_state, dr_cbw, dr_cbh, dr_bdr, \ dr_pad) \ PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_INIT_OFFSETS(dr_frame, dr_state, dr_pb, dr_cbwm, dr_bdr, \ dr_pad) \ PR_BEGIN_MACRO PR_END_MACRO # define DISPLAY_INIT_TYPE(dr_frame, dr_result) PR_BEGIN_MACRO PR_END_MACRO #endif // End Display Reflow Debugging #endif /* nsFrame_h___ */