From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- layout/generic/nsIFrameInlines.h | 189 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 layout/generic/nsIFrameInlines.h (limited to 'layout/generic/nsIFrameInlines.h') diff --git a/layout/generic/nsIFrameInlines.h b/layout/generic/nsIFrameInlines.h new file mode 100644 index 0000000000..e187f0dfb0 --- /dev/null +++ b/layout/generic/nsIFrameInlines.h @@ -0,0 +1,189 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef nsIFrameInlines_h___ +#define nsIFrameInlines_h___ + +#include "mozilla/dom/ElementInlines.h" +#include "mozilla/ComputedStyleInlines.h" +#include "nsContainerFrame.h" +#include "nsLayoutUtils.h" +#include "nsPlaceholderFrame.h" +#include "nsCSSAnonBoxes.h" +#include "nsFrameManager.h" + +bool nsIFrame::IsFlexItem() const { + return GetParent() && GetParent()->IsFlexContainerFrame() && + !HasAnyStateBits(NS_FRAME_OUT_OF_FLOW); +} + +bool nsIFrame::IsGridItem() const { + return GetParent() && GetParent()->IsGridContainerFrame() && + !HasAnyStateBits(NS_FRAME_OUT_OF_FLOW); +} + +bool nsIFrame::IsFlexOrGridContainer() const { + return IsFlexContainerFrame() || IsGridContainerFrame(); +} + +bool nsIFrame::IsFlexOrGridItem() const { + return !HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) && GetParent() && + GetParent()->IsFlexOrGridContainer(); +} + +bool nsIFrame::IsMasonry(mozilla::LogicalAxis aAxis) const { + MOZ_DIAGNOSTIC_ASSERT(IsGridContainerFrame()); + return HasAnyStateBits(aAxis == mozilla::eLogicalAxisBlock + ? NS_STATE_GRID_IS_ROW_MASONRY + : NS_STATE_GRID_IS_COL_MASONRY); +} + +bool nsIFrame::IsTableCaption() const { + return StyleDisplay()->mDisplay == mozilla::StyleDisplay::TableCaption && + GetParent()->Style()->GetPseudoType() == + mozilla::PseudoStyleType::tableWrapper; +} + +bool nsIFrame::IsFloating() const { + return HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) && + StyleDisplay()->IsFloating(this); +} + +bool nsIFrame::IsAbsPosContainingBlock() const { + return Style()->IsAbsPosContainingBlock(this); +} + +bool nsIFrame::IsFixedPosContainingBlock() const { + return Style()->IsFixedPosContainingBlock(this); +} + +bool nsIFrame::IsRelativelyOrStickyPositioned() const { + return StyleDisplay()->IsRelativelyOrStickyPositioned(this); +} + +bool nsIFrame::IsRelativelyPositioned() const { + return StyleDisplay()->IsRelativelyPositioned(this); +} + +bool nsIFrame::IsStickyPositioned() const { + return StyleDisplay()->IsStickyPositioned(this); +} + +bool nsIFrame::IsAbsolutelyPositioned( + const nsStyleDisplay* aStyleDisplay) const { + return HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) && + StyleDisplayWithOptionalParam(aStyleDisplay) + ->IsAbsolutelyPositioned(this); +} + +inline bool nsIFrame::IsTrueOverflowContainer() const { + return HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER) && + !IsAbsolutelyPositioned(); + // XXXfr This check isn't quite correct, because it doesn't handle cases + // where the out-of-flow has overflow.. but that's rare. + // We'll need to revisit the way abspos continuations are handled later + // for various reasons, this detail is one of them. See bug 154892 +} + +bool nsIFrame::IsBlockOutside() const { + return StyleDisplay()->IsBlockOutside(this); +} + +bool nsIFrame::IsInlineOutside() const { + return StyleDisplay()->IsInlineOutside(this); +} + +bool nsIFrame::IsColumnSpan() const { + return IsBlockOutside() && StyleColumn()->IsColumnSpanStyle(); +} + +bool nsIFrame::IsColumnSpanInMulticolSubtree() const { + return IsColumnSpan() && + (HasAnyStateBits(NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR) || + // A frame other than inline and block won't have + // NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR. We instead test its parent. + (GetParent() && GetParent()->Style()->GetPseudoType() == + mozilla::PseudoStyleType::columnSpanWrapper)); +} + +mozilla::StyleDisplay nsIFrame::GetDisplay() const { + return StyleDisplay()->GetDisplay(this); +} + +void nsIFrame::PropagateWritingModeToSelfAndAncestors( + mozilla::WritingMode aWM) { + MOZ_ASSERT(IsCanvasFrame()); + for (auto f = this; f; f = f->GetParent()) { + f->mWritingMode = aWM; + } +} + +nsContainerFrame* nsIFrame::GetInFlowParent() const { + if (HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { + nsIFrame* ph = + FirstContinuation()->GetProperty(nsIFrame::PlaceholderFrameProperty()); + return ph->GetParent(); + } + + return GetParent(); +} + +// We generally want to follow the style tree for preserve-3d, jumping through +// display: contents. +// +// There are various fun mismatches between the flattened tree and the frame +// tree which makes this non-trivial to do looking at the frame tree state: +// +// - Anon boxes. You'd have to step through them, because you generally want to +// ignore them. +// +// - IB-splits, which produce a frame tree where frames for the block inside +// the inline are not children of any frame from the inline. +// +// - display: contents, which makes DOM ancestors not have frames even when a +// descendant does. +// +// See GetFlattenedTreeParentElementForStyle for the difference between it and +// plain GetFlattenedTreeParentElement. +nsIFrame* nsIFrame::GetClosestFlattenedTreeAncestorPrimaryFrame() const { + if (!mContent) { + return nullptr; + } + mozilla::dom::Element* parent = + mContent->GetFlattenedTreeParentElementForStyle(); + while (parent) { + if (nsIFrame* frame = parent->GetPrimaryFrame()) { + return frame; + } + // NOTE(emilio): This should be an assert except we have code in tree which + // violates invariants like the frame construction code. + if (MOZ_UNLIKELY(!parent->IsDisplayContents())) { + return nullptr; + } + parent = parent->GetFlattenedTreeParentElementForStyle(); + } + return nullptr; +} + +nsPoint nsIFrame::GetNormalPosition(bool* aHasProperty) const { + bool hasProperty; + nsPoint normalPosition = GetProperty(NormalPositionProperty(), &hasProperty); + if (aHasProperty) { + *aHasProperty = hasProperty; + } + return hasProperty ? normalPosition : GetPosition(); +} + +mozilla::LogicalPoint nsIFrame::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()); +} + +#endif -- cgit v1.2.3