1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
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::LogicalAxis::Block
? 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 <frameset> 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
|
