diff options
Diffstat (limited to 'layout/mathml/nsMathMLContainerFrame.h')
| -rw-r--r-- | layout/mathml/nsMathMLContainerFrame.h | 565 |
1 files changed, 565 insertions, 0 deletions
diff --git a/layout/mathml/nsMathMLContainerFrame.h b/layout/mathml/nsMathMLContainerFrame.h new file mode 100644 index 000000000..94ccf70d2 --- /dev/null +++ b/layout/mathml/nsMathMLContainerFrame.h @@ -0,0 +1,565 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef nsMathMLContainerFrame_h___ +#define nsMathMLContainerFrame_h___ + +#include "mozilla/Attributes.h" +#include "nsContainerFrame.h" +#include "nsBlockFrame.h" +#include "nsInlineFrame.h" +#include "nsMathMLOperators.h" +#include "nsMathMLFrame.h" +#include "mozilla/Likely.h" + +/* + * Base class for MathML container frames. It acts like an inferred + * mrow. By default, this frame uses its Reflow() method to lay its + * children horizontally and ensure that their baselines are aligned. + * The Reflow() method relies upon Place() to position children. + * By overloading Place() in derived classes, it is therefore possible + * to position children in various customized ways. + */ + +// Options for the preferred size at which to stretch our stretchy children +#define STRETCH_CONSIDER_ACTUAL_SIZE 0x00000001 // just use our current size +#define STRETCH_CONSIDER_EMBELLISHMENTS 0x00000002 // size calculations include embellishments + +class nsMathMLContainerFrame : public nsContainerFrame, + public nsMathMLFrame { + friend class nsMathMLmfencedFrame; +public: + explicit nsMathMLContainerFrame(nsStyleContext* aContext) + : nsContainerFrame(aContext) + , mIntrinsicWidth(NS_INTRINSIC_WIDTH_UNKNOWN) + , mBlockStartAscent(0) + {} + + NS_DECL_QUERYFRAME_TARGET(nsMathMLContainerFrame) + NS_DECL_QUERYFRAME + NS_DECL_ABSTRACT_FRAME(nsMathMLContainerFrame) + + // -------------------------------------------------------------------------- + // Overloaded nsMathMLFrame methods -- see documentation in nsIMathMLFrame.h + + NS_IMETHOD + Stretch(DrawTarget* aDrawTarget, + nsStretchDirection aStretchDirection, + nsBoundingMetrics& aContainerSize, + ReflowOutput& aDesiredStretchSize) override; + + NS_IMETHOD + UpdatePresentationDataFromChildAt(int32_t aFirstIndex, + int32_t aLastIndex, + uint32_t aFlagsValues, + uint32_t aFlagsToUpdate) override + { + PropagatePresentationDataFromChildAt(this, aFirstIndex, aLastIndex, + aFlagsValues, aFlagsToUpdate); + return NS_OK; + } + + // helper to set the "increment script level" flag on the element belonging + // to a child frame given by aChildIndex. + // When this flag is set, the style system will increment the scriptlevel + // for the child element. This is needed for situations where the style system + // cannot itself determine the scriptlevel (mfrac, munder, mover, munderover). + // This should be called during reflow. We set the flag and if it changed, + // we request appropriate restyling and also queue a post-reflow callback + // to ensure that restyle and reflow happens immediately after the current + // reflow. + void + SetIncrementScriptLevel(int32_t aChildIndex, bool aIncrement); + + // -------------------------------------------------------------------------- + // Overloaded nsContainerFrame methods -- see documentation in nsIFrame.h + + virtual bool IsFrameOfType(uint32_t aFlags) const override + { + return !(aFlags & nsIFrame::eLineParticipant) && + nsContainerFrame::IsFrameOfType(aFlags & + ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace)); + } + + virtual void + AppendFrames(ChildListID aListID, + nsFrameList& aFrameList) override; + + virtual void + InsertFrames(ChildListID aListID, + nsIFrame* aPrevFrame, + nsFrameList& aFrameList) override; + + virtual void + RemoveFrame(ChildListID aListID, + nsIFrame* aOldFrame) override; + + /** + * Both GetMinISize and GetPrefISize use the intrinsic width metrics + * returned by GetIntrinsicMetrics, including ink overflow. + */ + virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override; + virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override; + + /** + * Return the intrinsic horizontal metrics of the frame's content area. + */ + virtual void + GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext, + ReflowOutput& aDesiredSize); + + virtual void + Reflow(nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) override; + + virtual void DidReflow(nsPresContext* aPresContext, + const ReflowInput* aReflowInput, + nsDidReflowStatus aStatus) override + + { + mPresentationData.flags &= ~NS_MATHML_STRETCH_DONE; + return nsContainerFrame::DidReflow(aPresContext, aReflowInput, aStatus); + } + + virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsRect& aDirtyRect, + const nsDisplayListSet& aLists) override; + + virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override; + + virtual void MarkIntrinsicISizesDirty() override; + + // Notification when an attribute is changed. The MathML module uses the + // following paradigm: + // + // 1. If the MathML frame class doesn't have any cached automatic data that + // depends on the attribute: we just reflow (e.g., this happens with <msub>, + // <msup>, <mmultiscripts>, etc). This is the default behavior implemented + // by this base class. + // + // 2. If the MathML frame class has cached automatic data that depends on + // the attribute: + // 2a. If the automatic data to update resides only within the descendants, + // we just re-layout them using ReLayoutChildren(this); + // (e.g., this happens with <ms>). + // 2b. If the automatic data to update affects us in some way, we ask our parent + // to re-layout its children using ReLayoutChildren(mParent); + // Therefore, there is an overhead here in that our siblings are re-laid + // too (e.g., this happens with <munder>, <mover>, <munderover>). + virtual nsresult + AttributeChanged(int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType) override; + + // helper function to apply mirroring to a horizontal coordinate, if needed. + nscoord + MirrorIfRTL(nscoord aParentWidth, nscoord aChildWidth, nscoord aChildLeading) + { + return (StyleVisibility()->mDirection ? + aParentWidth - aChildWidth - aChildLeading : aChildLeading); + } + + // -------------------------------------------------------------------------- + // Additional methods + +protected: + /* Place : + * This method is used to measure or position child frames and other + * elements. It may be called any number of times with aPlaceOrigin + * false to measure, and the final call of the Reflow process before + * returning from Reflow() or Stretch() will have aPlaceOrigin true + * to position the elements. + * + * IMPORTANT: This method uses GetReflowAndBoundingMetricsFor() which must + * have been set up with SaveReflowAndBoundingMetricsFor(). + * + * The Place() method will use this information to compute the desired size + * of the frame. + * + * @param aPlaceOrigin [in] + * If aPlaceOrigin is false, compute your desired size using the + * information from GetReflowAndBoundingMetricsFor. However, child + * frames or other elements should not be repositioned. + * + * If aPlaceOrigin is true, reflow is finished. You should position + * all your children, and return your desired size. You should now + * use FinishReflowChild() on your children to complete post-reflow + * operations. + * + * @param aDesiredSize [out] parameter where you should return your desired + * size and your ascent/descent info. Compute your desired size using + * the information from GetReflowAndBoundingMetricsFor, and include + * any space you want for border/padding in the desired size you + * return. + */ + virtual nsresult + Place(DrawTarget* aDrawTarget, + bool aPlaceOrigin, + ReflowOutput& aDesiredSize); + + // MeasureForWidth: + // + // A method used by nsMathMLContainerFrame::GetIntrinsicISize to get the + // width that a particular Place method desires. For most frames, this will + // just call the object's Place method. However <msqrt> and <menclose> use + // nsMathMLContainerFrame::GetIntrinsicISize to measure the child frames as + // if in an <mrow>, and so their frames implement MeasureForWidth to use + // nsMathMLContainerFrame::Place. + virtual nsresult + MeasureForWidth(DrawTarget* aDrawTarget, + ReflowOutput& aDesiredSize); + + + // helper to re-sync the automatic data in our children and notify our parent to + // reflow us when changes (e.g., append/insert/remove) happen in our child list + virtual nsresult + ChildListChanged(int32_t aModType); + + // helper to get the preferred size that a container frame should use to fire + // the stretch on its stretchy child frames. + void + GetPreferredStretchSize(DrawTarget* aDrawTarget, + uint32_t aOptions, + nsStretchDirection aStretchDirection, + nsBoundingMetrics& aPreferredStretchSize); + + // helper used by mstyle, mphantom, mpadded and mrow in their implementation + // of TransmitAutomaticData() to determine whether they are space-like. + nsresult + TransmitAutomaticDataForMrowLikeElement(); + +public: + // error handlers to provide a visual feedback to the user when an error + // (typically invalid markup) was encountered during reflow. + nsresult + ReflowError(DrawTarget* aDrawTarget, ReflowOutput& aDesiredSize); + /* + * Helper to call ReportErrorToConsole for parse errors involving + * attribute/value pairs. + * @param aAttribute The attribute for which the parse error occured. + * @param aValue The value for which the parse error occured. + */ + nsresult + ReportParseError(const char16_t* aAttribute, + const char16_t* aValue); + + /* + * Helper to call ReportErrorToConsole when certain tags + * have more than the expected amount of children. + */ + nsresult + ReportChildCountError(); + + /* + * Helper to call ReportErrorToConsole when certain tags have + * invalid child tags + * @param aChildTag The tag which is forbidden in this context + */ + nsresult + ReportInvalidChildError(nsIAtom* aChildTag); + + /* + * Helper to call ReportToConsole when an error occurs. + * @param aParams see nsContentUtils::ReportToConsole + */ + nsresult + ReportErrorToConsole(const char* aErrorMsgId, + const char16_t** aParams = nullptr, + uint32_t aParamCount = 0); + + // helper method to reflow a child frame. We are inline frames, and we don't + // know our positions until reflow is finished. That's why we ask the + // base method not to worry about our position. + void + ReflowChild(nsIFrame* aKidFrame, + nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus); + +protected: + // helper to add the inter-spacing when <math> is the immediate parent. + // Since we don't (yet) handle the root <math> element ourselves, we need to + // take special care of the inter-frame spacing on elements for which <math> + // is the direct xml parent. This function will be repeatedly called from + // left to right on the childframes of <math>, and by so doing it will + // emulate the spacing that would have been done by a <mrow> container. + // e.g., it fixes <math> <mi>f</mi> <mo>q</mo> <mi>f</mi> <mo>I</mo> </math> + virtual nscoord + FixInterFrameSpacing(ReflowOutput& aDesiredSize); + + // helper method to complete the post-reflow hook and ensure that embellished + // operators don't terminate their Reflow without receiving a Stretch command. + virtual nsresult + FinalizeReflow(DrawTarget* aDrawTarget, ReflowOutput& aDesiredSize); + + // Record metrics of a child frame for recovery through the following method + static void + SaveReflowAndBoundingMetricsFor(nsIFrame* aFrame, + const ReflowOutput& aReflowOutput, + const nsBoundingMetrics& aBoundingMetrics); + + // helper method to facilitate getting the reflow and bounding metrics of a + // child frame. The argument aMathMLFrameType, when non null, will return + // the 'type' of the frame, which is used to determine the inter-frame + // spacing. + // IMPORTANT: This function is only meant to be called in Place() methods as + // the information is available only when set up with the above method + // during Reflow/Stretch() and GetPrefISize(). + static void + GetReflowAndBoundingMetricsFor(nsIFrame* aFrame, + ReflowOutput& aReflowOutput, + nsBoundingMetrics& aBoundingMetrics, + eMathMLFrameType* aMathMLFrameType = nullptr); + + // helper method to clear metrics saved with + // SaveReflowAndBoundingMetricsFor() from all child frames. + void ClearSavedChildMetrics(); + + // helper to let the update of presentation data pass through + // a subtree that may contain non-MathML container frames + static void + PropagatePresentationDataFor(nsIFrame* aFrame, + uint32_t aFlagsValues, + uint32_t aFlagsToUpdate); + +public: + static void + PropagatePresentationDataFromChildAt(nsIFrame* aParentFrame, + int32_t aFirstChildIndex, + int32_t aLastChildIndex, + uint32_t aFlagsValues, + uint32_t aFlagsToUpdate); + + // Sets flags on aFrame and all descendant frames + static void + PropagateFrameFlagFor(nsIFrame* aFrame, + nsFrameState aFlags); + + // helper to let the rebuild of automatic data (presentation data + // and embellishement data) walk through a subtree that may contain + // non-MathML container frames. Note that this method re-builds the + // automatic data in the children -- not in aParentFrame itself (except + // for those particular operations that the parent frame may do in its + // TransmitAutomaticData()). The reason it works this way is because + // a container frame knows what it wants for its children, whereas children + // have no clue who their parent is. For example, it is <mfrac> who knows + // that its children have to be in scriptsizes, and has to transmit this + // information to them. Hence, when changes occur in a child frame, the child + // has to request the re-build from its parent. Unfortunately, the extra cost + // for this is that it will re-sync in the siblings of the child as well. + static void + RebuildAutomaticDataForChildren(nsIFrame* aParentFrame); + + // helper to blow away the automatic data cached in a frame's subtree and + // re-layout its subtree to reflect changes that may have happen. In the + // event where aParentFrame isn't a MathML frame, it will first walk up to + // the ancestor that is a MathML frame, and re-layout from there -- this is + // to guarantee that automatic data will be rebuilt properly. Note that this + // method re-builds the automatic data in the children -- not in the parent + // frame itself (except for those particular operations that the parent frame + // may do do its TransmitAutomaticData()). @see RebuildAutomaticDataForChildren + // + // aBits are the bits to pass to FrameNeedsReflow() when we call it. + static nsresult + ReLayoutChildren(nsIFrame* aParentFrame); + +protected: + // Helper method which positions child frames as an <mrow> on given baseline + // y = aBaseline starting from x = aOffsetX, calling FinishReflowChild() + // on the frames. + void + PositionRowChildFrames(nscoord aOffsetX, nscoord aBaseline); + + // A variant on FinishAndStoreOverflow() that uses the union of child + // overflows, the frame bounds, and mBoundingMetrics to set and store the + // overflow. + void GatherAndStoreOverflow(ReflowOutput* aMetrics); + + /** + * Call DidReflow() if the NS_FRAME_IN_REFLOW frame bit is set on aFirst and + * all its next siblings up to, but not including, aStop. + * aStop == nullptr meaning all next siblings with the bit set. + * The method does nothing if aFirst == nullptr. + */ + static void DidReflowChildren(nsIFrame* aFirst, nsIFrame* aStop = nullptr); + + /** + * Recompute mIntrinsicWidth if it's not already up to date. + */ + void UpdateIntrinsicWidth(nsRenderingContext* aRenderingContext); + + nscoord mIntrinsicWidth; + + nscoord mBlockStartAscent; + +private: + class RowChildFrameIterator; + friend class RowChildFrameIterator; +}; + + +// -------------------------------------------------------------------------- +// Currently, to benefit from line-breaking inside the <math> element, <math> is +// simply mapping to nsBlockFrame or nsInlineFrame. +// A separate implemention needs to provide: +// 1) line-breaking +// 2) proper inter-frame spacing +// 3) firing of Stretch() (in which case FinalizeReflow() would have to be cleaned) +// Issues: If/when mathml becomes a pluggable component, the separation will be needed. +class nsMathMLmathBlockFrame : public nsBlockFrame { +public: + NS_DECL_QUERYFRAME_TARGET(nsMathMLmathBlockFrame) + NS_DECL_QUERYFRAME + NS_DECL_FRAMEARENA_HELPERS + + friend nsContainerFrame* NS_NewMathMLmathBlockFrame(nsIPresShell* aPresShell, + nsStyleContext* aContext); + + // beware, mFrames is not set by nsBlockFrame + // cannot use mFrames{.FirstChild()|.etc} since the block code doesn't set mFrames + virtual void + SetInitialChildList(ChildListID aListID, + nsFrameList& aChildList) override + { + MOZ_ASSERT(aListID == kPrincipalList || aListID == kBackdropList, + "unexpected frame list"); + nsBlockFrame::SetInitialChildList(aListID, aChildList); + if (aListID == kPrincipalList) { + // re-resolve our subtree to set any mathml-expected data + nsMathMLContainerFrame::RebuildAutomaticDataForChildren(this); + } + } + + virtual void + AppendFrames(ChildListID aListID, + nsFrameList& aFrameList) override + { + NS_ASSERTION(aListID == kPrincipalList || aListID == kNoReflowPrincipalList, + "unexpected frame list"); + nsBlockFrame::AppendFrames(aListID, aFrameList); + if (MOZ_LIKELY(aListID == kPrincipalList)) + nsMathMLContainerFrame::ReLayoutChildren(this); + } + + virtual void + InsertFrames(ChildListID aListID, + nsIFrame* aPrevFrame, + nsFrameList& aFrameList) override + { + NS_ASSERTION(aListID == kPrincipalList || aListID == kNoReflowPrincipalList, + "unexpected frame list"); + nsBlockFrame::InsertFrames(aListID, aPrevFrame, aFrameList); + if (MOZ_LIKELY(aListID == kPrincipalList)) + nsMathMLContainerFrame::ReLayoutChildren(this); + } + + virtual void + RemoveFrame(ChildListID aListID, + nsIFrame* aOldFrame) override + { + NS_ASSERTION(aListID == kPrincipalList || aListID == kNoReflowPrincipalList, + "unexpected frame list"); + nsBlockFrame::RemoveFrame(aListID, aOldFrame); + if (MOZ_LIKELY(aListID == kPrincipalList)) + nsMathMLContainerFrame::ReLayoutChildren(this); + } + + virtual bool IsFrameOfType(uint32_t aFlags) const override { + return nsBlockFrame::IsFrameOfType(aFlags & + ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace)); + } + + // See nsIMathMLFrame.h + bool IsMrowLike() { + return mFrames.FirstChild() != mFrames.LastChild() || + !mFrames.FirstChild(); + } + +protected: + explicit nsMathMLmathBlockFrame(nsStyleContext* aContext) : nsBlockFrame(aContext) { + // We should always have a float manager. Not that things can really try + // to float out of us anyway, but we need one for line layout. + // Bug 1301881: Do we still need to set NS_BLOCK_FLOAT_MGR? + // AddStateBits(NS_BLOCK_FLOAT_MGR); + } + virtual ~nsMathMLmathBlockFrame() {} +}; + +// -------------- + +class nsMathMLmathInlineFrame : public nsInlineFrame, + public nsMathMLFrame { +public: + NS_DECL_QUERYFRAME_TARGET(nsMathMLmathInlineFrame) + NS_DECL_QUERYFRAME + NS_DECL_FRAMEARENA_HELPERS + + friend nsContainerFrame* NS_NewMathMLmathInlineFrame(nsIPresShell* aPresShell, + nsStyleContext* aContext); + + virtual void + SetInitialChildList(ChildListID aListID, + nsFrameList& aChildList) override + { + NS_ASSERTION(aListID == kPrincipalList, "unexpected frame list"); + nsInlineFrame::SetInitialChildList(aListID, aChildList); + // re-resolve our subtree to set any mathml-expected data + nsMathMLContainerFrame::RebuildAutomaticDataForChildren(this); + } + + virtual void + AppendFrames(ChildListID aListID, + nsFrameList& aFrameList) override + { + NS_ASSERTION(aListID == kPrincipalList || aListID == kNoReflowPrincipalList, + "unexpected frame list"); + nsInlineFrame::AppendFrames(aListID, aFrameList); + if (MOZ_LIKELY(aListID == kPrincipalList)) + nsMathMLContainerFrame::ReLayoutChildren(this); + } + + virtual void + InsertFrames(ChildListID aListID, + nsIFrame* aPrevFrame, + nsFrameList& aFrameList) override + { + NS_ASSERTION(aListID == kPrincipalList || aListID == kNoReflowPrincipalList, + "unexpected frame list"); + nsInlineFrame::InsertFrames(aListID, aPrevFrame, aFrameList); + if (MOZ_LIKELY(aListID == kPrincipalList)) + nsMathMLContainerFrame::ReLayoutChildren(this); + } + + virtual void + RemoveFrame(ChildListID aListID, + nsIFrame* aOldFrame) override + { + NS_ASSERTION(aListID == kPrincipalList || aListID == kNoReflowPrincipalList, + "unexpected frame list"); + nsInlineFrame::RemoveFrame(aListID, aOldFrame); + if (MOZ_LIKELY(aListID == kPrincipalList)) + nsMathMLContainerFrame::ReLayoutChildren(this); + } + + virtual bool IsFrameOfType(uint32_t aFlags) const override { + return nsInlineFrame::IsFrameOfType(aFlags & + ~(nsIFrame::eMathML | nsIFrame::eExcludesIgnorableWhitespace)); + } + + bool + IsMrowLike() override { + return mFrames.FirstChild() != mFrames.LastChild() || + !mFrames.FirstChild(); + } + +protected: + explicit nsMathMLmathInlineFrame(nsStyleContext* aContext) : nsInlineFrame(aContext) {} + virtual ~nsMathMLmathInlineFrame() {} +}; + +#endif /* nsMathMLContainerFrame_h___ */ |