summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsSplittableFrame.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/generic/nsSplittableFrame.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/generic/nsSplittableFrame.cpp')
-rw-r--r--layout/generic/nsSplittableFrame.cpp309
1 files changed, 309 insertions, 0 deletions
diff --git a/layout/generic/nsSplittableFrame.cpp b/layout/generic/nsSplittableFrame.cpp
new file mode 100644
index 000000000..00fbabc0c
--- /dev/null
+++ b/layout/generic/nsSplittableFrame.cpp
@@ -0,0 +1,309 @@
+/* -*- 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/. */
+
+/*
+ * base class for rendering objects that can be split across lines,
+ * columns, or pages
+ */
+
+#include "nsSplittableFrame.h"
+#include "nsContainerFrame.h"
+#include "nsIFrameInlines.h"
+
+using namespace mozilla;
+
+void
+nsSplittableFrame::Init(nsIContent* aContent,
+ nsContainerFrame* aParent,
+ nsIFrame* aPrevInFlow)
+{
+ nsFrame::Init(aContent, aParent, aPrevInFlow);
+
+ if (aPrevInFlow) {
+ // Hook the frame into the flow
+ SetPrevInFlow(aPrevInFlow);
+ aPrevInFlow->SetNextInFlow(this);
+ }
+}
+
+void
+nsSplittableFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+ // Disconnect from the flow list
+ if (mPrevContinuation || mNextContinuation) {
+ RemoveFromFlow(this);
+ }
+
+ // Let the base class destroy the frame
+ nsFrame::DestroyFrom(aDestructRoot);
+}
+
+nsSplittableType
+nsSplittableFrame::GetSplittableType() const
+{
+ return NS_FRAME_SPLITTABLE;
+}
+
+nsIFrame* nsSplittableFrame::GetPrevContinuation() const
+{
+ return mPrevContinuation;
+}
+
+void
+nsSplittableFrame::SetPrevContinuation(nsIFrame* aFrame)
+{
+ NS_ASSERTION (!aFrame || GetType() == aFrame->GetType(), "setting a prev continuation with incorrect type!");
+ NS_ASSERTION (!IsInPrevContinuationChain(aFrame, this), "creating a loop in continuation chain!");
+ mPrevContinuation = aFrame;
+ RemoveStateBits(NS_FRAME_IS_FLUID_CONTINUATION);
+}
+
+nsIFrame* nsSplittableFrame::GetNextContinuation() const
+{
+ return mNextContinuation;
+}
+
+void
+nsSplittableFrame::SetNextContinuation(nsIFrame* aFrame)
+{
+ NS_ASSERTION (!aFrame || GetType() == aFrame->GetType(), "setting a next continuation with incorrect type!");
+ NS_ASSERTION (!IsInNextContinuationChain(aFrame, this), "creating a loop in continuation chain!");
+ mNextContinuation = aFrame;
+ if (aFrame)
+ aFrame->RemoveStateBits(NS_FRAME_IS_FLUID_CONTINUATION);
+}
+
+nsIFrame*
+nsSplittableFrame::FirstContinuation() const
+{
+ nsSplittableFrame* firstContinuation = const_cast<nsSplittableFrame*>(this);
+ while (firstContinuation->mPrevContinuation) {
+ firstContinuation = static_cast<nsSplittableFrame*>(firstContinuation->mPrevContinuation);
+ }
+ MOZ_ASSERT(firstContinuation, "post-condition failed");
+ return firstContinuation;
+}
+
+nsIFrame*
+nsSplittableFrame::LastContinuation() const
+{
+ nsSplittableFrame* lastContinuation = const_cast<nsSplittableFrame*>(this);
+ while (lastContinuation->mNextContinuation) {
+ lastContinuation = static_cast<nsSplittableFrame*>(lastContinuation->mNextContinuation);
+ }
+ MOZ_ASSERT(lastContinuation, "post-condition failed");
+ return lastContinuation;
+}
+
+#ifdef DEBUG
+bool nsSplittableFrame::IsInPrevContinuationChain(nsIFrame* aFrame1, nsIFrame* aFrame2)
+{
+ int32_t iterations = 0;
+ while (aFrame1 && iterations < 10) {
+ // Bail out after 10 iterations so we don't bog down debug builds too much
+ if (aFrame1 == aFrame2)
+ return true;
+ aFrame1 = aFrame1->GetPrevContinuation();
+ ++iterations;
+ }
+ return false;
+}
+
+bool nsSplittableFrame::IsInNextContinuationChain(nsIFrame* aFrame1, nsIFrame* aFrame2)
+{
+ int32_t iterations = 0;
+ while (aFrame1 && iterations < 10) {
+ // Bail out after 10 iterations so we don't bog down debug builds too much
+ if (aFrame1 == aFrame2)
+ return true;
+ aFrame1 = aFrame1->GetNextContinuation();
+ ++iterations;
+ }
+ return false;
+}
+#endif
+
+nsIFrame* nsSplittableFrame::GetPrevInFlow() const
+{
+ return (GetStateBits() & NS_FRAME_IS_FLUID_CONTINUATION) ? mPrevContinuation : nullptr;
+}
+
+void
+nsSplittableFrame::SetPrevInFlow(nsIFrame* aFrame)
+{
+ NS_ASSERTION (!aFrame || GetType() == aFrame->GetType(), "setting a prev in flow with incorrect type!");
+ NS_ASSERTION (!IsInPrevContinuationChain(aFrame, this), "creating a loop in continuation chain!");
+ mPrevContinuation = aFrame;
+ AddStateBits(NS_FRAME_IS_FLUID_CONTINUATION);
+}
+
+nsIFrame* nsSplittableFrame::GetNextInFlow() const
+{
+ return mNextContinuation && (mNextContinuation->GetStateBits() & NS_FRAME_IS_FLUID_CONTINUATION) ?
+ mNextContinuation : nullptr;
+}
+
+void
+nsSplittableFrame::SetNextInFlow(nsIFrame* aFrame)
+{
+ NS_ASSERTION (!aFrame || GetType() == aFrame->GetType(), "setting a next in flow with incorrect type!");
+ NS_ASSERTION (!IsInNextContinuationChain(aFrame, this), "creating a loop in continuation chain!");
+ mNextContinuation = aFrame;
+ if (aFrame)
+ aFrame->AddStateBits(NS_FRAME_IS_FLUID_CONTINUATION);
+}
+
+nsIFrame*
+nsSplittableFrame::FirstInFlow() const
+{
+ nsSplittableFrame* firstInFlow = const_cast<nsSplittableFrame*>(this);
+ while (nsIFrame* prev = firstInFlow->GetPrevInFlow()) {
+ firstInFlow = static_cast<nsSplittableFrame*>(prev);
+ }
+ MOZ_ASSERT(firstInFlow, "post-condition failed");
+ return firstInFlow;
+}
+
+nsIFrame*
+nsSplittableFrame::LastInFlow() const
+{
+ nsSplittableFrame* lastInFlow = const_cast<nsSplittableFrame*>(this);
+ while (nsIFrame* next = lastInFlow->GetNextInFlow()) {
+ lastInFlow = static_cast<nsSplittableFrame*>(next);
+ }
+ MOZ_ASSERT(lastInFlow, "post-condition failed");
+ return lastInFlow;
+}
+
+// Remove this frame from the flow. Connects prev in flow and next in flow
+void
+nsSplittableFrame::RemoveFromFlow(nsIFrame* aFrame)
+{
+ nsIFrame* prevContinuation = aFrame->GetPrevContinuation();
+ nsIFrame* nextContinuation = aFrame->GetNextContinuation();
+
+ // The new continuation is fluid only if the continuation on both sides
+ // of the removed frame was fluid
+ if (aFrame->GetPrevInFlow() && aFrame->GetNextInFlow()) {
+ if (prevContinuation) {
+ prevContinuation->SetNextInFlow(nextContinuation);
+ }
+ if (nextContinuation) {
+ nextContinuation->SetPrevInFlow(prevContinuation);
+ }
+ } else {
+ if (prevContinuation) {
+ prevContinuation->SetNextContinuation(nextContinuation);
+ }
+ if (nextContinuation) {
+ nextContinuation->SetPrevContinuation(prevContinuation);
+ }
+ }
+
+ aFrame->SetPrevInFlow(nullptr);
+ aFrame->SetNextInFlow(nullptr);
+}
+
+nscoord
+nsSplittableFrame::GetConsumedBSize() const
+{
+ nscoord height = 0;
+ for (nsIFrame* prev = GetPrevInFlow(); prev; prev = prev->GetPrevInFlow()) {
+ height += prev->GetContentRectRelativeToSelf().height;
+ }
+ return height;
+}
+
+nscoord
+nsSplittableFrame::GetEffectiveComputedBSize(const ReflowInput& aReflowInput,
+ nscoord aConsumedBSize) const
+{
+ nscoord bSize = aReflowInput.ComputedBSize();
+ if (bSize == NS_INTRINSICSIZE) {
+ return NS_INTRINSICSIZE;
+ }
+
+ if (aConsumedBSize == NS_INTRINSICSIZE) {
+ aConsumedBSize = GetConsumedBSize();
+ }
+
+ bSize -= aConsumedBSize;
+
+ // We may have stretched the frame beyond its computed height. Oh well.
+ return std::max(0, bSize);
+}
+
+nsIFrame::LogicalSides
+nsSplittableFrame::GetLogicalSkipSides(const ReflowInput* aReflowInput) const
+{
+ if (IS_TRUE_OVERFLOW_CONTAINER(this)) {
+ return LogicalSides(eLogicalSideBitsBBoth);
+ }
+
+ if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Clone)) {
+ return LogicalSides();
+ }
+
+ LogicalSides skip;
+ if (GetPrevInFlow()) {
+ skip |= eLogicalSideBitsBStart;
+ }
+
+ if (aReflowInput) {
+ // We're in the midst of reflow right now, so it's possible that we haven't
+ // created a nif yet. If our content height is going to exceed our available
+ // height, though, then we're going to need a next-in-flow, it just hasn't
+ // been created yet.
+
+ if (NS_UNCONSTRAINEDSIZE != aReflowInput->AvailableBSize()) {
+ nscoord effectiveCH = this->GetEffectiveComputedBSize(*aReflowInput);
+ if (effectiveCH != NS_INTRINSICSIZE &&
+ effectiveCH > aReflowInput->AvailableBSize()) {
+ // Our content height is going to exceed our available height, so we're
+ // going to need a next-in-flow.
+ skip |= eLogicalSideBitsBEnd;
+ }
+ }
+ } else {
+ nsIFrame* nif = GetNextInFlow();
+ if (nif && !IS_TRUE_OVERFLOW_CONTAINER(nif)) {
+ skip |= eLogicalSideBitsBEnd;
+ }
+ }
+
+ return skip;
+}
+
+LogicalSides
+nsSplittableFrame::PreReflowBlockLevelLogicalSkipSides() const
+{
+ if (MOZ_UNLIKELY(IS_TRUE_OVERFLOW_CONTAINER(this))) {
+ return LogicalSides(mozilla::eLogicalSideBitsBBoth);
+ }
+ if (MOZ_LIKELY(StyleBorder()->mBoxDecorationBreak !=
+ StyleBoxDecorationBreak::Clone) &&
+ GetPrevInFlow()) {
+ return LogicalSides(mozilla::eLogicalSideBitsBStart);
+ }
+ return LogicalSides();
+}
+
+#ifdef DEBUG
+void
+nsSplittableFrame::DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
+{
+ nsFrame::DumpBaseRegressionData(aPresContext, out, aIndent);
+ if (nullptr != mNextContinuation) {
+ IndentBy(out, aIndent);
+ fprintf(out, "<next-continuation va=\"%p\"/>\n", (void*)mNextContinuation);
+ }
+ if (nullptr != mPrevContinuation) {
+ IndentBy(out, aIndent);
+ fprintf(out, "<prev-continuation va=\"%p\"/>\n", (void*)mPrevContinuation);
+ }
+
+}
+#endif