diff options
Diffstat (limited to 'layout/generic/nsIFrame.h')
| -rw-r--r-- | layout/generic/nsIFrame.h | 4021 |
1 files changed, 4021 insertions, 0 deletions
diff --git a/layout/generic/nsIFrame.h b/layout/generic/nsIFrame.h new file mode 100644 index 000000000..50eb958e0 --- /dev/null +++ b/layout/generic/nsIFrame.h @@ -0,0 +1,4021 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 sw=2 et tw=78: */ +/* 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/. */ + +/* interface for all rendering objects */ + +#ifndef nsIFrame_h___ +#define nsIFrame_h___ + +#ifndef MOZILLA_INTERNAL_API +#error This header/class should only be used within Mozilla code. It should not be used by extensions. +#endif + +#define MAX_REFLOW_DEPTH 200 + +/* nsIFrame is in the process of being deCOMtaminated, i.e., this file is eventually + going to be eliminated, and all callers will use nsFrame instead. At the moment + we're midway through this process, so you will see inlined functions and member + variables in this file. -dwh */ + +#include <algorithm> +#include <stdio.h> + +#include "CaretAssociationHint.h" +#include "FramePropertyTable.h" +#include "mozilla/layout/FrameChildList.h" +#include "mozilla/Maybe.h" +#include "mozilla/WritingModes.h" +#include "nsDirection.h" +#include "nsFrameList.h" +#include "nsFrameState.h" +#include "mozilla/ReflowOutput.h" +#include "nsITheme.h" +#include "nsLayoutUtils.h" +#include "nsQueryFrame.h" +#include "nsStringGlue.h" +#include "nsStyleContext.h" +#include "nsStyleStruct.h" +#include "Visibility.h" + +#ifdef ACCESSIBILITY +#include "mozilla/a11y/AccTypes.h" +#endif + +/** + * New rules of reflow: + * 1. you get a WillReflow() followed by a Reflow() followed by a DidReflow() in order + * (no separate pass over the tree) + * 2. it's the parent frame's responsibility to size/position the child's view (not + * the child frame's responsibility as it is today) during reflow (and before + * sending the DidReflow() notification) + * 3. positioning of child frames (and their views) is done on the way down the tree, + * and sizing of child frames (and their views) on the way back up + * 4. if you move a frame (outside of the reflow process, or after reflowing it), + * then you must make sure that its view (or its child frame's views) are re-positioned + * as well. It's reasonable to not position the view until after all reflowing the + * entire line, for example, but the frame should still be positioned and sized (and + * the view sized) during the reflow (i.e., before sending the DidReflow() notification) + * 5. the view system handles moving of widgets, i.e., it's not our problem + */ + +class nsIAtom; +class nsPresContext; +class nsIPresShell; +class nsRenderingContext; +class nsView; +class nsIWidget; +class nsISelectionController; +class nsBoxLayoutState; +class nsBoxLayout; +class nsILineIterator; +class nsDisplayListBuilder; +class nsDisplayListSet; +class nsDisplayList; +class gfxSkipChars; +class gfxSkipCharsIterator; +class gfxContext; +class nsLineList_iterator; +class nsAbsoluteContainingBlock; +class nsIContent; +class nsContainerFrame; + +struct nsPeekOffsetStruct; +struct nsPoint; +struct nsRect; +struct nsSize; +struct nsMargin; +struct CharacterDataChangeInfo; + +namespace mozilla { + +enum class CSSPseudoElementType : uint8_t; +class EventStates; +struct ReflowInput; +class ReflowOutput; + +namespace layers { +class Layer; +} // namespace layers + +namespace gfx { +class Matrix; +} // namespace gfx +} // namespace mozilla + +/** + * Indication of how the frame can be split. This is used when doing runaround + * of floats, and when pulling up child frames from a next-in-flow. + * + * The choices are splittable, not splittable at all, and splittable in + * a non-rectangular fashion. This last type only applies to block-level + * elements, and indicates whether splitting can be used when doing runaround. + * If you can split across page boundaries, but you expect each continuing + * frame to be the same width then return frSplittable and not + * frSplittableNonRectangular. + * + * @see #GetSplittableType() + */ +typedef uint32_t nsSplittableType; + +#define NS_FRAME_NOT_SPLITTABLE 0 // Note: not a bit! +#define NS_FRAME_SPLITTABLE 0x1 +#define NS_FRAME_SPLITTABLE_NON_RECTANGULAR 0x3 + +#define NS_FRAME_IS_SPLITTABLE(type)\ + (0 != ((type) & NS_FRAME_SPLITTABLE)) + +#define NS_FRAME_IS_NOT_SPLITTABLE(type)\ + (0 == ((type) & NS_FRAME_SPLITTABLE)) + +#define NS_INTRINSIC_WIDTH_UNKNOWN nscoord_MIN + +//---------------------------------------------------------------------- + +#define NS_SUBTREE_DIRTY(_frame) \ + (((_frame)->GetStateBits() & \ + (NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN)) != 0) + +/** + * Constant used to indicate an unconstrained size. + * + * @see #Reflow() + */ +#define NS_UNCONSTRAINEDSIZE NS_MAXSIZE + +#define NS_INTRINSICSIZE NS_UNCONSTRAINEDSIZE +#define NS_AUTOHEIGHT NS_UNCONSTRAINEDSIZE +// +1 is to avoid clamped huge margin values being processed as auto margins +#define NS_AUTOMARGIN (NS_UNCONSTRAINEDSIZE + 1) +#define NS_AUTOOFFSET NS_UNCONSTRAINEDSIZE +// NOTE: there are assumptions all over that these have the same value, namely NS_UNCONSTRAINEDSIZE +// if any are changed to be a value other than NS_UNCONSTRAINEDSIZE +// at least update AdjustComputedHeight/Width and test ad nauseum + +// 1 million CSS pixels less than our max app unit measure. +// For reflowing with an "infinite" available inline space per [css-sizing]. +// (reflowing with an NS_UNCONSTRAINEDSIZE available inline size isn't allowed +// and leads to assertions) +#define INFINITE_ISIZE_COORD nscoord(NS_MAXSIZE - (1000000*60)) + +//---------------------------------------------------------------------- + +enum nsSelectionAmount { + eSelectCharacter = 0, // a single Unicode character; + // do not use this (prefer Cluster) unless you + // are really sure it's what you want + eSelectCluster = 1, // a grapheme cluster: this is usually the right + // choice for movement or selection by "character" + // as perceived by the user + eSelectWord = 2, + eSelectWordNoSpace = 3, // select a "word" without selecting the following + // space, no matter what the default platform + // behavior is + eSelectLine = 4, // previous drawn line in flow. + // NOTE that selection code depends on the ordering of the above values, + // allowing simple <= tests to check categories of caret movement. + // Don't rearrange without checking the usage in nsSelection.cpp! + + eSelectBeginLine = 5, + eSelectEndLine = 6, + eSelectNoAmount = 7, // just bounce back current offset. + eSelectParagraph = 8 // select a "paragraph" +}; + +enum nsSpread { + eSpreadNone = 0, + eSpreadAcross = 1, + eSpreadDown = 2 +}; + +// Carried out margin flags +#define NS_CARRIED_TOP_MARGIN_IS_AUTO 0x1 +#define NS_CARRIED_BOTTOM_MARGIN_IS_AUTO 0x2 + +//---------------------------------------------------------------------- + +/** + * Reflow status returned by the reflow methods. There are three + * completion statuses, represented by two bit flags. + * + * NS_FRAME_COMPLETE means the frame is fully complete. + * + * NS_FRAME_NOT_COMPLETE bit flag means the frame does not map all its + * content, and that the parent frame should create a continuing frame. + * If this bit isn't set it means the frame does map all its content. + * This bit is mutually exclusive with NS_FRAME_OVERFLOW_INCOMPLETE. + * + * NS_FRAME_OVERFLOW_INCOMPLETE bit flag means that the frame has + * overflow that is not complete, but its own box is complete. + * (This happens when content overflows a fixed-height box.) + * The reflower should place and size the frame and continue its reflow, + * but needs to create an overflow container as a continuation for this + * frame. See nsContainerFrame.h for more information. + * This bit is mutually exclusive with NS_FRAME_NOT_COMPLETE. + * + * Please use the SET macro for handling + * NS_FRAME_NOT_COMPLETE and NS_FRAME_OVERFLOW_INCOMPLETE. + * + * NS_FRAME_REFLOW_NEXTINFLOW bit flag means that the next-in-flow is + * dirty, and also needs to be reflowed. This status only makes sense + * for a frame that is not complete, i.e. you wouldn't set both + * NS_FRAME_COMPLETE and NS_FRAME_REFLOW_NEXTINFLOW. + * + * The low 8 bits of the nsReflowStatus are reserved for future extensions; + * the remaining 24 bits are zero (and available for extensions; however + * API's that accept/return nsReflowStatus must not receive/return any + * extension bits). + * + * @see #Reflow() + */ +typedef uint32_t nsReflowStatus; + +#define NS_FRAME_COMPLETE 0 // Note: not a bit! +#define NS_FRAME_NOT_COMPLETE 0x1 +#define NS_FRAME_REFLOW_NEXTINFLOW 0x2 +#define NS_FRAME_OVERFLOW_INCOMPLETE 0x4 + +#define NS_FRAME_IS_COMPLETE(status) \ + (0 == ((status) & NS_FRAME_NOT_COMPLETE)) + +#define NS_FRAME_IS_NOT_COMPLETE(status) \ + (0 != ((status) & NS_FRAME_NOT_COMPLETE)) + +#define NS_FRAME_OVERFLOW_IS_INCOMPLETE(status) \ + (0 != ((status) & NS_FRAME_OVERFLOW_INCOMPLETE)) + +#define NS_FRAME_IS_FULLY_COMPLETE(status) \ + (NS_FRAME_IS_COMPLETE(status) && !NS_FRAME_OVERFLOW_IS_INCOMPLETE(status)) + +// These macros set or switch incomplete statuses without touching the +// NS_FRAME_REFLOW_NEXTINFLOW bit. +#define NS_FRAME_SET_INCOMPLETE(status) \ + status = (status & ~NS_FRAME_OVERFLOW_INCOMPLETE) | NS_FRAME_NOT_COMPLETE + +#define NS_FRAME_SET_OVERFLOW_INCOMPLETE(status) \ + status = (status & ~NS_FRAME_NOT_COMPLETE) | NS_FRAME_OVERFLOW_INCOMPLETE + +// This bit is set, when a break is requested. This bit is orthogonal +// to the nsIFrame::nsReflowStatus completion bits. +#define NS_INLINE_BREAK 0x0100 + +// When a break is requested, this bit when set indicates that the +// break should occur after the frame just reflowed; when the bit is +// clear the break should occur before the frame just reflowed. +#define NS_INLINE_BREAK_BEFORE 0x0000 +#define NS_INLINE_BREAK_AFTER 0x0200 + +// The type of break requested can be found in these bits. +#define NS_INLINE_BREAK_TYPE_MASK 0xF000 + +// Set when a break was induced by completion of a first-letter +#define NS_INLINE_BREAK_FIRST_LETTER_COMPLETE 0x10000 + +//---------------------------------------- +// Macros that use those bits + +#define NS_INLINE_IS_BREAK(_status) \ + (0 != ((_status) & NS_INLINE_BREAK)) + +#define NS_INLINE_IS_BREAK_AFTER(_status) \ + (0 != ((_status) & NS_INLINE_BREAK_AFTER)) + +#define NS_INLINE_IS_BREAK_BEFORE(_status) \ + (NS_INLINE_BREAK == ((_status) & (NS_INLINE_BREAK|NS_INLINE_BREAK_AFTER))) + +#define NS_INLINE_GET_BREAK_TYPE(_status) \ + (static_cast<StyleClear>(((_status) >> 12) & 0xF)) + +#define NS_INLINE_MAKE_BREAK_TYPE(_type) (static_cast<int>(_type) << 12) + +// Construct a line-break-before status. Note that there is no +// completion status for a line-break before because we *know* that +// the frame will be reflowed later and hence its current completion +// status doesn't matter. +#define NS_INLINE_LINE_BREAK_BEFORE() \ + (NS_INLINE_BREAK | NS_INLINE_BREAK_BEFORE | \ + NS_INLINE_MAKE_BREAK_TYPE(StyleClear::Line)) + +// Take a completion status and add to it the desire to have a +// line-break after. For this macro we do need the completion status +// because the user of the status will need to know whether to +// continue the frame or not. +#define NS_INLINE_LINE_BREAK_AFTER(_completionStatus) \ + ((_completionStatus) | NS_INLINE_BREAK | NS_INLINE_BREAK_AFTER | \ + NS_INLINE_MAKE_BREAK_TYPE(StyleClear::Line)) + +// A frame is "truncated" if the part of the frame before the first +// possible break point was unable to fit in the available vertical +// space. Therefore, the entire frame should be moved to the next page. +// A frame that begins at the top of the page must never be "truncated". +// Doing so would likely cause an infinite loop. +#define NS_FRAME_TRUNCATED 0x0010 +#define NS_FRAME_IS_TRUNCATED(status) \ + (0 != ((status) & NS_FRAME_TRUNCATED)) +#define NS_FRAME_SET_TRUNCATION(status, aReflowInput, aMetrics) \ + aReflowInput.SetTruncated(aMetrics, &status); + +// Merge the incompleteness, truncation and NS_FRAME_REFLOW_NEXTINFLOW +// status from aSecondary into aPrimary. +void NS_MergeReflowStatusInto(nsReflowStatus* aPrimary, + nsReflowStatus aSecondary); + +//---------------------------------------------------------------------- + +/** + * DidReflow status values. + */ +enum class nsDidReflowStatus : uint32_t { + NOT_FINISHED, + FINISHED +}; + +/** + * When there is no scrollable overflow rect, the visual overflow rect + * may be stored as four 1-byte deltas each strictly LESS THAN 0xff, for + * the four edges of the rectangle, or the four bytes may be read as a + * single 32-bit "overflow-rect type" value including at least one 0xff + * byte as an indicator that the value does NOT represent four deltas. + * If all four deltas are zero, this means that no overflow rect has + * actually been set (this is the initial state of newly-created frames). + */ +#define NS_FRAME_OVERFLOW_DELTA_MAX 0xfe // max delta we can store + +#define NS_FRAME_OVERFLOW_NONE 0x00000000 // there are no overflow rects; + // code relies on this being + // the all-zero value + +#define NS_FRAME_OVERFLOW_LARGE 0x000000ff // overflow is stored as a + // separate rect property + +/** + * nsBidiLevel is the type of the level values in our Unicode Bidi + * implementation. + * It holds an embedding level and indicates the visual direction + * by its bit 0 (even/odd value).<p> + * + * <li><code>aParaLevel</code> can be set to the + * pseudo-level values <code>NSBIDI_DEFAULT_LTR</code> + * and <code>NSBIDI_DEFAULT_RTL</code>.</li></ul> + * + * @see nsBidi::SetPara + * + * <p>The related constants are not real, valid level values. + * <code>NSBIDI_DEFAULT_XXX</code> can be used to specify + * a default for the paragraph level for + * when the <code>SetPara</code> function + * shall determine it but there is no + * strongly typed character in the input.<p> + * + * Note that the value for <code>NSBIDI_DEFAULT_LTR</code> is even + * and the one for <code>NSBIDI_DEFAULT_RTL</code> is odd, + * just like with normal LTR and RTL level values - + * these special values are designed that way. Also, the implementation + * assumes that NSBIDI_MAX_EXPLICIT_LEVEL is odd. + * + * @see NSBIDI_DEFAULT_LTR + * @see NSBIDI_DEFAULT_RTL + * @see NSBIDI_LEVEL_OVERRIDE + * @see NSBIDI_MAX_EXPLICIT_LEVEL + */ +typedef uint8_t nsBidiLevel; + +/** Paragraph level setting. + * If there is no strong character, then set the paragraph level to 0 (left-to-right). + */ +#define NSBIDI_DEFAULT_LTR 0xfe + +/** Paragraph level setting. + * If there is no strong character, then set the paragraph level to 1 (right-to-left). + */ +#define NSBIDI_DEFAULT_RTL 0xff + +/** + * Maximum explicit embedding level. + * (The maximum resolved level can be up to <code>NSBIDI_MAX_EXPLICIT_LEVEL+1</code>). + * + */ +#define NSBIDI_MAX_EXPLICIT_LEVEL 125 + +/** Bit flag for level input. + * Overrides directional properties. + */ +#define NSBIDI_LEVEL_OVERRIDE 0x80 + +/** + * <code>nsBidiDirection</code> values indicate the text direction. + */ +enum nsBidiDirection { + /** All left-to-right text This is a 0 value. */ + NSBIDI_LTR, + /** All right-to-left text This is a 1 value. */ + NSBIDI_RTL, + /** Mixed-directional text. */ + NSBIDI_MIXED +}; + +namespace mozilla { + +// https://drafts.csswg.org/css-align-3/#baseline-sharing-group +enum BaselineSharingGroup +{ + // NOTE Used as an array index so must be 0 and 1. + eFirst = 0, + eLast = 1, +}; + +// Loosely: https://drafts.csswg.org/css-align-3/#shared-alignment-context +enum class AlignmentContext +{ + eInline, + eTable, + eFlexbox, + eGrid, +}; + +/* + * For replaced elements only. Gets the intrinsic dimensions of this element. + * The dimensions may only be one of the following two types: + * + * eStyleUnit_Coord - a length in app units + * eStyleUnit_None - the element has no intrinsic size in this dimension + */ +struct IntrinsicSize { + nsStyleCoord width, height; + + IntrinsicSize() + : width(eStyleUnit_None), height(eStyleUnit_None) + {} + IntrinsicSize(const IntrinsicSize& rhs) + : width(rhs.width), height(rhs.height) + {} + IntrinsicSize& operator=(const IntrinsicSize& rhs) { + width = rhs.width; height = rhs.height; return *this; + } + bool operator==(const IntrinsicSize& rhs) { + return width == rhs.width && height == rhs.height; + } + bool operator!=(const IntrinsicSize& rhs) { + return !(*this == rhs); + } +}; + +// Pseudo bidi embedding level indicating nonexistence. +static const nsBidiLevel kBidiLevelNone = 0xff; + +struct FrameBidiData +{ + nsBidiLevel baseLevel; + nsBidiLevel embeddingLevel; + // The embedding level of virtual bidi formatting character before + // this frame if any. kBidiLevelNone is used to indicate nonexistence + // or unnecessity of such virtual character. + nsBidiLevel precedingControl; +}; + +} // namespace mozilla + +/// Generic destructor for frame properties. Calls delete. +template<typename T> +static void DeleteValue(T* aPropertyValue) +{ + delete aPropertyValue; +} + +/// Generic destructor for frame properties. Calls Release(). +template<typename T> +static void ReleaseValue(T* aPropertyValue) +{ + aPropertyValue->Release(); +} + +//---------------------------------------------------------------------- + +/** + * A frame in the layout model. This interface is supported by all frame + * objects. + * + * Frames can have multiple child lists: the default child list + * (referred to as the <i>principal</i> child list, and additional named + * child lists. There is an ordering of frames within a child list, but + * there is no order defined between frames in different child lists of + * the same parent frame. + * + * Frames are NOT reference counted. Use the Destroy() member function + * to destroy a frame. The lifetime of the frame hierarchy is bounded by the + * lifetime of the presentation shell which owns the frames. + * + * nsIFrame is a private Gecko interface. If you are not Gecko then you + * should not use it. If you're not in layout, then you won't be able to + * link to many of the functions defined here. Too bad. + * + * If you're not in layout but you must call functions in here, at least + * restrict yourself to calling virtual methods, which won't hurt you as badly. + */ +class nsIFrame : public nsQueryFrame +{ +public: + using AlignmentContext = mozilla::AlignmentContext; + using BaselineSharingGroup = mozilla::BaselineSharingGroup; + template <typename T> using Maybe = mozilla::Maybe<T>; + using Nothing = mozilla::Nothing; + using OnNonvisible = mozilla::OnNonvisible; + template<typename T=void> + using PropertyDescriptor = const mozilla::FramePropertyDescriptor<T>*; + using ReflowInput = mozilla::ReflowInput; + using ReflowOutput = mozilla::ReflowOutput; + using Visibility = mozilla::Visibility; + + typedef mozilla::FrameProperties FrameProperties; + typedef mozilla::layers::Layer Layer; + typedef mozilla::layout::FrameChildList ChildList; + typedef mozilla::layout::FrameChildListID ChildListID; + typedef mozilla::layout::FrameChildListIDs ChildListIDs; + typedef mozilla::layout::FrameChildListIterator ChildListIterator; + typedef mozilla::layout::FrameChildListArrayIterator ChildListArrayIterator; + typedef mozilla::gfx::DrawTarget DrawTarget; + typedef mozilla::gfx::Matrix Matrix; + typedef mozilla::gfx::Matrix4x4 Matrix4x4; + typedef mozilla::Sides Sides; + typedef mozilla::LogicalSides LogicalSides; + + NS_DECL_QUERYFRAME_TARGET(nsIFrame) + + nsPresContext* PresContext() const { + return StyleContext()->PresContext(); + } + + /** + * Called to initialize the frame. This is called immediately after creating + * the frame. + * + * If the frame is a continuing frame, then aPrevInFlow indicates the previous + * frame (the frame that was split). + * + * If you want a view associated with your frame, you should create the view + * after Init() has returned. + * + * @param aContent the content object associated with the frame + * @param aParent the parent frame + * @param aPrevInFlow the prev-in-flow frame + */ + virtual void Init(nsIContent* aContent, + nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) = 0; + + /** + * Destroys this frame and each of its child frames (recursively calls + * Destroy() for each child). If this frame is a first-continuation, this + * also removes the frame from the primary frame map and clears undisplayed + * content for its content node. + * If the frame is a placeholder, it also ensures the out-of-flow frame's + * removal and destruction. + */ + void Destroy() { DestroyFrom(this); } + + /** Flags for PeekOffsetCharacter, PeekOffsetNoAmount, PeekOffsetWord return values. + */ + enum FrameSearchResult { + // Peek found a appropriate offset within frame. + FOUND = 0x00, + // try next frame for offset. + CONTINUE = 0x1, + // offset not found because the frame was empty of text. + CONTINUE_EMPTY = 0x2 | CONTINUE, + // offset not found because the frame didn't contain any text that could be selected. + CONTINUE_UNSELECTABLE = 0x4 | CONTINUE, + }; + +protected: + /** + * Return true if the frame is part of a Selection. + * Helper method to implement the public IsSelected() API. + */ + virtual bool IsFrameSelected() const; + + /** + * Implements Destroy(). Do not call this directly except from within a + * DestroyFrom() implementation. + * + * @note This will always be called, so it is not necessary to override + * Destroy() in subclasses of nsFrame, just DestroyFrom(). + * + * @param aDestructRoot is the root of the subtree being destroyed + */ + virtual void DestroyFrom(nsIFrame* aDestructRoot) = 0; + friend class nsFrameList; // needed to pass aDestructRoot through to children + friend class nsLineBox; // needed to pass aDestructRoot through to children + friend class nsContainerFrame; // needed to pass aDestructRoot through to children + friend class nsFrame; // need to assign mParent +public: + + /** + * Get the content object associated with this frame. Does not add a reference. + */ + nsIContent* GetContent() const { return mContent; } + + /** + * Get the frame that should be the parent for the frames of child elements + * May return nullptr during reflow + */ + virtual nsContainerFrame* GetContentInsertionFrame() { return nullptr; } + + /** + * Move any frames on our overflow list to the end of our principal list. + * @return true if there were any overflow frames + */ + virtual bool DrainSelfOverflowList() { return false; } + + /** + * Get the frame that should be scrolled if the content associated + * with this frame is targeted for scrolling. For frames implementing + * nsIScrollableFrame this will return the frame itself. For frames + * like nsTextControlFrame that contain a scrollframe, will return + * that scrollframe. + */ + virtual nsIScrollableFrame* GetScrollTargetFrame() { return nullptr; } + + /** + * Get the offsets of the frame. most will be 0,0 + * + */ + virtual nsresult GetOffsets(int32_t &start, int32_t &end) const = 0; + + /** + * Reset the offsets when splitting frames during Bidi reordering + * + */ + virtual void AdjustOffsetsForBidi(int32_t aStart, int32_t aEnd) {} + + /** + * Get the style context associated with this frame. + */ + nsStyleContext* StyleContext() const { return mStyleContext; } + void SetStyleContext(nsStyleContext* aContext) + { + if (aContext != mStyleContext) { + nsStyleContext* oldStyleContext = mStyleContext; + mStyleContext = aContext; + aContext->AddRef(); +#ifdef DEBUG + aContext->FrameAddRef(); +#endif + DidSetStyleContext(oldStyleContext); +#ifdef DEBUG + oldStyleContext->FrameRelease(); +#endif + oldStyleContext->Release(); + } + } + + /** + * SetStyleContextWithoutNotification is for changes to the style + * context that should suppress style change processing, in other + * words, those that aren't really changes. This generally means only + * changes that happen during frame construction. + */ + void SetStyleContextWithoutNotification(nsStyleContext* aContext) + { + if (aContext != mStyleContext) { +#ifdef DEBUG + mStyleContext->FrameRelease(); +#endif + mStyleContext->Release(); + mStyleContext = aContext; + aContext->AddRef(); +#ifdef DEBUG + aContext->FrameAddRef(); +#endif + } + } + + // Style post processing hook + // Attention: the old style context is the one we're forgetting, + // and hence possibly completely bogus for GetStyle* purposes. + // Use PeekStyleData instead. + virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) = 0; + + /** + * Define typesafe getter functions for each style struct by + * preprocessing the list of style structs. These functions are the + * preferred way to get style data. The macro creates functions like: + * const nsStyleBorder* StyleBorder(); + * const nsStyleColor* StyleColor(); + * + * Callers outside of libxul should use nsIDOMWindow::GetComputedStyle() + * instead of these accessors. + */ + #define STYLE_STRUCT(name_, checkdata_cb_) \ + const nsStyle##name_ * Style##name_ () const { \ + NS_ASSERTION(mStyleContext, "No style context found!"); \ + return mStyleContext->Style##name_ (); \ + } + #include "nsStyleStructList.h" + #undef STYLE_STRUCT + + /** Also forward GetVisitedDependentColor to the style context */ + nscolor GetVisitedDependentColor(nsCSSPropertyID aProperty) + { return mStyleContext->GetVisitedDependentColor(aProperty); } + + /** + * These methods are to access any additional style contexts that + * the frame may be holding. These are contexts that are children + * of the frame's primary context and are NOT used as style contexts + * for any child frames. These contexts also MUST NOT have any child + * contexts whatsoever. If you need to insert style contexts into the + * style tree, then you should create pseudo element frames to own them + * The indicies must be consecutive and implementations MUST return an + * NS_ERROR_INVALID_ARG if asked for an index that is out of range. + */ + virtual nsStyleContext* GetAdditionalStyleContext(int32_t aIndex) const = 0; + + virtual void SetAdditionalStyleContext(int32_t aIndex, + nsStyleContext* aStyleContext) = 0; + + /** + * Accessor functions for geometric parent. + */ + nsContainerFrame* GetParent() const { return mParent; } + /** + * Set this frame's parent to aParent. + * If the frame may have moved into or out of a scrollframe's + * frame subtree, StickyScrollContainer::NotifyReparentedFrameAcrossScrollFrameBoundary + * must also be called. + */ + void SetParent(nsContainerFrame* aParent); + + /** + * The frame's writing-mode, used for logical layout computations. + */ + virtual mozilla::WritingMode GetWritingMode() const { + return mozilla::WritingMode(StyleContext()); + } + + /** + * Get the writing mode of this frame, but if it is styled with + * unicode-bidi: plaintext, reset the direction to the resolved paragraph + * level of the given subframe (typically the first frame on the line), + * not this frame's writing mode, because the container frame could be split + * by hard line breaks into multiple paragraphs with different base direction. + */ + mozilla::WritingMode GetWritingMode(nsIFrame* aSubFrame) const; + + /** + * Bounding rect of the frame. The values are in app units, and the origin is + * relative to the upper-left of the geometric parent. The size includes the + * content area, borders, and padding. + * + * Note: moving or sizing the frame does not affect the view's size or + * position. + */ + nsRect GetRect() const { return mRect; } + nsPoint GetPosition() const { return mRect.TopLeft(); } + nsSize GetSize() const { return mRect.Size(); } + nsRect GetRectRelativeToSelf() const { + return nsRect(nsPoint(0, 0), mRect.Size()); + } + /** + * Dimensions and position in logical coordinates in the frame's writing mode + * or another writing mode + */ + mozilla::LogicalRect GetLogicalRect(const nsSize& aContainerSize) const { + return GetLogicalRect(GetWritingMode(), aContainerSize); + } + mozilla::LogicalPoint GetLogicalPosition(const nsSize& aContainerSize) const { + return GetLogicalPosition(GetWritingMode(), aContainerSize); + } + mozilla::LogicalSize GetLogicalSize() const { + return GetLogicalSize(GetWritingMode()); + } + mozilla::LogicalRect GetLogicalRect(mozilla::WritingMode aWritingMode, + const nsSize& aContainerSize) const { + return mozilla::LogicalRect(aWritingMode, GetRect(), aContainerSize); + } + mozilla::LogicalPoint GetLogicalPosition(mozilla::WritingMode aWritingMode, + const nsSize& aContainerSize) const { + return GetLogicalRect(aWritingMode, aContainerSize).Origin(aWritingMode); + } + mozilla::LogicalSize GetLogicalSize(mozilla::WritingMode aWritingMode) const { + return mozilla::LogicalSize(aWritingMode, GetSize()); + } + nscoord IStart(const nsSize& aContainerSize) const { + return IStart(GetWritingMode(), aContainerSize); + } + nscoord IStart(mozilla::WritingMode aWritingMode, + const nsSize& aContainerSize) const { + return GetLogicalPosition(aWritingMode, aContainerSize).I(aWritingMode); + } + nscoord BStart(const nsSize& aContainerSize) const { + return BStart(GetWritingMode(), aContainerSize); + } + nscoord BStart(mozilla::WritingMode aWritingMode, + const nsSize& aContainerSize) const { + return GetLogicalPosition(aWritingMode, aContainerSize).B(aWritingMode); + } + nscoord ISize() const { return ISize(GetWritingMode()); } + nscoord ISize(mozilla::WritingMode aWritingMode) const { + return GetLogicalSize(aWritingMode).ISize(aWritingMode); + } + nscoord BSize() const { return BSize(GetWritingMode()); } + nscoord BSize(mozilla::WritingMode aWritingMode) const { + return GetLogicalSize(aWritingMode).BSize(aWritingMode); + } + nscoord ContentBSize() const { return ContentBSize(GetWritingMode()); } + nscoord ContentBSize(mozilla::WritingMode aWritingMode) const { + auto bp = GetLogicalUsedBorderAndPadding(aWritingMode); + bp.ApplySkipSides(GetLogicalSkipSides()); + return std::max(0, BSize(aWritingMode) - bp.BStartEnd(aWritingMode)); + } + + /** + * When we change the size of the frame's border-box rect, we may need to + * reset the overflow rect if it was previously stored as deltas. + * (If it is currently a "large" overflow and could be re-packed as deltas, + * we don't bother as the cost of the allocation has already been paid.) + */ + void SetRect(const nsRect& aRect) { + if (mOverflow.mType != NS_FRAME_OVERFLOW_LARGE && + mOverflow.mType != NS_FRAME_OVERFLOW_NONE) { + nsOverflowAreas overflow = GetOverflowAreas(); + mRect = aRect; + SetOverflowAreas(overflow); + } else { + mRect = aRect; + } + } + /** + * Set this frame's rect from a logical rect in its own writing direction + */ + void SetRect(const mozilla::LogicalRect& aRect, + const nsSize& aContainerSize) { + SetRect(GetWritingMode(), aRect, aContainerSize); + } + /** + * Set this frame's rect from a logical rect in a different writing direction + * (GetPhysicalRect will assert if the writing mode doesn't match) + */ + void SetRect(mozilla::WritingMode aWritingMode, + const mozilla::LogicalRect& aRect, + const nsSize& aContainerSize) { + SetRect(aRect.GetPhysicalRect(aWritingMode, aContainerSize)); + } + + /** + * Set this frame's size from a logical size in its own writing direction. + * This leaves the frame's logical position unchanged, which means its + * physical position may change (for right-to-left modes). + */ + void SetSize(const mozilla::LogicalSize& aSize) { + SetSize(GetWritingMode(), aSize); + } + /* + * Set this frame's size from a logical size in a different writing direction. + * This leaves the frame's logical position in the given mode unchanged, + * which means its physical position may change (for right-to-left modes). + */ + void SetSize(mozilla::WritingMode aWritingMode, + const mozilla::LogicalSize& aSize) + { + if ((!aWritingMode.IsVertical() && !aWritingMode.IsBidiLTR()) || + aWritingMode.IsVerticalRL()) { + nscoord oldWidth = mRect.width; + SetSize(aSize.GetPhysicalSize(aWritingMode)); + mRect.x -= mRect.width - oldWidth; + } else { + SetSize(aSize.GetPhysicalSize(aWritingMode)); + } + } + + /** + * Set this frame's physical size. This leaves the frame's physical position + * (topLeft) unchanged. + */ + void SetSize(const nsSize& aSize) { + SetRect(nsRect(mRect.TopLeft(), aSize)); + } + + void SetPosition(const nsPoint& aPt) { mRect.MoveTo(aPt); } + void SetPosition(mozilla::WritingMode aWritingMode, + const mozilla::LogicalPoint& aPt, + const nsSize& aContainerSize) { + // We subtract mRect.Size() from the container size to account for + // the fact that logical origins in RTL coordinate systems are at + // the top right of the frame instead of the top left. + mRect.MoveTo(aPt.GetPhysicalPoint(aWritingMode, + aContainerSize - mRect.Size())); + } + + /** + * Move the frame, accounting for relative positioning. Use this when + * adjusting the frame's position by a known amount, to properly update its + * saved normal position (see GetNormalPosition below). + * + * This must be used only when moving a frame *after* + * ReflowInput::ApplyRelativePositioning is called. When moving + * a frame during the reflow process prior to calling + * ReflowInput::ApplyRelativePositioning, the position should + * simply be adjusted directly (e.g., using SetPosition()). + */ + void MovePositionBy(const nsPoint& aTranslation); + + /** + * As above, using a logical-point delta in a given writing mode. + */ + void MovePositionBy(mozilla::WritingMode aWritingMode, + const mozilla::LogicalPoint& aTranslation) + { + // The LogicalPoint represents a vector rather than a point within a + // rectangular coordinate space, so we use a null containerSize when + // converting logical to physical. + const nsSize nullContainerSize; + MovePositionBy(aTranslation.GetPhysicalPoint(aWritingMode, + nullContainerSize)); + } + + /** + * Return frame's rect without relative positioning + */ + nsRect GetNormalRect() const; + + /** + * Return frame's position without relative positioning + */ + nsPoint GetNormalPosition() const; + mozilla::LogicalPoint + GetLogicalNormalPosition(mozilla::WritingMode aWritingMode, + const nsSize& aContainerSize) const + { + // Subtract the size of this frame from the container size to get + // the correct position in rtl frames where the origin is on the + // right instead of the left + return mozilla::LogicalPoint(aWritingMode, + GetNormalPosition(), + aContainerSize - mRect.Size()); + } + + virtual nsPoint GetPositionOfChildIgnoringScrolling(nsIFrame* aChild) + { return aChild->GetPosition(); } + + nsPoint GetPositionIgnoringScrolling(); + + typedef AutoTArray<nsIContent*, 2> ContentArray; + static void DestroyContentArray(ContentArray* aArray); + +#define NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, dtor) \ + static const mozilla::FramePropertyDescriptor<type>* prop() { \ + /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */ \ + static const auto descriptor = \ + mozilla::FramePropertyDescriptor<type>::NewWithDestructor<dtor>(); \ + return &descriptor; \ + } + +// Don't use this unless you really know what you're doing! +#define NS_DECLARE_FRAME_PROPERTY_WITH_FRAME_IN_DTOR(prop, type, dtor) \ + static const mozilla::FramePropertyDescriptor<type>* prop() { \ + /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */ \ + static const auto descriptor = mozilla:: \ + FramePropertyDescriptor<type>::NewWithDestructorWithFrame<dtor>(); \ + return &descriptor; \ + } + +#define NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(prop, type) \ + static const mozilla::FramePropertyDescriptor<type>* prop() { \ + /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */ \ + static const auto descriptor = \ + mozilla::FramePropertyDescriptor<type>::NewWithoutDestructor(); \ + return &descriptor; \ + } + +#define NS_DECLARE_FRAME_PROPERTY_DELETABLE(prop, type) \ + NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, DeleteValue) + +#define NS_DECLARE_FRAME_PROPERTY_RELEASABLE(prop, type) \ + NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, ReleaseValue) + +#define NS_DECLARE_FRAME_PROPERTY_WITH_DTOR_NEVER_CALLED(prop, type) \ + static void AssertOnDestroyingProperty##prop(type*) { \ + MOZ_ASSERT_UNREACHABLE("Frame property " #prop " should never " \ + "be destroyed by the FramePropertyTable"); \ + } \ + NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, \ + AssertOnDestroyingProperty##prop) + +#define NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(prop, type) \ + NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(prop, mozilla::SmallValueHolder<type>) + + NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(IBSplitSibling, nsIFrame) + NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(IBSplitPrevSibling, nsIFrame) + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(NormalPositionProperty, nsPoint) + NS_DECLARE_FRAME_PROPERTY_DELETABLE(ComputedOffsetProperty, nsMargin) + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(OutlineInnerRectProperty, nsRect) + NS_DECLARE_FRAME_PROPERTY_DELETABLE(PreEffectsBBoxProperty, nsRect) + NS_DECLARE_FRAME_PROPERTY_DELETABLE(PreTransformOverflowAreasProperty, + nsOverflowAreas) + + // The initial overflow area passed to FinishAndStoreOverflow. This is only set + // on frames that Preserve3D() or HasPerspective() or IsTransformed(), and + // when at least one of the overflow areas differs from the frame bound rect. + NS_DECLARE_FRAME_PROPERTY_DELETABLE(InitialOverflowProperty, nsOverflowAreas) + +#ifdef DEBUG + // InitialOverflowPropertyDebug is added to the frame to indicate that either + // the InitialOverflowProperty has been stored or the InitialOverflowProperty + // has been suppressed due to being set to the default value (frame bounds) + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(DebugInitialOverflowPropertyApplied, bool) +#endif + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(UsedMarginProperty, nsMargin) + NS_DECLARE_FRAME_PROPERTY_DELETABLE(UsedPaddingProperty, nsMargin) + NS_DECLARE_FRAME_PROPERTY_DELETABLE(UsedBorderProperty, nsMargin) + + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(LineBaselineOffset, nscoord) + + // Temporary override for a flex item's main-size property (either width + // or height), imposed by its flex container. + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(FlexItemMainSizeOverride, nscoord) + + NS_DECLARE_FRAME_PROPERTY_RELEASABLE(CachedBackgroundImageDT, DrawTarget) + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(InvalidationRect, nsRect) + + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(RefusedAsyncAnimationProperty, bool) + + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(FragStretchBSizeProperty, nscoord) + + // The block-axis margin-box size associated with eBClampMarginBoxMinSize. + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(BClampMarginBoxMinSizeProperty, nscoord) + + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(IBaselinePadProperty, nscoord) + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(BBaselinePadProperty, nscoord) + + NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(GenConProperty, ContentArray, + DestroyContentArray) + + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(BidiDataProperty, mozilla::FrameBidiData) + + mozilla::FrameBidiData GetBidiData() + { + return Properties().Get(BidiDataProperty()); + } + + nsBidiLevel GetBaseLevel() + { + return GetBidiData().baseLevel; + } + + nsBidiLevel GetEmbeddingLevel() + { + return GetBidiData().embeddingLevel; + } + + nsTArray<nsIContent*>* GetGenConPseudos() { + return Properties().Get(GenConProperty()); + } + + /** + * Return the distance between the border edge of the frame and the + * margin edge of the frame. Like GetRect(), returns the dimensions + * as of the most recent reflow. + * + * This doesn't include any margin collapsing that may have occurred. + * + * It also treats 'auto' margins as zero, and treats any margins that + * should have been turned into 'auto' because of overconstraint as + * having their original values. + */ + virtual nsMargin GetUsedMargin() const; + virtual mozilla::LogicalMargin + GetLogicalUsedMargin(mozilla::WritingMode aWritingMode) const { + return mozilla::LogicalMargin(aWritingMode, GetUsedMargin()); + } + + /** + * Return the distance between the border edge of the frame (which is + * its rect) and the padding edge of the frame. Like GetRect(), returns + * the dimensions as of the most recent reflow. + * + * Note that this differs from StyleBorder()->GetComputedBorder() in + * that this describes a region of the frame's box, and + * StyleBorder()->GetComputedBorder() describes a border. They differ + * for tables (particularly border-collapse tables) and themed + * elements. + */ + virtual nsMargin GetUsedBorder() const; + virtual mozilla::LogicalMargin + GetLogicalUsedBorder(mozilla::WritingMode aWritingMode) const { + return mozilla::LogicalMargin(aWritingMode, GetUsedBorder()); + } + + /** + * Return the distance between the padding edge of the frame and the + * content edge of the frame. Like GetRect(), returns the dimensions + * as of the most recent reflow. + */ + virtual nsMargin GetUsedPadding() const; + virtual mozilla::LogicalMargin + GetLogicalUsedPadding(mozilla::WritingMode aWritingMode) const { + return mozilla::LogicalMargin(aWritingMode, GetUsedPadding()); + } + + nsMargin GetUsedBorderAndPadding() const { + return GetUsedBorder() + GetUsedPadding(); + } + mozilla::LogicalMargin + GetLogicalUsedBorderAndPadding(mozilla::WritingMode aWritingMode) const { + return mozilla::LogicalMargin(aWritingMode, GetUsedBorderAndPadding()); + } + + /** + * Like the frame's rect (see |GetRect|), which is the border rect, + * other rectangles of the frame, in app units, relative to the parent. + */ + nsRect GetPaddingRect() const; + nsRect GetPaddingRectRelativeToSelf() const; + nsRect GetContentRect() const; + nsRect GetContentRectRelativeToSelf() const; + nsRect GetMarginRectRelativeToSelf() const; + + /** + * The area to paint box-shadows around. The default is the border rect. + * (nsFieldSetFrame overrides this). + */ + virtual nsRect VisualBorderRectRelativeToSelf() const { + return nsRect(0, 0, mRect.width, mRect.height); + } + + /** + * Get the size, in app units, of the border radii. It returns FALSE iff all + * returned radii == 0 (so no border radii), TRUE otherwise. + * For the aRadii indexes, use the NS_CORNER_* constants in nsStyleConsts.h + * If a side is skipped via aSkipSides, its corners are forced to 0. + * + * All corner radii are then adjusted so they do not require more + * space than aBorderArea, according to the algorithm in css3-background. + * + * aFrameSize is used as the basis for percentage widths and heights. + * aBorderArea is used for the adjustment of radii that might be too + * large. + * FIXME: In the long run, we can probably get away with only one of + * these, especially if we change the way we handle outline-radius (by + * removing it and inflating the border radius) + * + * Return whether any radii are nonzero. + */ + static bool ComputeBorderRadii(const nsStyleCorners& aBorderRadius, + const nsSize& aFrameSize, + const nsSize& aBorderArea, + Sides aSkipSides, + nscoord aRadii[8]); + + /* + * Given a set of border radii for one box (e.g., border box), convert + * it to the equivalent set of radii for another box (e.g., in to + * padding box, out to outline box) by reducing radii or increasing + * nonzero radii as appropriate. + * + * Indices into aRadii are the NS_CORNER_* constants in nsStyleConsts.h + * + * Note that InsetBorderRadii is lossy, since it can turn nonzero + * radii into zero, and OutsetBorderRadii does not inflate zero radii. + * Therefore, callers should always inset or outset directly from the + * original value coming from style. + */ + static void InsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets); + static void OutsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets); + + /** + * Fill in border radii for this frame. Return whether any are nonzero. + * Indices into aRadii are the NS_CORNER_* constants in nsStyleConsts.h + * aSkipSides is a union of SIDE_BIT_LEFT/RIGHT/TOP/BOTTOM bits that says + * which side(s) to skip. + */ + virtual bool GetBorderRadii(const nsSize& aFrameSize, + const nsSize& aBorderArea, + Sides aSkipSides, + nscoord aRadii[8]) const; + bool GetBorderRadii(nscoord aRadii[8]) const; + + bool GetPaddingBoxBorderRadii(nscoord aRadii[8]) const; + bool GetContentBoxBorderRadii(nscoord aRadii[8]) const; + + /** + * XXX: this method will likely be replaced by GetVerticalAlignBaseline + * Get the position of the frame's baseline, relative to the top of + * the frame (its top border edge). Only valid when Reflow is not + * needed. + * @note You should only call this on frames with a WM that's parallel to aWM. + * @param aWM the writing-mode of the alignment context, with the ltr/rtl + * direction tweak done by nsIFrame::GetWritingMode(nsIFrame*) in inline + * contexts (see that method). + */ + virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWM) const = 0; + + /** + * Synthesize a first(last) inline-axis baseline from our margin-box. + * An alphabetical baseline is at the start(end) edge and a central baseline + * is at the center of our block-axis margin-box (aWM tells which to use). + * https://drafts.csswg.org/css-align-3/#synthesize-baselines + * @note You should only call this on frames with a WM that's parallel to aWM. + * @param aWM the writing-mode of the alignment context + * @return an offset from our border-box block-axis start(end) edge for + * a first(last) baseline respectively + * (implemented in nsIFrameInlines.h) + */ + inline nscoord SynthesizeBaselineBOffsetFromMarginBox( + mozilla::WritingMode aWM, + BaselineSharingGroup aGroup) const; + + /** + * Synthesize a first(last) inline-axis baseline from our border-box. + * An alphabetical baseline is at the start(end) edge and a central baseline + * is at the center of our block-axis border-box (aWM tells which to use). + * https://drafts.csswg.org/css-align-3/#synthesize-baselines + * @note The returned value is only valid when reflow is not needed. + * @note You should only call this on frames with a WM that's parallel to aWM. + * @param aWM the writing-mode of the alignment context + * @return an offset from our border-box block-axis start(end) edge for + * a first(last) baseline respectively + * (implemented in nsIFrameInlines.h) + */ + inline nscoord SynthesizeBaselineBOffsetFromBorderBox( + mozilla::WritingMode aWM, + BaselineSharingGroup aGroup) const; + + /** + * Return the position of the frame's inline-axis baseline, or synthesize one + * for the given alignment context. The returned baseline is the distance from + * the block-axis border-box start(end) edge for aBaselineGroup eFirst(eLast). + * @note The returned value is only valid when reflow is not needed. + * @note You should only call this on frames with a WM that's parallel to aWM. + * @param aWM the writing-mode of the alignment context + * @param aBaselineOffset out-param, only valid if the method returns true + * (implemented in nsIFrameInlines.h) + */ + inline nscoord BaselineBOffset(mozilla::WritingMode aWM, + BaselineSharingGroup aBaselineGroup, + AlignmentContext aAlignmentContext) const; + + /** + * XXX: this method is taking over the role that GetLogicalBaseline has. + * Return true if the frame has a CSS2 'vertical-align' baseline. + * If it has, then the returned baseline is the distance from the block- + * axis border-box start edge. + * @note This method should only be used in AlignmentContext::eInline contexts. + * @note The returned value is only valid when reflow is not needed. + * @note You should only call this on frames with a WM that's parallel to aWM. + * @param aWM the writing-mode of the alignment context + * @param aBaseline the baseline offset, only valid if the method returns true + */ + virtual bool GetVerticalAlignBaseline(mozilla::WritingMode aWM, + nscoord* aBaseline) const { + return false; + } + + /** + * Return true if the frame has a first(last) inline-axis natural baseline per + * CSS Box Alignment. If so, then the returned baseline is the distance from + * the block-axis border-box start(end) edge for aBaselineGroup eFirst(eLast). + * https://drafts.csswg.org/css-align-3/#natural-baseline + * @note The returned value is only valid when reflow is not needed. + * @note You should only call this on frames with a WM that's parallel to aWM. + * @param aWM the writing-mode of the alignment context + * @param aBaseline the baseline offset, only valid if the method returns true + */ + virtual bool GetNaturalBaselineBOffset(mozilla::WritingMode aWM, + BaselineSharingGroup aBaselineGroup, + nscoord* aBaseline) const { + return false; + } + + /** + * Get the position of the baseline on which the caret needs to be placed, + * relative to the top of the frame. This is mostly needed for frames + * which return a baseline from GetBaseline which is not useful for + * caret positioning. + */ + virtual nscoord GetCaretBaseline() const { + return GetLogicalBaseline(GetWritingMode()); + } + + /////////////////////////////////////////////////////////////////////////////// + // The public visibility API. + /////////////////////////////////////////////////////////////////////////////// + + /// @return true if we're tracking visibility for this frame. + bool TrackingVisibility() const + { + return bool(GetStateBits() & NS_FRAME_VISIBILITY_IS_TRACKED); + } + + /// @return the visibility state of this frame. See the Visibility enum + /// for the possible return values and their meanings. + Visibility GetVisibility() const; + + /// Update the visibility state of this frame synchronously. + /// XXX(seth): Avoid using this method; we should be relying on the refresh + /// driver for visibility updates. This method, which replaces + /// nsLayoutUtils::UpdateApproximateFrameVisibility(), exists purely as a + /// temporary measure to avoid changing behavior during the transition from + /// the old image visibility code. + void UpdateVisibilitySynchronously(); + + // A frame property which stores the visibility state of this frame. Right + // now that consists of an approximate visibility counter represented as a + // uint32_t. When the visibility of this frame is not being tracked, this + // property is absent. + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(VisibilityStateProperty, uint32_t); + +protected: + + /** + * Subclasses can call this method to enable visibility tracking for this frame. + * + * If visibility tracking was previously disabled, this will schedule an + * update an asynchronous update of visibility. + */ + void EnableVisibilityTracking(); + + /** + * Subclasses can call this method to disable visibility tracking for this frame. + * + * Note that if visibility tracking was previously enabled, disabling visibility + * tracking will cause a synchronous call to OnVisibilityChange(). + */ + void DisableVisibilityTracking(); + + /** + * Called when a frame transitions between visibility states (for example, + * from nonvisible to visible, or from visible to nonvisible). + * + * @param aNewVisibility The new visibility state. + * @param aNonvisibleAction A requested action if the frame has become + * nonvisible. If Nothing(), no action is + * requested. If DISCARD_IMAGES is specified, the + * frame is requested to ask any images it's + * associated with to discard their surfaces if + * possible. + * + * Subclasses which override this method should call their parent class's + * implementation. + */ + virtual void OnVisibilityChange(Visibility aNewVisibility, + Maybe<OnNonvisible> aNonvisibleAction = Nothing()); + +public: + + /////////////////////////////////////////////////////////////////////////////// + // Internal implementation for the approximate frame visibility API. + /////////////////////////////////////////////////////////////////////////////// + + /** + * We track the approximate visibility of frames using a counter; if it's + * non-zero, then the frame is considered visible. Using a counter allows us + * to account for situations where the frame may be visible in more than one + * place (for example, via -moz-element), and it simplifies the + * implementation of our approximate visibility tracking algorithms. + * + * @param aNonvisibleAction A requested action if the frame has become + * nonvisible. If Nothing(), no action is + * requested. If DISCARD_IMAGES is specified, the + * frame is requested to ask any images it's + * associated with to discard their surfaces if + * possible. + */ + void DecApproximateVisibleCount(Maybe<OnNonvisible> aNonvisibleAction = Nothing()); + void IncApproximateVisibleCount(); + + + /** + * Get the specified child list. + * + * @param aListID identifies the requested child list. + * @return the child list. If the requested list is unsupported by this + * frame type, an empty list will be returned. + */ + virtual const nsFrameList& GetChildList(ChildListID aListID) const = 0; + const nsFrameList& PrincipalChildList() const { return GetChildList(kPrincipalList); } + virtual void GetChildLists(nsTArray<ChildList>* aLists) const = 0; + + /** + * Gets the child lists for this frame, including + * ones belong to a child document. + */ + void GetCrossDocChildLists(nsTArray<ChildList>* aLists); + + // The individual concrete child lists. + static const ChildListID kPrincipalList = mozilla::layout::kPrincipalList; + static const ChildListID kAbsoluteList = mozilla::layout::kAbsoluteList; + static const ChildListID kBulletList = mozilla::layout::kBulletList; + static const ChildListID kCaptionList = mozilla::layout::kCaptionList; + static const ChildListID kColGroupList = mozilla::layout::kColGroupList; + static const ChildListID kExcessOverflowContainersList = mozilla::layout::kExcessOverflowContainersList; + static const ChildListID kFixedList = mozilla::layout::kFixedList; + static const ChildListID kFloatList = mozilla::layout::kFloatList; + static const ChildListID kOverflowContainersList = mozilla::layout::kOverflowContainersList; + static const ChildListID kOverflowList = mozilla::layout::kOverflowList; + static const ChildListID kOverflowOutOfFlowList = mozilla::layout::kOverflowOutOfFlowList; + static const ChildListID kPopupList = mozilla::layout::kPopupList; + static const ChildListID kPushedFloatsList = mozilla::layout::kPushedFloatsList; + static const ChildListID kSelectPopupList = mozilla::layout::kSelectPopupList; + static const ChildListID kBackdropList = mozilla::layout::kBackdropList; + // A special alias for kPrincipalList that do not request reflow. + static const ChildListID kNoReflowPrincipalList = mozilla::layout::kNoReflowPrincipalList; + + /** + * Child frames are linked together in a doubly-linked list + */ + nsIFrame* GetNextSibling() const { return mNextSibling; } + void SetNextSibling(nsIFrame* aNextSibling) { + NS_ASSERTION(this != aNextSibling, "Creating a circular frame list, this is very bad."); + if (mNextSibling && mNextSibling->GetPrevSibling() == this) { + mNextSibling->mPrevSibling = nullptr; + } + mNextSibling = aNextSibling; + if (mNextSibling) { + mNextSibling->mPrevSibling = this; + } + } + + nsIFrame* GetPrevSibling() const { return mPrevSibling; } + + /** + * Builds the display lists for the content represented by this frame + * and its descendants. The background+borders of this element must + * be added first, before any other content. + * + * This should only be called by methods in nsFrame. Instead of calling this + * directly, call either BuildDisplayListForStackingContext or + * BuildDisplayListForChild. + * + * See nsDisplayList.h for more information about display lists. + * + * @param aDirtyRect content outside this rectangle can be ignored; the + * rectangle is in frame coordinates + */ + virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsRect& aDirtyRect, + const nsDisplayListSet& aLists) {} + /** + * Displays the caret onto the given display list builder. The caret is + * painted on top of the rest of the display list items. + * + * @param aDirtyRect is the dirty rectangle that we're repainting. + */ + void DisplayCaret(nsDisplayListBuilder* aBuilder, + const nsRect& aDirtyRect, + nsDisplayList* aList); + + /** + * Get the preferred caret color at the offset. + * + * @param aOffset is offset of the content. + */ + virtual nscolor GetCaretColorAt(int32_t aOffset); + + + bool IsThemed(nsITheme::Transparency* aTransparencyState = nullptr) const { + return IsThemed(StyleDisplay(), aTransparencyState); + } + bool IsThemed(const nsStyleDisplay* aDisp, + nsITheme::Transparency* aTransparencyState = nullptr) const { + nsIFrame* mutable_this = const_cast<nsIFrame*>(this); + if (!aDisp->mAppearance) + return false; + nsPresContext* pc = PresContext(); + nsITheme *theme = pc->GetTheme(); + if(!theme || + !theme->ThemeSupportsWidget(pc, mutable_this, aDisp->mAppearance)) + return false; + if (aTransparencyState) { + *aTransparencyState = + theme->GetWidgetTransparency(mutable_this, aDisp->mAppearance); + } + return true; + } + + /** + * Builds a display list for the content represented by this frame, + * treating this frame as the root of a stacking context. + * @param aDirtyRect content outside this rectangle can be ignored; the + * rectangle is in frame coordinates + */ + void BuildDisplayListForStackingContext(nsDisplayListBuilder* aBuilder, + const nsRect& aDirtyRect, + nsDisplayList* aList); + + enum { + DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT = 0x01, + DISPLAY_CHILD_FORCE_STACKING_CONTEXT = 0x02, + DISPLAY_CHILD_INLINE = 0x04 + }; + /** + * Adjusts aDirtyRect for the child's offset, checks that the dirty rect + * actually intersects the child (or its descendants), calls BuildDisplayList + * on the child if necessary, and puts things in the right lists if the child + * is positioned. + * + * @param aFlags combination of DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT, + * DISPLAY_CHILD_FORCE_STACKING_CONTEXT and DISPLAY_CHILD_INLINE + */ + void BuildDisplayListForChild(nsDisplayListBuilder* aBuilder, + nsIFrame* aChild, + const nsRect& aDirtyRect, + const nsDisplayListSet& aLists, + uint32_t aFlags = 0); + + /** + * Does this frame need a view? + */ + virtual bool NeedsView() { return false; } + + bool RefusedAsyncAnimation() const + { + return Properties().Get(RefusedAsyncAnimationProperty()); + } + + /** + * Returns true if this frame is transformed (e.g. has CSS or SVG transforms) + * or if its parent is an SVG frame that has children-only transforms (e.g. + * an SVG viewBox attribute) or if its transform-style is preserve-3d or + * the frame has transform animations. + */ + bool IsTransformed() const; + + /** + * Returns true if the frame is translucent or the frame has opacity + * animations for the purposes of creating a stacking context. + */ + bool HasOpacity() const + { + return HasOpacityInternal(1.0f); + } + /** + * Returns true if the frame is translucent for display purposes. + */ + bool HasVisualOpacity() const + { + // Treat an opacity value of 0.99 and above as opaque. This is an + // optimization aimed at Web content which use opacity:0.99 as a hint for + // creating a stacking context only. + return HasOpacityInternal(0.99f); + } + + /** + * Return true if this frame might be using a transform getter. + */ + virtual bool HasTransformGetter() const { return false; } + + /** + * Returns true if this frame is an SVG frame that has SVG transforms applied + * to it, or if its parent frame is an SVG frame that has children-only + * transforms (e.g. an SVG viewBox attribute). + * If aOwnTransforms is non-null and the frame has its own SVG transforms, + * aOwnTransforms will be set to these transforms. If aFromParentTransforms + * is non-null and the frame has an SVG parent with children-only transforms, + * then aFromParentTransforms will be set to these transforms. + */ + virtual bool IsSVGTransformed(Matrix *aOwnTransforms = nullptr, + Matrix *aFromParentTransforms = nullptr) const; + + /** + * Returns whether this frame will attempt to extend the 3d transforms of its + * children. This requires transform-style: preserve-3d, as well as no clipping + * or svg effects. + */ + bool Extend3DContext() const; + + /** + * Returns whether this frame has a parent that Extend3DContext() and has + * its own transform (or hidden backface) to be combined with the parent's + * transform. + */ + bool Combines3DTransformWithAncestors() const; + + /** + * Returns whether this frame has a hidden backface and has a parent that + * Extend3DContext(). This is useful because in some cases the hidden + * backface can safely be ignored if it could not be visible anyway. + */ + bool In3DContextAndBackfaceIsHidden() const; + + bool IsPreserve3DLeaf() const { + return Combines3DTransformWithAncestors() && !Extend3DContext(); + } + + bool HasPerspective() const; + + bool ChildrenHavePerspective() const; + + /** + * Includes the overflow area of all descendants that participate in the current + * 3d context into aOverflowAreas. + */ + void ComputePreserve3DChildrenOverflow(nsOverflowAreas& aOverflowAreas); + + void RecomputePerspectiveChildrenOverflow(const nsIFrame* aStartFrame); + + /** + * Returns the number of ancestors between this and the root of our frame tree + */ + uint32_t GetDepthInFrameTree() const; + + /** + * Event handling of GUI events. + * + * @param aEvent event structure describing the type of event and rge widget + * where the event originated + * The |point| member of this is in the coordinate system of the + * view returned by GetOffsetFromView. + * @param aEventStatus a return value indicating whether the event was handled + * and whether default processing should be done + * + * XXX From a frame's perspective it's unclear what the effect of the event status + * is. Does it cause the event to continue propagating through the frame hierarchy + * or is it just returned to the widgets? + * + * @see WidgetGUIEvent + * @see nsEventStatus + */ + virtual nsresult HandleEvent(nsPresContext* aPresContext, + mozilla::WidgetGUIEvent* aEvent, + nsEventStatus* aEventStatus) = 0; + + virtual nsresult GetContentForEvent(mozilla::WidgetEvent* aEvent, + nsIContent** aContent) = 0; + + // This structure keeps track of the content node and offsets associated with + // a point; there is a primary and a secondary offset associated with any + // point. The primary and secondary offsets differ when the point is over a + // non-text object. The primary offset is the expected position of the + // cursor calculated from a point; the secondary offset, when it is different, + // indicates that the point is in the boundaries of some selectable object. + // Note that the primary offset can be after the secondary offset; for places + // that need the beginning and end of the object, the StartOffset and + // EndOffset helpers can be used. + struct MOZ_STACK_CLASS ContentOffsets + { + ContentOffsets() : offset(0) + , secondaryOffset(0) + , associate(mozilla::CARET_ASSOCIATE_BEFORE) {} + bool IsNull() { return !content; } + // Helpers for places that need the ends of the offsets and expect them in + // numerical order, as opposed to wanting the primary and secondary offsets + int32_t StartOffset() { return std::min(offset, secondaryOffset); } + int32_t EndOffset() { return std::max(offset, secondaryOffset); } + + nsCOMPtr<nsIContent> content; + int32_t offset; + int32_t secondaryOffset; + // This value indicates whether the associated content is before or after + // the offset; the most visible use is to allow the caret to know which line + // to display on. + mozilla::CaretAssociationHint associate; + }; + enum { + IGNORE_SELECTION_STYLE = 0x01, + // Treat visibility:hidden frames as non-selectable + SKIP_HIDDEN = 0x02 + }; + /** + * This function calculates the content offsets for selection relative to + * a point. Note that this should generally only be callled on the event + * frame associated with an event because this function does not account + * for frame lists other than the primary one. + * @param aPoint point relative to this frame + */ + ContentOffsets GetContentOffsetsFromPoint(nsPoint aPoint, + uint32_t aFlags = 0); + + virtual ContentOffsets GetContentOffsetsFromPointExternal(nsPoint aPoint, + uint32_t aFlags = 0) + { return GetContentOffsetsFromPoint(aPoint, aFlags); } + + /** + * Ensure that aImage gets notifed when the underlying image request loads + * or animates. + */ + void AssociateImage(const nsStyleImage& aImage, nsPresContext* aPresContext); + + /** + * This structure holds information about a cursor. mContainer represents a + * loaded image that should be preferred. If it is not possible to use it, or + * if it is null, mCursor should be used. + */ + struct MOZ_STACK_CLASS Cursor { + nsCOMPtr<imgIContainer> mContainer; + int32_t mCursor; + bool mHaveHotspot; + bool mLoading; + float mHotspotX, mHotspotY; + }; + /** + * Get the cursor for a given frame. + */ + virtual nsresult GetCursor(const nsPoint& aPoint, + Cursor& aCursor) = 0; + + /** + * Get a point (in the frame's coordinate space) given an offset into + * the content. This point should be on the baseline of text with + * the correct horizontal offset + */ + virtual nsresult GetPointFromOffset(int32_t inOffset, + nsPoint* outPoint) = 0; + + /** + * Get a list of character rects in a given range. + * This is similar version of GetPointFromOffset. + */ + virtual nsresult GetCharacterRectsInRange(int32_t aInOffset, + int32_t aLength, + nsTArray<nsRect>& aRects) = 0; + + /** + * Get the child frame of this frame which contains the given + * content offset. outChildFrame may be this frame, or nullptr on return. + * outContentOffset returns the content offset relative to the start + * of the returned node. You can also pass a hint which tells the method + * to stick to the end of the first found frame or the beginning of the + * next in case the offset falls on a boundary. + */ + virtual nsresult GetChildFrameContainingOffset(int32_t inContentOffset, + bool inHint,//false stick left + int32_t* outFrameContentOffset, + nsIFrame** outChildFrame) = 0; + + /** + * Get the current frame-state value for this frame. aResult is + * filled in with the state bits. + */ + nsFrameState GetStateBits() const { return mState; } + + /** + * Update the current frame-state value for this frame. + */ + void AddStateBits(nsFrameState aBits) { mState |= aBits; } + void RemoveStateBits(nsFrameState aBits) { mState &= ~aBits; } + + /** + * Checks if the current frame-state includes all of the listed bits + */ + bool HasAllStateBits(nsFrameState aBits) const + { + return (mState & aBits) == aBits; + } + + /** + * Checks if the current frame-state includes any of the listed bits + */ + bool HasAnyStateBits(nsFrameState aBits) const + { + return mState & aBits; + } + + /** + * This call is invoked on the primary frame for a character data content + * node, when it is changed in the content tree. + */ + virtual nsresult CharacterDataChanged(CharacterDataChangeInfo* aInfo) = 0; + + /** + * This call is invoked when the value of a content objects's attribute + * is changed. + * The first frame that maps that content is asked to deal + * with the change by doing whatever is appropriate. + * + * @param aNameSpaceID the namespace of the attribute + * @param aAttribute the atom name of the attribute + * @param aModType Whether or not the attribute was added, changed, or removed. + * The constants are defined in nsIDOMMutationEvent.h. + */ + virtual nsresult AttributeChanged(int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType) = 0; + + /** + * When the content states of a content object change, this method is invoked + * on the primary frame of that content object. + * + * @param aStates the changed states + */ + virtual void ContentStatesChanged(mozilla::EventStates aStates); + + /** + * Return how your frame can be split. + */ + virtual nsSplittableType GetSplittableType() const = 0; + + /** + * Continuation member functions + */ + virtual nsIFrame* GetPrevContinuation() const = 0; + virtual void SetPrevContinuation(nsIFrame*) = 0; + virtual nsIFrame* GetNextContinuation() const = 0; + virtual void SetNextContinuation(nsIFrame*) = 0; + virtual nsIFrame* FirstContinuation() const { + return const_cast<nsIFrame*>(this); + } + virtual nsIFrame* LastContinuation() const { + return const_cast<nsIFrame*>(this); + } + + /** + * GetTailContinuation gets the last non-overflow-container continuation + * in the continuation chain, i.e. where the next sibling element + * should attach). + */ + nsIFrame* GetTailContinuation(); + + /** + * Flow member functions + */ + virtual nsIFrame* GetPrevInFlowVirtual() const = 0; + nsIFrame* GetPrevInFlow() const { return GetPrevInFlowVirtual(); } + virtual void SetPrevInFlow(nsIFrame*) = 0; + + virtual nsIFrame* GetNextInFlowVirtual() const = 0; + nsIFrame* GetNextInFlow() const { return GetNextInFlowVirtual(); } + virtual void SetNextInFlow(nsIFrame*) = 0; + + /** + * Return the first frame in our current flow. + */ + virtual nsIFrame* FirstInFlow() const { + return const_cast<nsIFrame*>(this); + } + + /** + * Return the last frame in our current flow. + */ + virtual nsIFrame* LastInFlow() const { + return const_cast<nsIFrame*>(this); + } + + /** + * Note: "width" in the names and comments on the following methods + * means inline-size, which could be height in vertical layout + */ + + /** + * Mark any stored intrinsic width information as dirty (requiring + * re-calculation). Note that this should generally not be called + * directly; nsPresShell::FrameNeedsReflow will call it instead. + */ + virtual void MarkIntrinsicISizesDirty() = 0; + + /** + * Get the min-content intrinsic inline size of the frame. This must be + * less than or equal to the max-content intrinsic inline size. + * + * This is *not* affected by the CSS 'min-width', 'width', and + * 'max-width' properties on this frame, but it is affected by the + * values of those properties on this frame's descendants. (It may be + * called during computation of the values of those properties, so it + * cannot depend on any values in the nsStylePosition for this frame.) + * + * The value returned should **NOT** include the space required for + * padding and border. + * + * Note that many frames will cache the result of this function call + * unless MarkIntrinsicISizesDirty is called. + * + * It is not acceptable for a frame to mark itself dirty when this + * method is called. + * + * This method must not return a negative value. + */ + virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) = 0; + + /** + * Get the max-content intrinsic inline size of the frame. This must be + * greater than or equal to the min-content intrinsic inline size. + * + * Otherwise, all the comments for |GetMinISize| above apply. + */ + virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) = 0; + + /** + * |InlineIntrinsicISize| represents the intrinsic width information + * in inline layout. Code that determines the intrinsic width of a + * region of inline layout accumulates the result into this structure. + * This pattern is needed because we need to maintain state + * information about whitespace (for both collapsing and trimming). + */ + struct InlineIntrinsicISizeData { + InlineIntrinsicISizeData() + : mLine(nullptr) + , mLineContainer(nullptr) + , mPrevLines(0) + , mCurrentLine(0) + , mTrailingWhitespace(0) + , mSkipWhitespace(true) + {} + + // The line. This may be null if the inlines are not associated with + // a block or if we just don't know the line. + const nsLineList_iterator* mLine; + + // The line container. Private, to ensure we always use SetLineContainer + // to update it (so that we have a chance to store the mLineContainerWM). + // + // Note that nsContainerFrame::DoInlineIntrinsicISize will clear the + // |mLine| and |mLineContainer| fields when following a next-in-flow link, + // so we must not assume these can always be dereferenced. + private: + nsIFrame* mLineContainer; + + // Setter and getter for the lineContainer field: + public: + void SetLineContainer(nsIFrame* aLineContainer) + { + mLineContainer = aLineContainer; + if (mLineContainer) { + mLineContainerWM = mLineContainer->GetWritingMode(); + } + } + nsIFrame* LineContainer() const { return mLineContainer; } + + // The maximum intrinsic width for all previous lines. + nscoord mPrevLines; + + // The maximum intrinsic width for the current line. At a line + // break (mandatory for preferred width; allowed for minimum width), + // the caller should call |Break()|. + nscoord mCurrentLine; + + // This contains the width of the trimmable whitespace at the end of + // |mCurrentLine|; it is zero if there is no such whitespace. + nscoord mTrailingWhitespace; + + // True if initial collapsable whitespace should be skipped. This + // should be true at the beginning of a block, after hard breaks + // and when the last text ended with whitespace. + bool mSkipWhitespace; + + // Writing mode of the line container (stored here so that we don't + // lose track of it if the mLineContainer field is reset). + mozilla::WritingMode mLineContainerWM; + + // Floats encountered in the lines. + class FloatInfo { + public: + FloatInfo(const nsIFrame* aFrame, nscoord aWidth) + : mFrame(aFrame), mWidth(aWidth) + { } + const nsIFrame* Frame() const { return mFrame; } + nscoord Width() const { return mWidth; } + + private: + const nsIFrame* mFrame; + nscoord mWidth; + }; + + nsTArray<FloatInfo> mFloats; + }; + + struct InlineMinISizeData : public InlineIntrinsicISizeData { + InlineMinISizeData() + : mAtStartOfLine(true) + {} + + // The default implementation for nsIFrame::AddInlineMinISize. + void DefaultAddInlineMinISize(nsIFrame* aFrame, + nscoord aISize, + bool aAllowBreak = true); + + // We need to distinguish forced and optional breaks for cases where the + // current line total is negative. When it is, we need to ignore + // optional breaks to prevent min-width from ending up bigger than + // pref-width. + void ForceBreak(); + + // If the break here is actually taken, aHyphenWidth must be added to the + // width of the current line. + void OptionallyBreak(nscoord aHyphenWidth = 0); + + // Whether we're currently at the start of the line. If we are, we + // can't break (for example, between the text-indent and the first + // word). + bool mAtStartOfLine; + }; + + struct InlinePrefISizeData : public InlineIntrinsicISizeData { + void ForceBreak(); + + // The default implementation for nsIFrame::AddInlinePrefISize. + void DefaultAddInlinePrefISize(nscoord aISize); + }; + + /** + * Add the intrinsic minimum width of a frame in a way suitable for + * use in inline layout to an |InlineIntrinsicISizeData| object that + * represents the intrinsic width information of all the previous + * frames in the inline layout region. + * + * All *allowed* breakpoints within the frame determine what counts as + * a line for the |InlineIntrinsicISizeData|. This means that + * |aData->mTrailingWhitespace| will always be zero (unlike for + * AddInlinePrefISize). + * + * All the comments for |GetMinISize| apply, except that this function + * is responsible for adding padding, border, and margin and for + * considering the effects of 'width', 'min-width', and 'max-width'. + * + * This may be called on any frame. Frames that do not participate in + * line breaking can inherit the default implementation on nsFrame, + * which calls |GetMinISize|. + */ + virtual void + AddInlineMinISize(nsRenderingContext *aRenderingContext, + InlineMinISizeData *aData) = 0; + + /** + * Add the intrinsic preferred width of a frame in a way suitable for + * use in inline layout to an |InlineIntrinsicISizeData| object that + * represents the intrinsic width information of all the previous + * frames in the inline layout region. + * + * All the comments for |AddInlineMinISize| and |GetPrefISize| apply, + * except that this fills in an |InlineIntrinsicISizeData| structure + * based on using all *mandatory* breakpoints within the frame. + */ + virtual void + AddInlinePrefISize(nsRenderingContext *aRenderingContext, + InlinePrefISizeData *aData) = 0; + + /** + * Return the horizontal components of padding, border, and margin + * that contribute to the intrinsic width that applies to the parent. + */ + struct IntrinsicISizeOffsetData { + nscoord hPadding, hBorder, hMargin; + float hPctPadding, hPctMargin; + + IntrinsicISizeOffsetData() + : hPadding(0), hBorder(0), hMargin(0) + , hPctPadding(0.0f), hPctMargin(0.0f) + {} + }; + virtual IntrinsicISizeOffsetData IntrinsicISizeOffsets() = 0; + + /** + * Return the bsize components of padding, border, and margin + * that contribute to the intrinsic width that applies to the parent. + */ + IntrinsicISizeOffsetData IntrinsicBSizeOffsets(); + + virtual mozilla::IntrinsicSize GetIntrinsicSize() = 0; + + /** + * Get the intrinsic ratio of this element, or nsSize(0,0) if it has + * no intrinsic ratio. The intrinsic ratio is the ratio of the + * height/width of a box with an intrinsic size or the intrinsic + * aspect ratio of a scalable vector image without an intrinsic size. + * + * Either one of the sides may be zero, indicating a zero or infinite + * ratio. + */ + virtual nsSize GetIntrinsicRatio() = 0; + + /** + * Bit-flags to pass to ComputeSize in |aFlags| parameter. + */ + enum ComputeSizeFlags { + eDefault = 0, + /** + * Set if the frame is in a context where non-replaced blocks should + * shrink-wrap (e.g., it's floating, absolutely positioned, or + * inline-block). + */ + eShrinkWrap = 1 << 0, + /** + * Set if we'd like to compute our 'auto' bsize, regardless of our actual + * corresponding computed value. (e.g. to get an intrinsic height for flex + * items with "min-height: auto" to use during flexbox layout.) + */ + eUseAutoBSize = 1 << 1, + /** + * Indicates that we should clamp the margin-box min-size to the given CB + * size. This is used for implementing the grid area clamping here: + * https://drafts.csswg.org/css-grid/#min-size-auto + */ + eIClampMarginBoxMinSize = 1 << 2, // clamp in our inline axis + eBClampMarginBoxMinSize = 1 << 3, // clamp in our block axis + }; + + /** + * Compute the size that a frame will occupy. Called while + * constructing the ReflowInput to be used to Reflow the frame, + * in order to fill its mComputedWidth and mComputedHeight member + * variables. + * + * The |height| member of the return value may be + * NS_UNCONSTRAINEDSIZE, but the |width| member must not be. + * + * Note that the reason that border and padding need to be passed + * separately is so that the 'box-sizing' property can be handled. + * Thus aMargin includes absolute positioning offsets as well. + * + * @param aWritingMode The writing mode to use for the returned size + * (need not match this frame's writing mode). + * This is also the writing mode of the passed-in + * LogicalSize parameters. + * @param aCBSize The size of the element's containing block. (Well, + * the |height| component isn't really.) + * @param aAvailableWidth The available width for 'auto' widths. + * This is usually the same as aCBSize.width, + * but differs in cases such as block + * formatting context roots next to floats, or + * in some cases of float reflow in quirks + * mode. + * @param aMargin The sum of the vertical / horizontal margins + * ***AND*** absolute positioning offsets (top, right, + * bottom, left) of the frame, including actual values + * resulting from percentages and from the + * "hypothetical box" for absolute positioning, but + * not including actual values resulting from 'auto' + * margins or ignored 'auto' values in absolute + * positioning. + * @param aBorder The sum of the vertical / horizontal border widths + * of the frame. + * @param aPadding The sum of the vertical / horizontal margins of + * the frame, including actual values resulting from + * percentages. + * @param aFlags Flags to further customize behavior (definitions above). + */ + virtual mozilla::LogicalSize + ComputeSize(nsRenderingContext *aRenderingContext, + mozilla::WritingMode aWritingMode, + const mozilla::LogicalSize& aCBSize, + nscoord aAvailableISize, + const mozilla::LogicalSize& aMargin, + const mozilla::LogicalSize& aBorder, + const mozilla::LogicalSize& aPadding, + ComputeSizeFlags aFlags) = 0; + + /** + * Compute a tight bounding rectangle for the frame. This is a rectangle + * that encloses the pixels that are actually drawn. We're allowed to be + * conservative and currently we don't try very hard. The rectangle is + * in appunits and relative to the origin of this frame. + * + * This probably only needs to include frame bounds, glyph bounds, and + * text decorations, but today it sometimes includes other things that + * contribute to visual overflow. + * + * @param aDrawTarget a draw target that can be used if we need + * to do measurement + */ + virtual nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const; + + /** + * This function is similar to GetPrefISize and ComputeTightBounds: it + * computes the left and right coordinates of a preferred tight bounding + * rectangle for the frame. This is a rectangle that would enclose the pixels + * that are drawn if we lay out the element without taking any optional line + * breaks. The rectangle is in appunits and relative to the origin of this + * frame. Currently, this function is only implemented for nsBlockFrame and + * nsTextFrame and is used to determine intrinsic widths of MathML token + * elements. + + * @param aContext a rendering context that can be used if we need + * to do measurement + * @param aX computed left coordinate of the tight bounding rectangle + * @param aXMost computed intrinsic width of the tight bounding rectangle + * + */ + virtual nsresult GetPrefWidthTightBounds(nsRenderingContext* aContext, + nscoord* aX, + nscoord* aXMost); + + /** + * The frame is given an available size and asked for its desired + * size. This is the frame's opportunity to reflow its children. + * + * If the frame has the NS_FRAME_IS_DIRTY bit set then it is + * responsible for completely reflowing itself and all of its + * descendants. + * + * Otherwise, if the frame has the NS_FRAME_HAS_DIRTY_CHILDREN bit + * set, then it is responsible for reflowing at least those + * children that have NS_FRAME_HAS_DIRTY_CHILDREN or NS_FRAME_IS_DIRTY + * set. + * + * If a difference in available size from the previous reflow causes + * the frame's size to change, it should reflow descendants as needed. + * + * @param aReflowOutput <i>out</i> parameter where you should return the + * desired size and ascent/descent info. You should include any + * space you want for border/padding in the desired size you return. + * + * It's okay to return a desired size that exceeds the avail + * size if that's the smallest you can be, i.e. it's your + * minimum size. + * + * For an incremental reflow you are responsible for invalidating + * any area within your frame that needs repainting (including + * borders). If your new desired size is different than your current + * size, then your parent frame is responsible for making sure that + * the difference between the two rects is repainted + * + * @param aReflowInput information about your reflow including the reason + * for the reflow and the available space in which to lay out. Each + * dimension of the available space can either be constrained or + * unconstrained (a value of NS_UNCONSTRAINEDSIZE). + * + * Note that the available space can be negative. In this case you + * still must return an accurate desired size. If you're a container + * you must <b>always</b> reflow at least one frame regardless of the + * available space + * + * @param aStatus a return value indicating whether the frame is complete + * and whether the next-in-flow is dirty and needs to be reflowed + */ + virtual void Reflow(nsPresContext* aPresContext, + ReflowOutput& aReflowOutput, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) = 0; + + /** + * Post-reflow hook. After a frame is reflowed this method will be called + * informing the frame that this reflow process is complete, and telling the + * frame the status returned by the Reflow member function. + * + * This call may be invoked many times, while NS_FRAME_IN_REFLOW is set, before + * it is finally called once with a NS_FRAME_REFLOW_COMPLETE value. When called + * with a NS_FRAME_REFLOW_COMPLETE value the NS_FRAME_IN_REFLOW bit in the + * frame state will be cleared. + * + * XXX This doesn't make sense. If the frame is reflowed but not complete, then + * the status should be NS_FRAME_NOT_COMPLETE and not NS_FRAME_COMPLETE + * XXX Don't we want the semantics to dictate that we only call this once for + * a given reflow? + */ + virtual void DidReflow(nsPresContext* aPresContext, + const ReflowInput* aReflowInput, + nsDidReflowStatus aStatus) = 0; + + /** + * Updates the overflow areas of the frame. This can be called if an + * overflow area of the frame's children has changed without reflowing. + * @return true if either of the overflow areas for this frame have changed. + */ + bool UpdateOverflow(); + + /** + * Computes any overflow area created by the frame itself (outside of the + * frame bounds) and includes it into aOverflowAreas. + * + * Returns false if updating overflow isn't supported for this frame. + * If the frame requires a reflow instead, then it is responsible + * for scheduling one. + */ + virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) = 0; + + /** + * Computes any overflow area created by children of this frame and + * includes it into aOverflowAreas. + */ + virtual void UnionChildOverflow(nsOverflowAreas& aOverflowAreas) = 0; + + /** + * Helper method used by block reflow to identify runs of text so + * that proper word-breaking can be done. + * + * @return + * true if we can continue a "text run" through the frame. A + * text run is text that should be treated contiguously for line + * and word breaking. + */ + virtual bool CanContinueTextRun() const = 0; + + /** + * Computes an approximation of the rendered text of the frame and its + * continuations. Returns nothing for non-text frames. + * The appended text will often not contain all the whitespace from source, + * depending on CSS white-space processing. + * if aEndOffset goes past end, use the text up to the string's end. + * Call this on the primary frame for a text node. + * aStartOffset and aEndOffset can be content offsets or offsets in the + * rendered text, depending on aOffsetType. + * Returns a string, as well as offsets identifying the start of the text + * within the rendered text for the whole node, and within the text content + * of the node. + */ + struct RenderedText { + nsAutoString mString; + uint32_t mOffsetWithinNodeRenderedText; + int32_t mOffsetWithinNodeText; + RenderedText() : mOffsetWithinNodeRenderedText(0), + mOffsetWithinNodeText(0) {} + }; + enum class TextOffsetType { + // Passed-in start and end offsets are within the content text. + OFFSETS_IN_CONTENT_TEXT, + // Passed-in start and end offsets are within the rendered text. + OFFSETS_IN_RENDERED_TEXT + }; + enum class TrailingWhitespace { + TRIM_TRAILING_WHITESPACE, + // Spaces preceding a caret at the end of a line should not be trimmed + DONT_TRIM_TRAILING_WHITESPACE + }; + virtual RenderedText GetRenderedText(uint32_t aStartOffset = 0, + uint32_t aEndOffset = UINT32_MAX, + TextOffsetType aOffsetType = + TextOffsetType::OFFSETS_IN_CONTENT_TEXT, + TrailingWhitespace aTrimTrailingWhitespace = + TrailingWhitespace::TRIM_TRAILING_WHITESPACE) + { return RenderedText(); } + + /** + * Returns true if the frame contains any non-collapsed characters. + * This method is only available for text frames, and it will return false + * for all other frame types. + */ + virtual bool HasAnyNoncollapsedCharacters() + { return false; } + + /** + * Accessor functions to get/set the associated view object + * + * GetView returns non-null if and only if |HasView| returns true. + */ + bool HasView() const { return !!(mState & NS_FRAME_HAS_VIEW); } + nsView* GetView() const; + nsresult SetView(nsView* aView); + + /** + * Find the closest view (on |this| or an ancestor). + * If aOffset is non-null, it will be set to the offset of |this| + * from the returned view. + */ + nsView* GetClosestView(nsPoint* aOffset = nullptr) const; + + /** + * Find the closest ancestor (excluding |this| !) that has a view + */ + nsIFrame* GetAncestorWithView() const; + + /** + * Get the offset between the coordinate systems of |this| and aOther. + * Adding the return value to a point in the coordinate system of |this| + * will transform the point to the coordinate system of aOther. + * + * aOther must be non-null. + * + * This function is fastest when aOther is an ancestor of |this|. + * + * This function _DOES NOT_ work across document boundaries. + * Use this function only when |this| and aOther are in the same document. + * + * NOTE: this actually returns the offset from aOther to |this|, but + * that offset is added to transform _coordinates_ from |this| to + * aOther. + */ + nsPoint GetOffsetTo(const nsIFrame* aOther) const; + + /** + * Get the offset between the coordinate systems of |this| and aOther + * expressed in appunits per dev pixel of |this|' document. Adding the return + * value to a point that is relative to the origin of |this| will make the + * point relative to the origin of aOther but in the appunits per dev pixel + * ratio of |this|. + * + * aOther must be non-null. + * + * This function is fastest when aOther is an ancestor of |this|. + * + * This function works across document boundaries. + * + * Because this function may cross document boundaries that have different + * app units per dev pixel ratios it needs to be used very carefully. + * + * NOTE: this actually returns the offset from aOther to |this|, but + * that offset is added to transform _coordinates_ from |this| to + * aOther. + */ + nsPoint GetOffsetToCrossDoc(const nsIFrame* aOther) const; + + /** + * Like GetOffsetToCrossDoc, but the caller can specify which appunits + * to return the result in. + */ + nsPoint GetOffsetToCrossDoc(const nsIFrame* aOther, const int32_t aAPD) const; + + /** + * Get the screen rect of the frame in pixels. + * @return the pixel rect of the frame in screen coordinates. + */ + nsIntRect GetScreenRect() const; + + /** + * Get the screen rect of the frame in app units. + * @return the app unit rect of the frame in screen coordinates. + */ + nsRect GetScreenRectInAppUnits() const; + + /** + * Returns the offset from this frame to the closest geometric parent that + * has a view. Also returns the containing view or null in case of error + */ + void GetOffsetFromView(nsPoint& aOffset, nsView** aView) const; + + /** + * Returns the nearest widget containing this frame. If this frame has a + * view and the view has a widget, then this frame's widget is + * returned, otherwise this frame's geometric parent is checked + * recursively upwards. + */ + nsIWidget* GetNearestWidget() const; + + /** + * Same as GetNearestWidget() above but uses an outparam to return the offset + * of this frame to the returned widget expressed in appunits of |this| (the + * widget might be in a different document with a different zoom). + */ + nsIWidget* GetNearestWidget(nsPoint& aOffset) const; + + /** + * Get the "type" of the frame. May return nullptr. + * + * @see nsGkAtoms + */ + virtual nsIAtom* GetType() const = 0; + + /** + * Returns a transformation matrix that converts points in this frame's + * coordinate space to points in some ancestor frame's coordinate space. + * The frame decides which ancestor it will use as a reference point. + * If this frame has no ancestor, aOutAncestor will be set to null. + * + * @param aStopAtAncestor don't look further than aStopAtAncestor. If null, + * all ancestors (including across documents) will be traversed. + * @param aOutAncestor [out] The ancestor frame the frame has chosen. If + * this frame has no ancestor, *aOutAncestor will be set to null. If + * this frame is not a root frame, then *aOutAncestor will be in the same + * document as this frame. If this frame IsTransformed(), then *aOutAncestor + * will be the parent frame (if not preserve-3d) or the nearest non-transformed + * ancestor (if preserve-3d). + * @return A Matrix4x4 that converts points in this frame's coordinate space + * into points in aOutAncestor's coordinate space. + */ + Matrix4x4 GetTransformMatrix(const nsIFrame* aStopAtAncestor, + nsIFrame **aOutAncestor); + + /** + * Bit-flags to pass to IsFrameOfType() + */ + enum { + eMathML = 1 << 0, + eSVG = 1 << 1, + eSVGForeignObject = 1 << 2, + eSVGContainer = 1 << 3, + eSVGGeometry = 1 << 4, + eSVGPaintServer = 1 << 5, + eBidiInlineContainer = 1 << 6, + // the frame is for a replaced element, such as an image + eReplaced = 1 << 7, + // Frame that contains a block but looks like a replaced element + // from the outside + eReplacedContainsBlock = 1 << 8, + // A frame that participates in inline reflow, i.e., one that + // requires ReflowInput::mLineLayout. + eLineParticipant = 1 << 9, + eXULBox = 1 << 10, + eCanContainOverflowContainers = 1 << 11, + eBlockFrame = 1 << 12, + eTablePart = 1 << 13, + // If this bit is set, the frame doesn't allow ignorable whitespace as + // children. For example, the whitespace between <table>\n<tr>\n<td> + // will be excluded during the construction of children. + eExcludesIgnorableWhitespace = 1 << 14, + eSupportsCSSTransforms = 1 << 15, + + // A replaced element that has replaced-element sizing + // characteristics (i.e., like images or iframes), as opposed to + // inline-block sizing characteristics (like form controls). + eReplacedSizing = 1 << 16, + + // These are to allow nsFrame::Init to assert that IsFrameOfType + // implementations all call the base class method. They are only + // meaningful in DEBUG builds. + eDEBUGAllFrames = 1 << 30, + eDEBUGNoFrames = 1 << 31 + }; + + /** + * API for doing a quick check if a frame is of a given + * type. Returns true if the frame matches ALL flags passed in. + * + * Implementations should always override with inline virtual + * functions that call the base class's IsFrameOfType method. + */ + virtual bool IsFrameOfType(uint32_t aFlags) const + { +#ifdef DEBUG + return !(aFlags & ~(nsIFrame::eDEBUGAllFrames | nsIFrame::eSupportsCSSTransforms)); +#else + return !(aFlags & ~nsIFrame::eSupportsCSSTransforms); +#endif + } + + /** + * Returns true if the frame is a block wrapper. + */ + bool IsBlockWrapper() const; + + /** + * Get this frame's CSS containing block. + * + * The algorithm is defined in + * http://www.w3.org/TR/CSS2/visudet.html#containing-block-details. + * + * NOTE: This is guaranteed to return a non-null pointer when invoked on any + * frame other than the root frame. + * + * Requires SKIP_SCROLLED_FRAME to get behaviour matching the spec, otherwise + * it can return anonymous inner scrolled frames. Bug 1204044 is filed for + * investigating whether any of the callers actually require the default + * behaviour. + */ + enum { + // If the containing block is an anonymous scrolled frame, then skip over + // this and return the outer scroll frame. + SKIP_SCROLLED_FRAME = 0x01 + }; + nsIFrame* GetContainingBlock(uint32_t aFlags = 0) const; + + /** + * Is this frame a containing block for floating elements? + * Note that very few frames are, so default to false. + */ + virtual bool IsFloatContainingBlock() const { return false; } + + /** + * Is this a leaf frame? Frames that want the frame constructor to be able + * to construct kids for them should return false, all others should return + * true. Note that returning true here does not mean that the frame _can't_ + * have kids. It could still have kids created via + * nsIAnonymousContentCreator. Returning true indicates that "normal" + * (non-anonymous, XBL-bound, CSS generated content, etc) children should not + * be constructed. + */ + virtual bool IsLeaf() const; + + /** + * Marks all display items created by this frame as needing a repaint, + * and calls SchedulePaint() if requested and one is not already pending. + * + * This includes all display items created by this frame, including + * container types. + * + * @param aDisplayItemKey If specified, only issues an invalidate + * if this frame painted a display item of that type during the + * previous paint. SVG rendering observers are always notified. + */ + virtual void InvalidateFrame(uint32_t aDisplayItemKey = 0); + + /** + * Same as InvalidateFrame(), but only mark a fixed rect as needing + * repainting. + * + * @param aRect The rect to invalidate, relative to the TopLeft of the + * frame's border box. + * @param aDisplayItemKey If specified, only issues an invalidate + * if this frame painted a display item of that type during the + * previous paint. SVG rendering observers are always notified. + */ + virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0); + + /** + * Calls InvalidateFrame() on all frames descendant frames (including + * this one). + * + * This function doesn't walk through placeholder frames to invalidate + * the out-of-flow frames. + * + * @param aDisplayItemKey If specified, only issues an invalidate + * if this frame painted a display item of that type during the + * previous paint. SVG rendering observers are always notified. + */ + void InvalidateFrameSubtree(uint32_t aDisplayItemKey = 0); + + /** + * Called when a frame is about to be removed and needs to be invalidated. + * Normally does nothing since DLBI handles removed frames. + */ + virtual void InvalidateFrameForRemoval() {} + + /** + * When HasUserData(frame->LayerIsPrerenderedDataKey()), then the + * entire overflow area of this frame has been rendered in its + * layer(s). + */ + static void* LayerIsPrerenderedDataKey() { + return &sLayerIsPrerenderedDataKey; + } + static uint8_t sLayerIsPrerenderedDataKey; + + /** + * Try to update this frame's transform without invalidating any + * content. Return true iff successful. If unsuccessful, the + * caller is responsible for scheduling an invalidating paint. + * + * If the result is true, aLayerResult will be filled in with the + * transform layer for the frame. + */ + bool TryUpdateTransformOnly(Layer** aLayerResult); + + /** + * Checks if a frame has had InvalidateFrame() called on it since the + * last paint. + * + * If true, then the invalid rect is returned in aRect, with an + * empty rect meaning all pixels drawn by this frame should be + * invalidated. + * If false, aRect is left unchanged. + */ + bool IsInvalid(nsRect& aRect); + + /** + * Check if any frame within the frame subtree (including this frame) + * returns true for IsInvalid(). + */ + bool HasInvalidFrameInSubtree() + { + return HasAnyStateBits(NS_FRAME_NEEDS_PAINT | NS_FRAME_DESCENDANT_NEEDS_PAINT); + } + + /** + * Removes the invalid state from the current frame and all + * descendant frames. + */ + void ClearInvalidationStateBits(); + + /** + * Ensures that the refresh driver is running, and schedules a view + * manager flush on the next tick. + * + * The view manager flush will update the layer tree, repaint any + * invalid areas in the layer tree and schedule a layer tree + * composite operation to display the layer tree. + * + * In general it is not necessary for frames to call this when they change. + * For example, changes that result in a reflow will have this called for + * them by PresContext::DoReflow when the reflow begins. Style changes that + * do not trigger a reflow should have this called for them by + * DoApplyRenderingChangeToTree. + * + * @param aType PAINT_COMPOSITE_ONLY : No changes have been made + * that require a layer tree update, so only schedule a layer + * tree composite. + * PAINT_DELAYED_COMPRESS : Schedule a paint to be executed after a delay, and + * put FrameLayerBuilder in 'compressed' mode that avoids short cut optimizations. + */ + enum PaintType { + PAINT_DEFAULT = 0, + PAINT_COMPOSITE_ONLY, + PAINT_DELAYED_COMPRESS + }; + void SchedulePaint(PaintType aType = PAINT_DEFAULT); + + /** + * Checks if the layer tree includes a dedicated layer for this + * frame/display item key pair, and invalidates at least aDamageRect + * area within that layer. + * + * If no layer is found, calls InvalidateFrame() instead. + * + * @param aDamageRect Area of the layer to invalidate. + * @param aFrameDamageRect If no layer is found, the area of the frame to + * invalidate. If null, the entire frame will be + * invalidated. + * @param aDisplayItemKey Display item type. + * @param aFlags UPDATE_IS_ASYNC : Will skip the invalidation + * if the found layer is being composited by a remote + * compositor. + * @return Layer, if found, nullptr otherwise. + */ + enum { + UPDATE_IS_ASYNC = 1 << 0 + }; + Layer* InvalidateLayer(uint32_t aDisplayItemKey, + const nsIntRect* aDamageRect = nullptr, + const nsRect* aFrameDamageRect = nullptr, + uint32_t aFlags = 0); + + /** + * Returns a rect that encompasses everything that might be painted by + * this frame. This includes this frame, all its descendant frames, this + * frame's outline, and descendant frames' outline, but does not include + * areas clipped out by the CSS "overflow" and "clip" properties. + * + * HasOverflowRects() (below) will return true when this overflow + * rect has been explicitly set, even if it matches mRect. + * XXX Note: because of a space optimization using the formula above, + * during reflow this function does not give accurate data if + * FinishAndStoreOverflow has been called but mRect hasn't yet been + * updated yet. FIXME: This actually isn't true, but it should be. + * + * The visual overflow rect should NEVER be used for things that + * affect layout. The scrollable overflow rect is permitted to affect + * layout. + * + * @return the rect relative to this frame's origin, but after + * CSS transforms have been applied (i.e. not really this frame's coordinate + * system, and may not contain the frame's border-box, e.g. if there + * is a CSS transform scaling it down) + */ + nsRect GetVisualOverflowRect() const { + return GetOverflowRect(eVisualOverflow); + } + + /** + * Returns a rect that encompasses the area of this frame that the + * user should be able to scroll to reach. This is similar to + * GetVisualOverflowRect, but does not include outline or shadows, and + * may in the future include more margins than visual overflow does. + * It does not include areas clipped out by the CSS "overflow" and + * "clip" properties. + * + * HasOverflowRects() (below) will return true when this overflow + * rect has been explicitly set, even if it matches mRect. + * XXX Note: because of a space optimization using the formula above, + * during reflow this function does not give accurate data if + * FinishAndStoreOverflow has been called but mRect hasn't yet been + * updated yet. + * + * @return the rect relative to this frame's origin, but after + * CSS transforms have been applied (i.e. not really this frame's coordinate + * system, and may not contain the frame's border-box, e.g. if there + * is a CSS transform scaling it down) + */ + nsRect GetScrollableOverflowRect() const { + return GetOverflowRect(eScrollableOverflow); + } + + nsRect GetOverflowRect(nsOverflowType aType) const; + + nsOverflowAreas GetOverflowAreas() const; + + /** + * Same as GetOverflowAreas, except in this frame's coordinate + * system (before transforms are applied). + * + * @return the overflow areas relative to this frame, before any CSS transforms have + * been applied, i.e. in this frame's coordinate system + */ + nsOverflowAreas GetOverflowAreasRelativeToSelf() const; + + /** + * Same as GetScrollableOverflowRect, except relative to the parent + * frame. + * + * @return the rect relative to the parent frame, in the parent frame's + * coordinate system + */ + nsRect GetScrollableOverflowRectRelativeToParent() const; + + /** + * Same as GetScrollableOverflowRect, except in this frame's coordinate + * system (before transforms are applied). + * + * @return the rect relative to this frame, before any CSS transforms have + * been applied, i.e. in this frame's coordinate system + */ + nsRect GetScrollableOverflowRectRelativeToSelf() const; + + /** + * Like GetVisualOverflowRect, except in this frame's + * coordinate system (before transforms are applied). + * + * @return the rect relative to this frame, before any CSS transforms have + * been applied, i.e. in this frame's coordinate system + */ + nsRect GetVisualOverflowRectRelativeToSelf() const; + + /** + * Same as GetVisualOverflowRect, except relative to the parent + * frame. + * + * @return the rect relative to the parent frame, in the parent frame's + * coordinate system + */ + nsRect GetVisualOverflowRectRelativeToParent() const; + + /** + * Returns this frame's visual overflow rect as it would be before taking + * account of SVG effects or transforms. The rect returned is relative to + * this frame. + */ + nsRect GetPreEffectsVisualOverflowRect() const; + + /** + * Store the overflow area in the frame's mOverflow.mVisualDeltas + * fields or as a frame property in the frame manager so that it can + * be retrieved later without reflowing the frame. Returns true if either of + * the overflow areas changed. + */ + bool FinishAndStoreOverflow(nsOverflowAreas& aOverflowAreas, + nsSize aNewSize, nsSize* aOldSize = nullptr); + + bool FinishAndStoreOverflow(ReflowOutput* aMetrics) { + return FinishAndStoreOverflow(aMetrics->mOverflowAreas, + nsSize(aMetrics->Width(), aMetrics->Height())); + } + + /** + * Returns whether the frame has an overflow rect that is different from + * its border-box. + */ + bool HasOverflowAreas() const { + return mOverflow.mType != NS_FRAME_OVERFLOW_NONE; + } + + /** + * Removes any stored overflow rects (visual and scrollable) from the frame. + * Returns true if the overflow changed. + */ + bool ClearOverflowRects(); + + /** + * Determine whether borders, padding, margins etc should NOT be applied + * on certain sides of the frame. + * @see mozilla::Sides in gfx/2d/BaseMargin.h + * @see mozilla::LogicalSides in layout/generic/WritingModes.h + * + * @note (See also bug 743402, comment 11) GetSkipSides() checks to see + * if this frame has a previous or next continuation to determine + * if a side should be skipped. + * Unfortunately, this only works after reflow has been completed. In + * lieu of this, during reflow, an ReflowInput parameter can be + * passed in, indicating that it should be used to determine if sides + * should be skipped during reflow. + */ + Sides GetSkipSides(const ReflowInput* aReflowInput = nullptr) const; + virtual LogicalSides + GetLogicalSkipSides(const ReflowInput* aReflowInput = nullptr) const { + return LogicalSides(); + } + + /** + * @returns true if this frame is selected. + */ + bool IsSelected() const; + + /** + * called to discover where this frame, or a parent frame has user-select style + * applied, which affects that way that it is selected. + * + * @param aIsSelectable out param. Set to true if the frame can be selected + * (i.e. is not affected by user-select: none) + * @param aSelectStyle out param. Returns the type of selection style found + * (using values defined in nsStyleConsts.h). + */ + virtual nsresult IsSelectable(bool* aIsSelectable, + mozilla::StyleUserSelect* aSelectStyle) const = 0; + + /** + * Called to retrieve the SelectionController associated with the frame. + * @param aSelCon will contain the selection controller associated with + * the frame. + */ + virtual nsresult GetSelectionController(nsPresContext *aPresContext, nsISelectionController **aSelCon) = 0; + + /** + * Call to get nsFrameSelection for this frame. + */ + already_AddRefed<nsFrameSelection> GetFrameSelection(); + + /** + * GetConstFrameSelection returns an object which methods are safe to use for + * example in nsIFrame code. + */ + const nsFrameSelection* GetConstFrameSelection() const; + + /** + * called to find the previous/next character, word, or line returns the actual + * nsIFrame and the frame offset. THIS DOES NOT CHANGE SELECTION STATE + * uses frame's begin selection state to start. if no selection on this frame will + * return NS_ERROR_FAILURE + * @param aPOS is defined in nsFrameSelection + */ + virtual nsresult PeekOffset(nsPeekOffsetStruct *aPos); + + /** + * called to find the previous/next non-anonymous selectable leaf frame. + * @param aDirection [in] the direction to move in (eDirPrevious or eDirNext) + * @param aVisual [in] whether bidi caret behavior is visual (true) or logical (false) + * @param aJumpLines [in] whether to allow jumping across line boundaries + * @param aScrollViewStop [in] whether to stop when reaching a scroll frame boundary + * @param aOutFrame [out] the previous/next selectable leaf frame + * @param aOutOffset [out] 0 indicates that we arrived at the beginning of the output frame; + * -1 indicates that we arrived at its end. + * @param aOutJumpedLine [out] whether this frame and the returned frame are on different lines + * @param aOutMovedOverNonSelectableText [out] whether we jumped over a non-selectable + * frame during the search + */ + nsresult GetFrameFromDirection(nsDirection aDirection, bool aVisual, + bool aJumpLines, bool aScrollViewStop, + nsIFrame** aOutFrame, int32_t* aOutOffset, + bool* aOutJumpedLine, bool* aOutMovedOverNonSelectableText); + + /** + * called to see if the children of the frame are visible from indexstart to index end. + * this does not change any state. returns true only if the indexes are valid and any of + * the children are visible. for textframes this index is the character index. + * if aStart = aEnd result will be false + * @param aStart start index of first child from 0-N (number of children) + * @param aEnd end index of last child from 0-N + * @param aRecurse should this frame talk to siblings to get to the contents other children? + * @param aFinished did this frame have the aEndIndex? or is there more work to do + * @param _retval return value true or false. false = range is not rendered. + */ + virtual nsresult CheckVisibility(nsPresContext* aContext, int32_t aStartIndex, int32_t aEndIndex, bool aRecurse, bool *aFinished, bool *_retval)=0; + + /** + * Called to tell a frame that one of its child frames is dirty (i.e., + * has the NS_FRAME_IS_DIRTY *or* NS_FRAME_HAS_DIRTY_CHILDREN bit + * set). This should always set the NS_FRAME_HAS_DIRTY_CHILDREN on + * the frame, and may do other work. + */ + virtual void ChildIsDirty(nsIFrame* aChild) = 0; + + /** + * Called to retrieve this frame's accessible. + * If this frame implements Accessibility return a valid accessible + * If not return NS_ERROR_NOT_IMPLEMENTED. + * Note: Accessible must be refcountable. Do not implement directly on your frame + * Use a mediatior of some kind. + */ +#ifdef ACCESSIBILITY + virtual mozilla::a11y::AccType AccessibleType() = 0; +#endif + + /** + * Get the frame whose style context should be the parent of this + * frame's style context (i.e., provide the parent style context). + * This frame must either be an ancestor of this frame or a child. If + * this returns a child frame, then the child frame must be sure to + * return a grandparent or higher! Furthermore, if a child frame is + * returned it must have the same GetContent() as this frame. + * + * @param aProviderFrame (out) the frame associated with the returned value + * or nullptr if the style context is for display:contents content. + * @return The style context that should be the parent of this frame's + * style context. Null is permitted, and means that this frame's + * style context should be the root of the style context tree. + */ + virtual nsStyleContext* GetParentStyleContext(nsIFrame** aProviderFrame) const = 0; + + /** + * Determines whether a frame is visible for painting; + * taking into account whether it is painting a selection or printing. + */ + bool IsVisibleForPainting(nsDisplayListBuilder* aBuilder); + /** + * Determines whether a frame is visible for painting or collapsed; + * taking into account whether it is painting a selection or printing, + */ + bool IsVisibleOrCollapsedForPainting(nsDisplayListBuilder* aBuilder); + /** + * As above, but slower because we have to recompute some stuff that + * aBuilder already has. + */ + bool IsVisibleForPainting(); + /** + * Check whether this frame is visible in the current selection. Returns + * true if there is no current selection. + */ + bool IsVisibleInSelection(nsDisplayListBuilder* aBuilder); + + /** + * Overridable function to determine whether this frame should be considered + * "in" the given non-null aSelection for visibility purposes. + */ + virtual bool IsVisibleInSelection(nsISelection* aSelection); + + /** + * Determines whether this frame is a pseudo stacking context, looking + * only as style --- i.e., assuming that it's in-flow and not a replaced + * element and not an SVG element. + * XXX maybe check IsTransformed()? + */ + bool IsPseudoStackingContextFromStyle(); + + virtual bool HonorPrintBackgroundSettings() { return true; } + + /** + * Determine whether the frame is logically empty, which is roughly + * whether the layout would be the same whether or not the frame is + * present. Placeholder frames should return true. Block frames + * should be considered empty whenever margins collapse through them, + * even though those margins are relevant. Text frames containing + * only whitespace that does not contribute to the height of the line + * should return true. + */ + virtual bool IsEmpty() = 0; + /** + * Return the same as IsEmpty(). This may only be called after the frame + * has been reflowed and before any further style or content changes. + */ + virtual bool CachedIsEmpty(); + /** + * Determine whether the frame is logically empty, assuming that all + * its children are empty. + */ + virtual bool IsSelfEmpty() = 0; + + /** + * IsGeneratedContentFrame returns whether a frame corresponds to + * generated content + * + * @return whether the frame correspods to generated content + */ + bool IsGeneratedContentFrame() const { + return (mState & NS_FRAME_GENERATED_CONTENT) != 0; + } + + /** + * IsPseudoFrame returns whether a frame is a pseudo frame (eg an + * anonymous table-row frame created for a CSS table-cell without an + * enclosing table-row. + * + * @param aParentContent the content node corresponding to the parent frame + * @return whether the frame is a pseudo frame + */ + bool IsPseudoFrame(const nsIContent* aParentContent) { + return mContent == aParentContent; + } + + FrameProperties Properties() const { + return FrameProperties(PresContext()->PropertyTable(), this); + } + + /** + * Return true if and only if this frame obeys visibility:hidden. + * if it does not, then nsContainerFrame will hide its view even though + * this means children can't be made visible again. + */ + virtual bool SupportsVisibilityHidden() { return true; } + + /** + * Returns the clip rect set via the 'clip' property, if the 'clip' property + * applies to this frame; otherwise returns Nothing(). The 'clip' property + * applies to HTML frames if they are absolutely positioned. The 'clip' + * property applies to SVG frames regardless of the value of the 'position' + * property. + * + * The coordinates of the returned rectangle are relative to this frame's + * origin. + */ + Maybe<nsRect> GetClipPropClipRect(const nsStyleDisplay* aDisp, + const nsStyleEffects* aEffects, + const nsSize& aSize) const; + + /** + * Check if this frame is focusable and in the current tab order. + * Tabbable is indicated by a nonnegative tabindex & is a subset of focusable. + * For example, only the selected radio button in a group is in the + * tab order, unless the radio group has no selection in which case + * all of the visible, non-disabled radio buttons in the group are + * in the tab order. On the other hand, all of the visible, non-disabled + * radio buttons are always focusable via clicking or script. + * Also, depending on the pref accessibility.tabfocus some widgets may be + * focusable but removed from the tab order. This is the default on + * Mac OS X, where fewer items are focusable. + * @param [in, optional] aTabIndex the computed tab index + * < 0 if not tabbable + * == 0 if in normal tab order + * > 0 can be tabbed to in the order specified by this value + * @param [in, optional] aWithMouse, is this focus query for mouse clicking + * @return whether the frame is focusable via mouse, kbd or script. + */ + virtual bool IsFocusable(int32_t *aTabIndex = nullptr, bool aWithMouse = false); + + // BOX LAYOUT METHODS + // These methods have been migrated from nsIBox and are in the process of + // being refactored. DO NOT USE OUTSIDE OF XUL. + bool IsXULBoxFrame() const + { + return IsFrameOfType(nsIFrame::eXULBox); + } + + enum Halignment { + hAlign_Left, + hAlign_Right, + hAlign_Center + }; + + enum Valignment { + vAlign_Top, + vAlign_Middle, + vAlign_BaseLine, + vAlign_Bottom + }; + + /** + * This calculates the minimum size required for a box based on its state + * @param[in] aBoxLayoutState The desired state to calculate for + * @return The minimum size + */ + virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) = 0; + + /** + * This calculates the preferred size of a box based on its state + * @param[in] aBoxLayoutState The desired state to calculate for + * @return The preferred size + */ + virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) = 0; + + /** + * This calculates the maximum size for a box based on its state + * @param[in] aBoxLayoutState The desired state to calculate for + * @return The maximum size + */ + virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) = 0; + + /** + * This returns the minimum size for the scroll area if this frame is + * being scrolled. Usually it's (0,0). + */ + virtual nsSize GetXULMinSizeForScrollArea(nsBoxLayoutState& aBoxLayoutState) = 0; + + // Implemented in nsBox, used in nsBoxFrame + uint32_t GetXULOrdinal(); + + virtual nscoord GetXULFlex() = 0; + virtual nscoord GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) = 0; + virtual bool IsXULCollapsed() = 0; + // This does not alter the overflow area. If the caller is changing + // the box size, the caller is responsible for updating the overflow + // area. It's enough to just call XULLayout or SyncLayout on the + // box. You can pass true to aRemoveOverflowArea as a + // convenience. + virtual void SetXULBounds(nsBoxLayoutState& aBoxLayoutState, const nsRect& aRect, + bool aRemoveOverflowAreas = false) = 0; + nsresult XULLayout(nsBoxLayoutState& aBoxLayoutState); + // Box methods. Note that these do NOT just get the CSS border, padding, + // etc. They also talk to nsITheme. + virtual nsresult GetXULBorderAndPadding(nsMargin& aBorderAndPadding); + virtual nsresult GetXULBorder(nsMargin& aBorder)=0; + virtual nsresult GetXULPadding(nsMargin& aBorderAndPadding)=0; + virtual nsresult GetXULMargin(nsMargin& aMargin)=0; + virtual void SetXULLayoutManager(nsBoxLayout* aLayout) { } + virtual nsBoxLayout* GetXULLayoutManager() { return nullptr; } + nsresult GetXULClientRect(nsRect& aContentRect); + + virtual uint32_t GetXULLayoutFlags() + { return 0; } + + // For nsSprocketLayout + virtual Valignment GetXULVAlign() const = 0; + virtual Halignment GetXULHAlign() const = 0; + + bool IsXULHorizontal() const { return (mState & NS_STATE_IS_HORIZONTAL) != 0; } + bool IsXULNormalDirection() const { return (mState & NS_STATE_IS_DIRECTION_NORMAL) != 0; } + + nsresult XULRedraw(nsBoxLayoutState& aState); + virtual nsresult XULRelayoutChildAtOrdinal(nsIFrame* aChild)=0; + +#ifdef DEBUG_LAYOUT + virtual nsresult SetXULDebug(nsBoxLayoutState& aState, bool aDebug)=0; + virtual nsresult GetXULDebug(bool& aDebug)=0; + + virtual nsresult XULDumpBox(FILE* out)=0; +#endif + + static bool AddXULPrefSize(nsIFrame* aBox, nsSize& aSize, bool& aWidth, bool& aHeightSet); + static bool AddXULMinSize(nsBoxLayoutState& aState, nsIFrame* aBox, + nsSize& aSize, bool& aWidth, bool& aHeightSet); + static bool AddXULMaxSize(nsIFrame* aBox, nsSize& aSize, bool& aWidth, bool& aHeightSet); + static bool AddXULFlex(nsIFrame* aBox, nscoord& aFlex); + + // END OF BOX LAYOUT METHODS + // The above methods have been migrated from nsIBox and are in the process of + // being refactored. DO NOT USE OUTSIDE OF XUL. + + /** + * @return true if this text frame ends with a newline character. It + * should return false if this is not a text frame. + */ + virtual bool HasSignificantTerminalNewline() const; + + struct CaretPosition { + CaretPosition(); + ~CaretPosition(); + + nsCOMPtr<nsIContent> mResultContent; + int32_t mContentOffset; + }; + + /** + * gets the first or last possible caret position within the frame + * + * @param [in] aStart + * true for getting the first possible caret position + * false for getting the last possible caret position + * @return The caret position in a CaretPosition. + * the returned value is a 'best effort' in case errors + * are encountered rummaging through the frame. + */ + CaretPosition GetExtremeCaretPosition(bool aStart); + + /** + * Get a line iterator for this frame, if supported. + * + * @return nullptr if no line iterator is supported. + * @note dispose the line iterator using nsILineIterator::DisposeLineIterator + */ + virtual nsILineIterator* GetLineIterator() = 0; + + /** + * If this frame is a next-in-flow, and its prev-in-flow has something on its + * overflow list, pull those frames into the child list of this one. + */ + virtual void PullOverflowsFromPrevInFlow() {} + + /** + * Clear the list of child PresShells generated during the last paint + * so that we can begin generating a new one. + */ + void ClearPresShellsFromLastPaint() { + PaintedPresShellList()->Clear(); + } + + /** + * Flag a child PresShell as painted so that it will get its paint count + * incremented during empty transactions. + */ + void AddPaintedPresShell(nsIPresShell* shell) { + PaintedPresShellList()->AppendElement(do_GetWeakReference(shell)); + } + + /** + * Increment the paint count of all child PresShells that were painted during + * the last repaint. + */ + void UpdatePaintCountForPaintedPresShells() { + for (nsWeakPtr& item : *PaintedPresShellList()) { + nsCOMPtr<nsIPresShell> shell = do_QueryReferent(item); + if (shell) { + shell->IncrementPaintCount(); + } + } + } + + /** + * @return true if we painted @aShell during the last repaint. + */ + bool DidPaintPresShell(nsIPresShell* aShell) + { + for (nsWeakPtr& item : *PaintedPresShellList()) { + nsCOMPtr<nsIPresShell> shell = do_QueryReferent(item); + if (shell == aShell) { + return true; + } + } + return false; + } + + /** + * Accessors for the absolute containing block. + */ + bool IsAbsoluteContainer() const { return !!(mState & NS_FRAME_HAS_ABSPOS_CHILDREN); } + bool HasAbsolutelyPositionedChildren() const; + nsAbsoluteContainingBlock* GetAbsoluteContainingBlock() const; + void MarkAsAbsoluteContainingBlock(); + void MarkAsNotAbsoluteContainingBlock(); + // Child frame types override this function to select their own child list name + virtual mozilla::layout::FrameChildListID GetAbsoluteListID() const { return kAbsoluteList; } + + // Checks if we (or any of our descendents) have NS_FRAME_PAINTED_THEBES set, and + // clears this bit if so. + bool CheckAndClearPaintedState(); + + // CSS visibility just doesn't cut it because it doesn't inherit through + // documents. Also if this frame is in a hidden card of a deck then it isn't + // visible either and that isn't expressed using CSS visibility. Also if it + // is in a hidden view (there are a few cases left and they are hopefully + // going away soon). + // If the VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY flag is passed then we + // ignore the chrome/content boundary, otherwise we stop looking when we + // reach it. + enum { + VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY = 0x01 + }; + bool IsVisibleConsideringAncestors(uint32_t aFlags = 0) const; + + struct FrameWithDistance + { + nsIFrame* mFrame; + nscoord mXDistance; + nscoord mYDistance; + }; + + /** + * Finds a frame that is closer to a specified point than a current + * distance. Distance is measured as for text selection -- a closer x + * distance beats a closer y distance. + * + * Normally, this function will only check the distance between this + * frame's rectangle and the specified point. SVGTextFrame overrides + * this so that it can manage all of its descendant frames and take + * into account any SVG text layout. + * + * If aPoint is closer to this frame's rectangle than aCurrentBestFrame + * indicates, then aCurrentBestFrame is updated with the distance between + * aPoint and this frame's rectangle, and with a pointer to this frame. + * If aPoint is not closer, then aCurrentBestFrame is left unchanged. + * + * @param aPoint The point to check for its distance to this frame. + * @param aCurrentBestFrame Pointer to a struct that will be updated with + * a pointer to this frame and its distance to aPoint, if this frame + * is indeed closer than the current distance in aCurrentBestFrame. + */ + virtual void FindCloserFrameForSelection(nsPoint aPoint, + FrameWithDistance* aCurrentBestFrame); + + /** + * Is this a flex item? (i.e. a non-abs-pos child of a flex container) + */ + inline bool IsFlexItem() const; + /** + * Is this a flex or grid item? (i.e. a non-abs-pos child of a flex/grid container) + */ + inline bool IsFlexOrGridItem() const; + inline bool IsFlexOrGridContainer() const; + + /** + * @return true if this frame is used as a table caption. + */ + inline bool IsTableCaption() const; + + inline bool IsBlockInside() const; + inline bool IsBlockOutside() const; + inline bool IsInlineOutside() const; + inline mozilla::StyleDisplay GetDisplay() const; + inline bool IsFloating() const; + inline bool IsAbsPosContainingBlock() const; + inline bool IsFixedPosContainingBlock() const; + inline bool IsRelativelyPositioned() const; + inline bool IsAbsolutelyPositioned() const; + + /** + * Returns the vertical-align value to be used for layout, if it is one + * of the enumerated values. If this is an SVG text frame, it returns a value + * that corresponds to the value of dominant-baseline. If the + * vertical-align property has length or percentage value, this returns + * eInvalidVerticalAlign. + */ + uint8_t VerticalAlignEnum() const; + enum { eInvalidVerticalAlign = 0xFF }; + + bool IsSVGText() const { return mState & NS_FRAME_IS_SVG_TEXT; } + + void CreateOwnLayerIfNeeded(nsDisplayListBuilder* aBuilder, nsDisplayList* aList); + + /** + * Adds the NS_FRAME_IN_POPUP state bit to aFrame, and + * all descendant frames (including cross-doc ones). + */ + static void AddInPopupStateBitToDescendants(nsIFrame* aFrame); + /** + * Removes the NS_FRAME_IN_POPUP state bit from aFrame and + * all descendant frames (including cross-doc ones), unless + * the frame is a popup itself. + */ + static void RemoveInPopupStateBitFromDescendants(nsIFrame* aFrame); + + /** + * Sorts the given nsFrameList, so that for every two adjacent frames in the + * list, the former is less than or equal to the latter, according to the + * templated IsLessThanOrEqual method. + * + * Note: this method uses a stable merge-sort algorithm. + */ + template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> + static void SortFrameList(nsFrameList& aFrameList); + + /** + * Returns true if the given frame list is already sorted, according to the + * templated IsLessThanOrEqual function. + */ + template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> + static bool IsFrameListSorted(nsFrameList& aFrameList); + + /** + * Return true if aFrame is in an {ib} split and is NOT one of the + * continuations of the first inline in it. + */ + bool FrameIsNonFirstInIBSplit() const { + return (GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) && + FirstContinuation()->Properties().Get(nsIFrame::IBSplitPrevSibling()); + } + + /** + * Return true if aFrame is in an {ib} split and is NOT one of the + * continuations of the last inline in it. + */ + bool FrameIsNonLastInIBSplit() const { + return (GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) && + FirstContinuation()->Properties().Get(nsIFrame::IBSplitSibling()); + } + + /** + * Return whether this is a frame whose width is used when computing + * the font size inflation of its descendants. + */ + bool IsContainerForFontSizeInflation() const { + return GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER; + } + + /** + * Return whether this frame keeps track of overflow areas. (Frames for + * non-display SVG elements -- e.g. <clipPath> -- do not maintain overflow + * areas, because they're never painted.) + */ + bool FrameMaintainsOverflow() const { + return !HasAllStateBits(NS_FRAME_SVG_LAYOUT | NS_FRAME_IS_NONDISPLAY); + } + + /** + * Returns the content node within the anonymous content that this frame + * generated and which corresponds to the specified pseudo-element type, + * or nullptr if there is no such anonymous content. + */ + virtual mozilla::dom::Element* + GetPseudoElement(mozilla::CSSPseudoElementType aType); + + bool BackfaceIsHidden() const { + return StyleDisplay()->BackfaceIsHidden(); + } + + /** + * Returns true if the frame is scrolled out of view. + */ + bool IsScrolledOutOfView(); + + /** + * If this returns true, the frame it's called on should get the + * NS_FRAME_HAS_DIRTY_CHILDREN bit set on it by the caller; either directly + * if it's already in reflow, or via calling FrameNeedsReflow() to schedule a + * reflow. + */ + virtual bool RenumberFrameAndDescendants(int32_t* aOrdinal, + int32_t aDepth, + int32_t aIncrement, + bool aForCounting) { return false; } + + /** + * Helper function - computes the content-box inline size for aCoord. + */ + nscoord ComputeISizeValue(nsRenderingContext* aRenderingContext, + nscoord aContainingBlockISize, + nscoord aContentEdgeToBoxSizing, + nscoord aBoxSizingToMarginEdge, + const nsStyleCoord& aCoord, + ComputeSizeFlags aFlags = eDefault); +protected: + // Members + nsRect mRect; + nsIContent* mContent; + nsStyleContext* mStyleContext; +private: + nsContainerFrame* mParent; + nsIFrame* mNextSibling; // doubly-linked list of frames + nsIFrame* mPrevSibling; // Do not touch outside SetNextSibling! + + void MarkAbsoluteFramesForDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect); + + static void DestroyPaintedPresShellList(nsTArray<nsWeakPtr>* list) { + list->Clear(); + delete list; + } + + // Stores weak references to all the PresShells that were painted during + // the last paint event so that we can increment their paint count during + // empty transactions + NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(PaintedPresShellsProperty, + nsTArray<nsWeakPtr>, + DestroyPaintedPresShellList) + + nsTArray<nsWeakPtr>* PaintedPresShellList() { + nsTArray<nsWeakPtr>* list = Properties().Get(PaintedPresShellsProperty()); + + if (!list) { + list = new nsTArray<nsWeakPtr>(); + Properties().Set(PaintedPresShellsProperty(), list); + } + + return list; + } + +protected: + void MarkInReflow() { +#ifdef DEBUG_dbaron_off + // bug 81268 + NS_ASSERTION(!(mState & NS_FRAME_IN_REFLOW), "frame is already in reflow"); +#endif + mState |= NS_FRAME_IN_REFLOW; + } + + nsFrameState mState; + + // When there is an overflow area only slightly larger than mRect, + // we store a set of four 1-byte deltas from the edges of mRect + // rather than allocating a whole separate rectangle property. + // Note that these are unsigned values, all measured "outwards" + // from the edges of mRect, so /mLeft/ and /mTop/ are reversed from + // our normal coordinate system. + // If mOverflow.mType == NS_FRAME_OVERFLOW_LARGE, then the + // delta values are not meaningful and the overflow area is stored + // as a separate rect property. + struct VisualDeltas { + uint8_t mLeft; + uint8_t mTop; + uint8_t mRight; + uint8_t mBottom; + bool operator==(const VisualDeltas& aOther) const + { + return mLeft == aOther.mLeft && mTop == aOther.mTop && + mRight == aOther.mRight && mBottom == aOther.mBottom; + } + bool operator!=(const VisualDeltas& aOther) const + { + return !(*this == aOther); + } + }; + union { + uint32_t mType; + VisualDeltas mVisualDeltas; + } mOverflow; + + // Helpers + /** + * Can we stop inside this frame when we're skipping non-rendered whitespace? + * @param aForward [in] Are we moving forward (or backward) in content order. + * @param aOffset [in/out] At what offset into the frame to start looking. + * on output - what offset was reached (whether or not we found a place to stop). + * @return STOP: An appropriate offset was found within this frame, + * and is given by aOffset. + * CONTINUE: Not found within this frame, need to try the next frame. + * see enum FrameSearchResult for more details. + */ + virtual FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) = 0; + + /** + * Search the frame for the next character + * @param aForward [in] Are we moving forward (or backward) in content order. + * @param aOffset [in/out] At what offset into the frame to start looking. + * on output - what offset was reached (whether or not we found a place to stop). + * @param aRespectClusters [in] Whether to restrict result to valid cursor locations + * (between grapheme clusters) - default TRUE maintains "normal" behavior, + * FALSE is used for selection by "code unit" (instead of "character") + * @return STOP: An appropriate offset was found within this frame, + * and is given by aOffset. + * CONTINUE: Not found within this frame, need to try the next frame. + * see enum FrameSearchResult for more details. + */ + virtual FrameSearchResult PeekOffsetCharacter(bool aForward, int32_t* aOffset, + bool aRespectClusters = true) = 0; + + /** + * Search the frame for the next word boundary + * @param aForward [in] Are we moving forward (or backward) in content order. + * @param aWordSelectEatSpace [in] true: look for non-whitespace following + * whitespace (in the direction of movement). + * false: look for whitespace following non-whitespace (in the + * direction of movement). + * @param aIsKeyboardSelect [in] Was the action initiated by a keyboard operation? + * If true, punctuation immediately following a word is considered part + * of that word. Otherwise, a sequence of punctuation is always considered + * as a word on its own. + * @param aOffset [in/out] At what offset into the frame to start looking. + * on output - what offset was reached (whether or not we found a place to stop). + * @param aState [in/out] the state that is carried from frame to frame + * @return true: An appropriate offset was found within this frame, + * and is given by aOffset. + * false: Not found within this frame, need to try the next frame. + */ + struct PeekWordState { + // true when we're still at the start of the search, i.e., we can't return + // this point as a valid offset! + bool mAtStart; + // true when we've encountered at least one character of the pre-boundary type + // (whitespace if aWordSelectEatSpace is true, non-whitespace otherwise) + bool mSawBeforeType; + // true when the last character encountered was punctuation + bool mLastCharWasPunctuation; + // true when the last character encountered was whitespace + bool mLastCharWasWhitespace; + // true when we've seen non-punctuation since the last whitespace + bool mSeenNonPunctuationSinceWhitespace; + // text that's *before* the current frame when aForward is true, *after* + // the current frame when aForward is false. Only includes the text + // on the current line. + nsAutoString mContext; + + PeekWordState() : mAtStart(true), mSawBeforeType(false), + mLastCharWasPunctuation(false), mLastCharWasWhitespace(false), + mSeenNonPunctuationSinceWhitespace(false) {} + void SetSawBeforeType() { mSawBeforeType = true; } + void Update(bool aAfterPunctuation, bool aAfterWhitespace) { + mLastCharWasPunctuation = aAfterPunctuation; + mLastCharWasWhitespace = aAfterWhitespace; + if (aAfterWhitespace) { + mSeenNonPunctuationSinceWhitespace = false; + } else if (!aAfterPunctuation) { + mSeenNonPunctuationSinceWhitespace = true; + } + mAtStart = false; + } + }; + virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect, + int32_t* aOffset, PeekWordState* aState) = 0; + + /** + * Search for the first paragraph boundary before or after the given position + * @param aPos See description in nsFrameSelection.h. The following fields are + * used by this method: + * Input: mDirection + * Output: mResultContent, mContentOffset + */ + nsresult PeekOffsetParagraph(nsPeekOffsetStruct *aPos); + +private: + nsOverflowAreas* GetOverflowAreasProperty(); + nsRect GetVisualOverflowFromDeltas() const { + MOZ_ASSERT(mOverflow.mType != NS_FRAME_OVERFLOW_LARGE, + "should not be called when overflow is in a property"); + // Calculate the rect using deltas from the frame's border rect. + // Note that the mOverflow.mDeltas fields are unsigned, but we will often + // need to return negative values for the left and top, so take care + // to cast away the unsigned-ness. + return nsRect(-(int32_t)mOverflow.mVisualDeltas.mLeft, + -(int32_t)mOverflow.mVisualDeltas.mTop, + mRect.width + mOverflow.mVisualDeltas.mRight + + mOverflow.mVisualDeltas.mLeft, + mRect.height + mOverflow.mVisualDeltas.mBottom + + mOverflow.mVisualDeltas.mTop); + } + /** + * Returns true if any overflow changed. + */ + bool SetOverflowAreas(const nsOverflowAreas& aOverflowAreas); + + // Helper-functions for SortFrameList(): + template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> + static nsIFrame* SortedMerge(nsIFrame *aLeft, nsIFrame *aRight); + + template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> + static nsIFrame* MergeSort(nsIFrame *aSource); + + bool HasOpacityInternal(float aThreshold) const; + +#ifdef DEBUG_FRAME_DUMP +public: + static void IndentBy(FILE* out, int32_t aIndent) { + while (--aIndent >= 0) fputs(" ", out); + } + void ListTag(FILE* out) const { + ListTag(out, this); + } + static void ListTag(FILE* out, const nsIFrame* aFrame) { + nsAutoCString t; + ListTag(t, aFrame); + fputs(t.get(), out); + } + static void ListTag(FILE* out, const nsFrameList& aFrameList) { + for (nsIFrame* frame : aFrameList) { + ListTag(out, frame); + } + } + void ListTag(nsACString& aTo) const; + nsAutoCString ListTag() const { + nsAutoCString tag; + ListTag(tag); + return tag; + } + static void ListTag(nsACString& aTo, const nsIFrame* aFrame); + void ListGeneric(nsACString& aTo, const char* aPrefix = "", uint32_t aFlags = 0) const; + enum { + TRAVERSE_SUBDOCUMENT_FRAMES = 0x01 + }; + virtual void List(FILE* out = stderr, const char* aPrefix = "", uint32_t aFlags = 0) const; + /** + * lists the frames beginning from the root frame + * - calls root frame's List(...) + */ + static void RootFrameList(nsPresContext* aPresContext, + FILE* out = stderr, const char* aPrefix = ""); + virtual void DumpFrameTree() const; + void DumpFrameTreeLimited() const; + + virtual nsresult GetFrameName(nsAString& aResult) const = 0; +#endif + +#ifdef DEBUG +public: + virtual nsFrameState GetDebugStateBits() const = 0; + virtual nsresult DumpRegressionData(nsPresContext* aPresContext, + FILE* out, int32_t aIndent) = 0; +#endif +}; + +//---------------------------------------------------------------------- + +/** + * nsWeakFrame can be used to keep a reference to a nsIFrame in a safe way. + * Whenever an nsIFrame object is deleted, the nsWeakFrames pointing + * to it will be cleared. + * + * Create nsWeakFrame object when it is sure that nsIFrame object + * is alive and after some operations which may destroy the nsIFrame + * (for example any DOM modifications) use IsAlive() or GetFrame() methods to + * check whether it is safe to continue to use the nsIFrame object. + * + * @note The usage of this class should be kept to a minimum. + */ + +class nsWeakFrame { +public: + nsWeakFrame() : mPrev(nullptr), mFrame(nullptr) { } + + nsWeakFrame(const nsWeakFrame& aOther) : mPrev(nullptr), mFrame(nullptr) + { + Init(aOther.GetFrame()); + } + + MOZ_IMPLICIT nsWeakFrame(nsIFrame* aFrame) : mPrev(nullptr), mFrame(nullptr) + { + Init(aFrame); + } + + nsWeakFrame& operator=(nsWeakFrame& aOther) { + Init(aOther.GetFrame()); + return *this; + } + + nsWeakFrame& operator=(nsIFrame* aFrame) { + Init(aFrame); + return *this; + } + + nsIFrame* operator->() + { + return mFrame; + } + + operator nsIFrame*() + { + return mFrame; + } + + void Clear(nsIPresShell* aShell) { + if (aShell) { + aShell->RemoveWeakFrame(this); + } + mFrame = nullptr; + mPrev = nullptr; + } + + bool IsAlive() { return !!mFrame; } + + nsIFrame* GetFrame() const { return mFrame; } + + nsWeakFrame* GetPreviousWeakFrame() { return mPrev; } + + void SetPreviousWeakFrame(nsWeakFrame* aPrev) { mPrev = aPrev; } + + ~nsWeakFrame() + { + Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr); + } +private: + void Init(nsIFrame* aFrame); + + nsWeakFrame* mPrev; + nsIFrame* mFrame; +}; + +inline bool +nsFrameList::ContinueRemoveFrame(nsIFrame* aFrame) +{ + MOZ_ASSERT(!aFrame->GetPrevSibling() || !aFrame->GetNextSibling(), + "Forgot to call StartRemoveFrame?"); + if (aFrame == mLastChild) { + MOZ_ASSERT(!aFrame->GetNextSibling(), "broken frame list"); + nsIFrame* prevSibling = aFrame->GetPrevSibling(); + if (!prevSibling) { + MOZ_ASSERT(aFrame == mFirstChild, "broken frame list"); + mFirstChild = mLastChild = nullptr; + return true; + } + MOZ_ASSERT(prevSibling->GetNextSibling() == aFrame, "Broken frame linkage"); + prevSibling->SetNextSibling(nullptr); + mLastChild = prevSibling; + return true; + } + if (aFrame == mFirstChild) { + MOZ_ASSERT(!aFrame->GetPrevSibling(), "broken frame list"); + mFirstChild = aFrame->GetNextSibling(); + aFrame->SetNextSibling(nullptr); + MOZ_ASSERT(mFirstChild, "broken frame list"); + return true; + } + return false; +} + +inline bool +nsFrameList::StartRemoveFrame(nsIFrame* aFrame) +{ + if (aFrame->GetPrevSibling() && aFrame->GetNextSibling()) { + UnhookFrameFromSiblings(aFrame); + return true; + } + return ContinueRemoveFrame(aFrame); +} + +inline void +nsFrameList::Enumerator::Next() +{ + NS_ASSERTION(!AtEnd(), "Should have checked AtEnd()!"); + mFrame = mFrame->GetNextSibling(); +} + +inline +nsFrameList::FrameLinkEnumerator:: +FrameLinkEnumerator(const nsFrameList& aList, nsIFrame* aPrevFrame) + : Enumerator(aList) +{ + mPrev = aPrevFrame; + mFrame = aPrevFrame ? aPrevFrame->GetNextSibling() : aList.FirstChild(); +} + +inline void +nsFrameList::FrameLinkEnumerator::Next() +{ + mPrev = mFrame; + Enumerator::Next(); +} + +// Operators of nsFrameList::Iterator +// --------------------------------------------------- + +inline nsFrameList::Iterator& +nsFrameList::Iterator::operator++() +{ + mCurrent = mCurrent->GetNextSibling(); + return *this; +} + +inline nsFrameList::Iterator& +nsFrameList::Iterator::operator--() +{ + if (!mCurrent) { + mCurrent = mList.LastChild(); + } else { + mCurrent = mCurrent->GetPrevSibling(); + } + return *this; +} + +// Helper-functions for nsIFrame::SortFrameList() +// --------------------------------------------------- + +template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> +/* static */ nsIFrame* +nsIFrame::SortedMerge(nsIFrame *aLeft, nsIFrame *aRight) +{ + NS_PRECONDITION(aLeft && aRight, "SortedMerge must have non-empty lists"); + + nsIFrame *result; + // Unroll first iteration to avoid null-check 'result' inside the loop. + if (IsLessThanOrEqual(aLeft, aRight)) { + result = aLeft; + aLeft = aLeft->GetNextSibling(); + if (!aLeft) { + result->SetNextSibling(aRight); + return result; + } + } + else { + result = aRight; + aRight = aRight->GetNextSibling(); + if (!aRight) { + result->SetNextSibling(aLeft); + return result; + } + } + + nsIFrame *last = result; + for (;;) { + if (IsLessThanOrEqual(aLeft, aRight)) { + last->SetNextSibling(aLeft); + last = aLeft; + aLeft = aLeft->GetNextSibling(); + if (!aLeft) { + last->SetNextSibling(aRight); + return result; + } + } + else { + last->SetNextSibling(aRight); + last = aRight; + aRight = aRight->GetNextSibling(); + if (!aRight) { + last->SetNextSibling(aLeft); + return result; + } + } + } +} + +template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> +/* static */ nsIFrame* +nsIFrame::MergeSort(nsIFrame *aSource) +{ + NS_PRECONDITION(aSource, "MergeSort null arg"); + + nsIFrame *sorted[32] = { nullptr }; + nsIFrame **fill = &sorted[0]; + nsIFrame **left; + nsIFrame *rest = aSource; + + do { + nsIFrame *current = rest; + rest = rest->GetNextSibling(); + current->SetNextSibling(nullptr); + + // Merge it with sorted[0] if present; then merge the result with sorted[1] etc. + // sorted[0] is a list of length 1 (or nullptr). + // sorted[1] is a list of length 2 (or nullptr). + // sorted[2] is a list of length 4 (or nullptr). etc. + for (left = &sorted[0]; left != fill && *left; ++left) { + current = SortedMerge<IsLessThanOrEqual>(*left, current); + *left = nullptr; + } + + // Fill the empty slot that we couldn't merge with the last result. + *left = current; + + if (left == fill) + ++fill; + } while (rest); + + // Collect and merge the results. + nsIFrame *result = nullptr; + for (left = &sorted[0]; left != fill; ++left) { + if (*left) { + result = result ? SortedMerge<IsLessThanOrEqual>(*left, result) : *left; + } + } + return result; +} + +template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> +/* static */ void +nsIFrame::SortFrameList(nsFrameList& aFrameList) +{ + nsIFrame* head = MergeSort<IsLessThanOrEqual>(aFrameList.FirstChild()); + aFrameList = nsFrameList(head, nsLayoutUtils::GetLastSibling(head)); + MOZ_ASSERT(IsFrameListSorted<IsLessThanOrEqual>(aFrameList), + "After we sort a frame list, it should be in sorted order..."); +} + +template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)> +/* static */ bool +nsIFrame::IsFrameListSorted(nsFrameList& aFrameList) +{ + if (aFrameList.IsEmpty()) { + // empty lists are trivially sorted. + return true; + } + + // We'll walk through the list with two iterators, one trailing behind the + // other. The list is sorted IFF trailingIter <= iter, across the whole list. + nsFrameList::Enumerator trailingIter(aFrameList); + nsFrameList::Enumerator iter(aFrameList); + iter.Next(); // Skip |iter| past first frame. (List is nonempty, so we can.) + + // Now, advance the iterators in parallel, comparing each adjacent pair. + while (!iter.AtEnd()) { + MOZ_ASSERT(!trailingIter.AtEnd(), "trailing iter shouldn't finish first"); + if (!IsLessThanOrEqual(trailingIter.get(), iter.get())) { + return false; + } + trailingIter.Next(); + iter.Next(); + } + + // We made it to the end without returning early, so the list is sorted. + return true; +} + +#endif /* nsIFrame_h___ */ |