Line data Source code
1 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* This Source Code Form is subject to the terms of the Mozilla Public
3 : * License, v. 2.0. If a copy of the MPL was not distributed with this
4 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5 :
6 : /* a list of all frame state bits, for preprocessing */
7 :
8 : /******
9 :
10 : This file contains definitions for frame state bits -- values used
11 : in nsIFrame::mState -- and groups of frame state bits and which
12 : classes they apply to.
13 :
14 : There are two macros that can be defined before #including this
15 : file:
16 :
17 : FRAME_STATE_GROUP(name_, class_)
18 :
19 : This denotes the existence of a named group of frame state bits.
20 : name_ is the name of the group and class_ is the name of a frame
21 : class that uses the frame state bits that are a part of the group.
22 :
23 : The main group of frame state bits is named "Generic" and is
24 : defined to apply to nsIFrame, i.e. all frames. All of the global
25 : frame state bits -- bits 0..19 and 32..59 -- are in this group.
26 :
27 : FRAME_STATE_BIT(group_, value_, name_)
28 :
29 : This denotes the existence of a frame state bit. group_ indicates
30 : which group the bit belongs to, value_ is the bit number (0..63),
31 : and name_ is the name of the frame state bit constant.
32 :
33 : Note that if you add a new frame state group, you'll need to #include
34 : the header for its frame classes in nsFrameState.cpp and, if they don't
35 : already, add nsQueryFrame implementations (which can be DEBUG-only) to
36 : the frame classes.
37 :
38 : ******/
39 :
40 : #ifndef FRAME_STATE_GROUP
41 : #define FRAME_STATE_GROUP(name_, class_) /* nothing */
42 : #define DEFINED_FRAME_STATE_GROUP
43 : #endif
44 :
45 : #ifndef FRAME_STATE_BIT
46 : #define FRAME_STATE_BIT(group_, value_, name_) /* nothing */
47 : #define DEFINED_FRAME_STATE_BIT
48 : #endif
49 :
50 : // == Frame state bits that apply to all frames ===============================
51 :
52 0 : FRAME_STATE_GROUP(Generic, nsIFrame)
53 :
54 : // This bit is set when the frame is actively being reflowed. It is set in many
55 : // frames' Reflow() by calling MarkInReflow() and unset in DidReflow().
56 0 : FRAME_STATE_BIT(Generic, 0, NS_FRAME_IN_REFLOW)
57 :
58 : // This bit is set when a frame is created. After it has been reflowed
59 : // once (during the DidReflow with a finished state) the bit is
60 : // cleared.
61 0 : FRAME_STATE_BIT(Generic, 1, NS_FRAME_FIRST_REFLOW)
62 :
63 : // For a continuation frame, if this bit is set, then this a "fluid"
64 : // continuation, i.e., across a line boundary. Otherwise it's a "hard"
65 : // continuation, e.g. a bidi continuation.
66 0 : FRAME_STATE_BIT(Generic, 2, NS_FRAME_IS_FLUID_CONTINUATION)
67 :
68 : // For nsIAnonymousContentCreator content that's created using ContentInfo.
69 0 : FRAME_STATE_BIT(Generic, 3, NS_FRAME_ANONYMOUSCONTENTCREATOR_CONTENT)
70 :
71 : // If this bit is set, then a reference to the frame is being held
72 : // elsewhere. The frame may want to send a notification when it is
73 : // destroyed to allow these references to be cleared.
74 0 : FRAME_STATE_BIT(Generic, 4, NS_FRAME_EXTERNAL_REFERENCE)
75 :
76 : // If this bit is set, this frame or one of its descendants has a
77 : // percentage block-size that depends on an ancestor of this frame.
78 : // (Or it did at one point in the past, since we don't necessarily clear
79 : // the bit when it's no longer needed; it's an optimization.)
80 0 : FRAME_STATE_BIT(Generic, 5, NS_FRAME_CONTAINS_RELATIVE_BSIZE)
81 :
82 : // If this bit is set, then the frame corresponds to generated content
83 0 : FRAME_STATE_BIT(Generic, 6, NS_FRAME_GENERATED_CONTENT)
84 :
85 : // If this bit is set the frame is a continuation that is holding overflow,
86 : // i.e. it is a next-in-flow created to hold overflow after the box's
87 : // height has ended. This means the frame should be a) at the top of the
88 : // page and b) invisible: no borders, zero height, ignored in margin
89 : // collapsing, etc. See nsContainerFrame.h
90 0 : FRAME_STATE_BIT(Generic, 7, NS_FRAME_IS_OVERFLOW_CONTAINER)
91 :
92 : // If this bit is set, then the frame has been moved out of the flow,
93 : // e.g., it is absolutely positioned or floated
94 0 : FRAME_STATE_BIT(Generic, 8, NS_FRAME_OUT_OF_FLOW)
95 :
96 : // Frame can be an abs/fixed pos. container, if its style says so.
97 : // MarkAs[Not]AbsoluteContainingBlock will assert that this bit is set.
98 : // NS_FRAME_HAS_ABSPOS_CHILDREN must not be set when this bit is unset.
99 0 : FRAME_STATE_BIT(Generic, 9, NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN)
100 :
101 : // If this bit is set, then the frame and _all_ of its descendant frames need
102 : // to be reflowed.
103 : // This bit is set when the frame is first created.
104 : // This bit is cleared by DidReflow after the required call to Reflow has
105 : // finished.
106 : // Do not set this bit yourself if you plan to pass the frame to
107 : // nsIPresShell::FrameNeedsReflow. Pass the right arguments instead.
108 0 : FRAME_STATE_BIT(Generic, 10, NS_FRAME_IS_DIRTY)
109 :
110 : // If this bit is set then the frame is too deep in the frame tree, and
111 : // we'll stop updating it and its children, to prevent stack overflow
112 : // and the like.
113 0 : FRAME_STATE_BIT(Generic, 11, NS_FRAME_TOO_DEEP_IN_FRAME_TREE)
114 :
115 : // If this bit is set, then either:
116 : // 1. the frame has at least one child that has the NS_FRAME_IS_DIRTY bit or
117 : // NS_FRAME_HAS_DIRTY_CHILDREN bit set, or
118 : // 2. the frame has had at least one child removed since the last reflow, or
119 : // 3. the frame has had a style change that requires the frame to be reflowed
120 : // but does not _necessarily_ require its descendants to be reflowed (e.g.,
121 : // for a 'height', 'width', 'margin', etc. change, it's up to the
122 : // applicable Reflow methods to decide whether the frame's children
123 : // _actually_ need to be reflowed).
124 : // If this bit is set but the NS_FRAME_IS_DIRTY is not set, then Reflow still
125 : // needs to be called on the frame, but Reflow will likely not do as much work
126 : // as it would if NS_FRAME_IS_DIRTY were set. See the comment documenting
127 : // nsFrame::Reflow for more.
128 : // This bit is cleared by DidReflow after the required call to Reflow has
129 : // finished.
130 : // Do not set this bit yourself if you plan to pass the frame to
131 : // nsIPresShell::FrameNeedsReflow. Pass the right arguments instead.
132 0 : FRAME_STATE_BIT(Generic, 12, NS_FRAME_HAS_DIRTY_CHILDREN)
133 :
134 : // If this bit is set, the frame has an associated view
135 0 : FRAME_STATE_BIT(Generic, 13, NS_FRAME_HAS_VIEW)
136 :
137 : // If this bit is set, the frame was created from anonymous content.
138 0 : FRAME_STATE_BIT(Generic, 14, NS_FRAME_INDEPENDENT_SELECTION)
139 :
140 : // If this bit is set, the frame is part of the mangled frame hierarchy
141 : // that results when an inline has been split because of a nested block.
142 : // See the comments in nsCSSFrameConstructor::ConstructInline for
143 : // more details. (this is only set on nsBlockFrame/nsInlineFrame frames)
144 0 : FRAME_STATE_BIT(Generic, 15, NS_FRAME_PART_OF_IBSPLIT)
145 :
146 : // If this bit is set, then transforms (e.g. CSS or SVG transforms) are allowed
147 : // to affect the frame, and a transform may currently be in affect. If this bit
148 : // is not set, then any transforms on the frame will be ignored.
149 : // This is used primarily in GetTransformMatrix to optimize for the
150 : // common case.
151 0 : FRAME_STATE_BIT(Generic, 16, NS_FRAME_MAY_BE_TRANSFORMED)
152 :
153 : // If this bit is set, the frame itself is a bidi continuation,
154 : // or is incomplete (its next sibling is a bidi continuation)
155 0 : FRAME_STATE_BIT(Generic, 17, NS_FRAME_IS_BIDI)
156 :
157 : // If this bit is set the frame has descendant with a view
158 0 : FRAME_STATE_BIT(Generic, 18, NS_FRAME_HAS_CHILD_WITH_VIEW)
159 :
160 : // If this bit is set, then reflow may be dispatched from the current
161 : // frame instead of the root frame.
162 0 : FRAME_STATE_BIT(Generic, 19, NS_FRAME_REFLOW_ROOT)
163 :
164 : // NOTE: Bits 20-31 and 60-63 of the frame state are reserved for specific
165 : // frame classes.
166 :
167 : // This bit is set on floats whose parent does not contain their
168 : // placeholder. This can happen for two reasons: (1) the float was
169 : // split, and this piece is the continuation, or (2) the entire float
170 : // didn't fit on the page.
171 : // Note that this bit is also shared by text frames for
172 : // TEXT_IS_IN_TOKEN_MATHML. That's OK because we only check the
173 : // NS_FRAME_IS_PUSHED_FLOAT bit on frames which we already know are
174 : // out-of-flow.
175 0 : FRAME_STATE_BIT(Generic, 32, NS_FRAME_IS_PUSHED_FLOAT)
176 :
177 : // This bit acts as a loop flag for recursive paint server drawing.
178 0 : FRAME_STATE_BIT(Generic, 33, NS_FRAME_DRAWING_AS_PAINTSERVER)
179 :
180 : // Intrinsic ISize depending on the frame's BSize is rare but possible.
181 : // This flag indicates that the frame has (or once had) a descendant in that
182 : // situation (possibly the frame itself).
183 0 : FRAME_STATE_BIT(Generic, 34, NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)
184 :
185 : // A flag that tells us we can take the common path with respect to style
186 : // properties for this frame when building event regions. This flag is cleared
187 : // when any styles are changed and then we recompute it on the next build
188 : // of the event regions.
189 0 : FRAME_STATE_BIT(Generic, 35, NS_FRAME_SIMPLE_EVENT_REGIONS)
190 :
191 : // Frame is a display root and the retained layer tree needs to be updated
192 : // at the next paint via display list construction.
193 : // Only meaningful for display roots, so we don't really need a global state
194 : // bit; we could free up this bit with a little extra complexity.
195 0 : FRAME_STATE_BIT(Generic, 36, NS_FRAME_UPDATE_LAYER_TREE)
196 :
197 : // Frame can accept absolutely positioned children.
198 0 : FRAME_STATE_BIT(Generic, 37, NS_FRAME_HAS_ABSPOS_CHILDREN)
199 :
200 : // A display item for this frame has been painted as part of a PaintedLayer.
201 0 : FRAME_STATE_BIT(Generic, 38, NS_FRAME_PAINTED_THEBES)
202 :
203 : // Frame is or is a descendant of something with a fixed block-size, unless
204 : // that ancestor is a body or html element, and has no closer ancestor that is
205 : // overflow:auto or overflow:scroll.
206 0 : FRAME_STATE_BIT(Generic, 39, NS_FRAME_IN_CONSTRAINED_BSIZE)
207 :
208 : // This is only set during painting
209 0 : FRAME_STATE_BIT(Generic, 40, NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO)
210 :
211 : // Is this frame a container for font size inflation, i.e., is it a
212 : // frame whose width is used to determine the inflation factor for
213 : // everything whose nearest ancestor container for this frame?
214 0 : FRAME_STATE_BIT(Generic, 41, NS_FRAME_FONT_INFLATION_CONTAINER)
215 :
216 : // Does this frame manage a region in which we do font size inflation,
217 : // i.e., roughly, is it an element establishing a new block formatting
218 : // context?
219 0 : FRAME_STATE_BIT(Generic, 42, NS_FRAME_FONT_INFLATION_FLOW_ROOT)
220 :
221 : // This bit is set on SVG frames that are laid out using SVG's coordinate
222 : // system based layout (as opposed to any of the CSS layout models). Note that
223 : // this does not include nsSVGOuterSVGFrame since it takes part is CSS layout.
224 0 : FRAME_STATE_BIT(Generic, 43, NS_FRAME_SVG_LAYOUT)
225 :
226 : // Is this frame allowed to have generated (::before/::after) content?
227 0 : FRAME_STATE_BIT(Generic, 44, NS_FRAME_MAY_HAVE_GENERATED_CONTENT)
228 :
229 : // This bit is set on frames that create ContainerLayers with component
230 : // alpha children. With BasicLayers we avoid creating these, so we mark
231 : // the frames for future reference.
232 0 : FRAME_STATE_BIT(Generic, 45, NS_FRAME_NO_COMPONENT_ALPHA)
233 :
234 : // This bit indicates that we're tracking visibility for this frame, and that
235 : // the frame has a VisibilityStateProperty property.
236 0 : FRAME_STATE_BIT(Generic, 46, NS_FRAME_VISIBILITY_IS_TRACKED)
237 :
238 : // The frame is a descendant of SVGTextFrame and is thus used for SVG
239 : // text layout.
240 0 : FRAME_STATE_BIT(Generic, 47, NS_FRAME_IS_SVG_TEXT)
241 :
242 : // Frame is marked as needing painting
243 0 : FRAME_STATE_BIT(Generic, 48, NS_FRAME_NEEDS_PAINT)
244 :
245 : // Frame has a descendant frame that needs painting - This includes
246 : // cross-doc children.
247 0 : FRAME_STATE_BIT(Generic, 49, NS_FRAME_DESCENDANT_NEEDS_PAINT)
248 :
249 : // Frame is a descendant of a popup
250 0 : FRAME_STATE_BIT(Generic, 50, NS_FRAME_IN_POPUP)
251 :
252 : // Frame has only descendant frames that needs painting - This includes
253 : // cross-doc children. This guarantees that all descendents have
254 : // NS_FRAME_NEEDS_PAINT and NS_FRAME_ALL_DESCENDANTS_NEED_PAINT, or they
255 : // have no display items.
256 0 : FRAME_STATE_BIT(Generic, 51, NS_FRAME_ALL_DESCENDANTS_NEED_PAINT)
257 :
258 : // Frame is marked as NS_FRAME_NEEDS_PAINT and also has an explicit
259 : // rect stored to invalidate.
260 0 : FRAME_STATE_BIT(Generic, 52, NS_FRAME_HAS_INVALID_RECT)
261 :
262 : // Frame is not displayed directly due to it being, or being under, an SVG
263 : // <defs> element or an SVG resource element (<mask>, <pattern>, etc.)
264 0 : FRAME_STATE_BIT(Generic, 53, NS_FRAME_IS_NONDISPLAY)
265 :
266 : // Frame has a LayerActivityProperty property
267 0 : FRAME_STATE_BIT(Generic, 54, NS_FRAME_HAS_LAYER_ACTIVITY_PROPERTY)
268 :
269 : // Frame owns anonymous boxes whose style contexts it will need to update during
270 : // a stylo tree traversal.
271 0 : FRAME_STATE_BIT(Generic, 55, NS_FRAME_OWNS_ANON_BOXES)
272 :
273 : // Frame maybe has a counter-reset/increment style
274 0 : FRAME_STATE_BIT(Generic, 56, NS_FRAME_HAS_CSS_COUNTER_STYLE)
275 :
276 : // The display list of the frame can be handled by the shortcut for
277 : // COMMON CASE.
278 0 : FRAME_STATE_BIT(Generic, 57, NS_FRAME_SIMPLE_DISPLAYLIST)
279 :
280 : // Set for all descendants of MathML sub/supscript elements (other than the
281 : // base frame) to indicate that the SSTY font feature should be used.
282 0 : FRAME_STATE_BIT(Generic, 58, NS_FRAME_MATHML_SCRIPT_DESCENDANT)
283 :
284 : // This state bit is set on frames within token MathML elements if the
285 : // token represents an <mi> tag whose inner HTML consists of a single
286 : // non-whitespace character to allow special rendering behaviour.
287 0 : FRAME_STATE_BIT(Generic, 59, NS_FRAME_IS_IN_SINGLE_CHAR_MI)
288 :
289 : // NOTE: Bits 20-31 and 60-63 of the frame state are reserved for specific
290 : // frame classes.
291 :
292 :
293 : // == Frame state bits that apply to box frames ===============================
294 :
295 0 : FRAME_STATE_GROUP(Box, nsBoxFrame)
296 :
297 0 : FRAME_STATE_BIT(Box, 20, NS_STATE_BOX_CHILD_RESERVED)
298 0 : FRAME_STATE_BIT(Box, 21, NS_STATE_STACK_NOT_POSITIONED)
299 0 : FRAME_STATE_BIT(Box, 22, NS_STATE_IS_HORIZONTAL)
300 0 : FRAME_STATE_BIT(Box, 23, NS_STATE_AUTO_STRETCH)
301 0 : FRAME_STATE_BIT(Box, 24, NS_STATE_IS_ROOT)
302 0 : FRAME_STATE_BIT(Box, 25, NS_STATE_CURRENTLY_IN_DEBUG)
303 0 : FRAME_STATE_BIT(Box, 26, NS_STATE_SET_TO_DEBUG)
304 0 : FRAME_STATE_BIT(Box, 27, NS_STATE_DEBUG_WAS_SET)
305 0 : FRAME_STATE_BIT(Box, 28, NS_STATE_MENU_HAS_POPUP_LIST)
306 0 : FRAME_STATE_BIT(Box, 29, NS_STATE_BOX_WRAPS_KIDS_IN_BLOCK)
307 0 : FRAME_STATE_BIT(Box, 30, NS_STATE_EQUAL_SIZE)
308 0 : FRAME_STATE_BIT(Box, 31, NS_STATE_IS_DIRECTION_NORMAL)
309 0 : FRAME_STATE_BIT(Box, 60, NS_FRAME_MOUSE_THROUGH_ALWAYS)
310 0 : FRAME_STATE_BIT(Box, 61, NS_FRAME_MOUSE_THROUGH_NEVER)
311 :
312 :
313 : // == Frame state bits that apply to flex container frames ====================
314 :
315 0 : FRAME_STATE_GROUP(FlexContainer, nsFlexContainerFrame)
316 :
317 : // True iff the normal flow children are already in CSS 'order' in the
318 : // order they occur in the child frame list.
319 0 : FRAME_STATE_BIT(FlexContainer, 20, NS_STATE_FLEX_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER)
320 :
321 : // Set for a flex container that is emulating a legacy
322 : // 'display:-webkit-{inline-}box' container.
323 0 : FRAME_STATE_BIT(FlexContainer, 21, NS_STATE_FLEX_IS_LEGACY_WEBKIT_BOX)
324 :
325 : // True if the container has no flex items; may lie if there is a pending reflow
326 0 : FRAME_STATE_BIT(FlexContainer, 22, NS_STATE_FLEX_SYNTHESIZE_BASELINE)
327 :
328 : // == Frame state bits that apply to grid container frames ====================
329 :
330 0 : FRAME_STATE_GROUP(GridContainer, nsGridContainerFrame)
331 :
332 : // True iff the normal flow children are already in CSS 'order' in the
333 : // order they occur in the child frame list.
334 0 : FRAME_STATE_BIT(GridContainer, 20, NS_STATE_GRID_NORMAL_FLOW_CHILDREN_IN_CSS_ORDER)
335 :
336 : // True iff some first-in-flow in-flow children were pushed.
337 : // Note that those child frames may have been removed without this bit
338 : // being updated for performance reasons, so code shouldn't depend on
339 : // actually finding any pushed items when this bit is set.
340 0 : FRAME_STATE_BIT(GridContainer, 21, NS_STATE_GRID_DID_PUSH_ITEMS)
341 :
342 : // True iff computed grid values should be generated on the next reflow
343 0 : FRAME_STATE_BIT(GridContainer, 22, NS_STATE_GRID_GENERATE_COMPUTED_VALUES)
344 :
345 : // True if the container has no grid items; may lie if there is a pending reflow
346 0 : FRAME_STATE_BIT(GridContainer, 23, NS_STATE_GRID_SYNTHESIZE_BASELINE)
347 :
348 : // == Frame state bits that apply to SVG frames ===============================
349 :
350 0 : FRAME_STATE_GROUP(SVG, nsSVGDisplayableFrame)
351 0 : FRAME_STATE_GROUP(SVG, nsSVGContainerFrame)
352 :
353 0 : FRAME_STATE_BIT(SVG, 20, NS_STATE_IS_OUTER_SVG)
354 :
355 : // If this bit is set, we are a <clipPath> element or descendant.
356 0 : FRAME_STATE_BIT(SVG, 21, NS_STATE_SVG_CLIPPATH_CHILD)
357 :
358 : // For SVG text, the NS_FRAME_IS_DIRTY and NS_FRAME_HAS_DIRTY_CHILDREN bits
359 : // indicate that our anonymous block child needs to be reflowed, and that
360 : // mPositions will likely need to be updated as a consequence. These are set,
361 : // for example, when the font-family changes. Sometimes we only need to
362 : // update mPositions though. For example if the x/y attributes change.
363 : // mPositioningDirty is used to indicate this latter "things are dirty" case
364 : // to allow us to avoid reflowing the anonymous block when it is not
365 : // necessary.
366 0 : FRAME_STATE_BIT(SVG, 22, NS_STATE_SVG_POSITIONING_DIRTY)
367 :
368 : // For text, whether the values from x/y/dx/dy attributes have any percentage
369 : // values that are used in determining the positions of glyphs. The value will
370 : // be true even if a positioning value is overridden by a descendant element's
371 : // attribute with a non-percentage length. For example,
372 : // NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES would be set for:
373 : //
374 : // <text x="10%"><tspan x="0">abc</tspan></text>
375 : //
376 : // Percentage values beyond the number of addressable characters, however, do
377 : // not influence NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES. For example,
378 : // NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES would be false for:
379 : //
380 : // <text x="10 20 30 40%">abc</text>
381 : //
382 : // NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES is used to determine whether
383 : // to recompute mPositions when the viewport size changes. So although the
384 : // first example above shows that NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES
385 : // can be true even if a viewport size change will not affect mPositions,
386 : // determining a completley accurate value for
387 : // NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES would require extra work that is
388 : // probably not worth it.
389 0 : FRAME_STATE_BIT(SVG, 23, NS_STATE_SVG_POSITIONING_MAY_USE_PERCENTAGES)
390 :
391 0 : FRAME_STATE_BIT(SVG, 24, NS_STATE_SVG_TEXT_IN_REFLOW)
392 :
393 :
394 : // == Frame state bits that apply to text frames ==============================
395 :
396 0 : FRAME_STATE_GROUP(Text, nsTextFrame)
397 :
398 : // -- Flags set during reflow -------------------------------------------------
399 :
400 : // nsTextFrame.cpp defines TEXT_REFLOW_FLAGS to be all of these bits.
401 :
402 : // This bit is set on the first frame in a continuation indicating
403 : // that it was chopped short because of :first-letter style.
404 0 : FRAME_STATE_BIT(Text, 20, TEXT_FIRST_LETTER)
405 :
406 : // This bit is set on frames that are logically adjacent to the start of the
407 : // line (i.e. no prior frame on line with actual displayed in-flow content).
408 0 : FRAME_STATE_BIT(Text, 21, TEXT_START_OF_LINE)
409 :
410 : // This bit is set on frames that are logically adjacent to the end of the
411 : // line (i.e. no following on line with actual displayed in-flow content).
412 0 : FRAME_STATE_BIT(Text, 22, TEXT_END_OF_LINE)
413 :
414 : // This bit is set on frames that end with a hyphenated break.
415 0 : FRAME_STATE_BIT(Text, 23, TEXT_HYPHEN_BREAK)
416 :
417 : // This bit is set on frames that trimmed trailing whitespace characters when
418 : // calculating their width during reflow.
419 0 : FRAME_STATE_BIT(Text, 24, TEXT_TRIMMED_TRAILING_WHITESPACE)
420 :
421 : // This bit is set on frames that have justification enabled. We record
422 : // this in a state bit because we don't always have the containing block
423 : // easily available to check text-align on.
424 0 : FRAME_STATE_BIT(Text, 25, TEXT_JUSTIFICATION_ENABLED)
425 :
426 : // Set this bit if the textframe has overflow area for IME/spellcheck underline.
427 0 : FRAME_STATE_BIT(Text, 26, TEXT_SELECTION_UNDERLINE_OVERFLOWED)
428 :
429 : // -- Cache bits for IsEmpty() ------------------------------------------------
430 :
431 : // nsTextFrame.cpp defines TEXT_WHITESPACE_FLAGS to be both of these bits.
432 :
433 : // Set this bit if the textframe is known to be only collapsible whitespace.
434 0 : FRAME_STATE_BIT(Text, 27, TEXT_IS_ONLY_WHITESPACE)
435 :
436 : // Set this bit if the textframe is known to be not only collapsible whitespace.
437 0 : FRAME_STATE_BIT(Text, 28, TEXT_ISNOT_ONLY_WHITESPACE)
438 :
439 : // -- Other state bits --------------------------------------------------------
440 :
441 : // Set when this text frame is mentioned in the userdata for mTextRun
442 0 : FRAME_STATE_BIT(Text, 29, TEXT_IN_TEXTRUN_USER_DATA)
443 :
444 : // This state bit is set on frames whose character data offsets need to be
445 : // fixed up
446 0 : FRAME_STATE_BIT(Text, 30, TEXT_OFFSETS_NEED_FIXING)
447 :
448 : // This state bit is set on frames that have some non-collapsed characters after
449 : // reflow
450 0 : FRAME_STATE_BIT(Text, 31, TEXT_HAS_NONCOLLAPSED_CHARACTERS)
451 :
452 : // This state bit is set on children of token MathML elements.
453 : // NOTE: TEXT_IS_IN_TOKEN_MATHML has a global state bit value that is shared
454 : // with NS_FRAME_IS_PUSHED_FLOAT.
455 0 : FRAME_STATE_BIT(Text, 32, TEXT_IS_IN_TOKEN_MATHML)
456 :
457 : // Set when this text frame is mentioned in the userdata for the
458 : // uninflated textrun property
459 0 : FRAME_STATE_BIT(Text, 60, TEXT_IN_UNINFLATED_TEXTRUN_USER_DATA)
460 :
461 0 : FRAME_STATE_BIT(Text, 61, TEXT_HAS_FONT_INFLATION)
462 :
463 : // Set when this text frame contains nothing that will actually render
464 0 : FRAME_STATE_BIT(Text, 62, TEXT_NO_RENDERED_GLYPHS)
465 :
466 : // Whether this frame is cached in the Offset Frame Cache
467 : // (OffsetToFrameProperty)
468 0 : FRAME_STATE_BIT(Text, 63, TEXT_IN_OFFSET_CACHE)
469 :
470 :
471 : // == Frame state bits that apply to block frames =============================
472 :
473 0 : FRAME_STATE_GROUP(Block, nsBlockFrame)
474 :
475 : // Something in the block has changed that requires Bidi resolution to be
476 : // performed on the block. This flag must be either set on all blocks in a
477 : // continuation chain or none of them.
478 0 : FRAME_STATE_BIT(Block, 20, NS_BLOCK_NEEDS_BIDI_RESOLUTION)
479 :
480 0 : FRAME_STATE_BIT(Block, 21, NS_BLOCK_HAS_PUSHED_FLOATS)
481 :
482 : // This indicates that this is a frame from which child margins can be
483 : // calculated. The absence of this flag implies that child margin calculations
484 : // should ignore the frame and look further up the parent chain. Used in
485 : // nsBlockReflowContext::ComputeCollapsedBStartMargin() via
486 : // nsBlockFrame::IsMarginRoot().
487 : //
488 : // This causes the BlockReflowInput's constructor to set the
489 : // mIsBStartMarginRoot and mIsBEndMarginRoot flags.
490 0 : FRAME_STATE_BIT(Block, 22, NS_BLOCK_MARGIN_ROOT)
491 :
492 : // This indicates that a block frame should create its own float manager. This
493 : // is required by each block frame that can contain floats. The float manager is
494 : // used to reserve space for the floated frames.
495 0 : FRAME_STATE_BIT(Block, 23, NS_BLOCK_FLOAT_MGR)
496 :
497 : // For setting the relevant bits on a block formatting context:
498 : #define NS_BLOCK_FORMATTING_CONTEXT_STATE_BITS (NS_BLOCK_FLOAT_MGR | NS_BLOCK_MARGIN_ROOT)
499 :
500 0 : FRAME_STATE_BIT(Block, 24, NS_BLOCK_HAS_LINE_CURSOR)
501 :
502 0 : FRAME_STATE_BIT(Block, 25, NS_BLOCK_HAS_OVERFLOW_LINES)
503 :
504 0 : FRAME_STATE_BIT(Block, 26, NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS)
505 :
506 : // Set on any block that has descendant frames in the normal
507 : // flow with 'clear' set to something other than 'none'
508 : // (including <BR CLEAR="..."> frames)
509 0 : FRAME_STATE_BIT(Block, 27, NS_BLOCK_HAS_CLEAR_CHILDREN)
510 :
511 : // NS_BLOCK_CLIP_PAGINATED_OVERFLOW is only set in paginated prescontexts, on
512 : // blocks which were forced to not have scrollframes but still need to clip
513 : // the display of their kids.
514 0 : FRAME_STATE_BIT(Block, 28, NS_BLOCK_CLIP_PAGINATED_OVERFLOW)
515 :
516 : // NS_BLOCK_HAS_FIRST_LETTER_STYLE means that the block has first-letter style,
517 : // even if it has no actual first-letter frame among its descendants.
518 0 : FRAME_STATE_BIT(Block, 29, NS_BLOCK_HAS_FIRST_LETTER_STYLE)
519 :
520 : // NS_BLOCK_FRAME_HAS_OUTSIDE_BULLET and NS_BLOCK_FRAME_HAS_INSIDE_BULLET
521 : // means the block has an associated bullet frame, they are mutually exclusive.
522 0 : FRAME_STATE_BIT(Block, 30, NS_BLOCK_FRAME_HAS_OUTSIDE_BULLET)
523 0 : FRAME_STATE_BIT(Block, 31, NS_BLOCK_FRAME_HAS_INSIDE_BULLET)
524 :
525 : // This block has had a child marked dirty, so before we reflow we need
526 : // to look through the lines to find any such children and mark
527 : // appropriate lines dirty.
528 0 : FRAME_STATE_BIT(Block, 61, NS_BLOCK_LOOK_FOR_DIRTY_FRAMES)
529 :
530 : // Are our cached intrinsic widths intrinsic widths for font size
531 : // inflation? i.e., what was the current state of
532 : // GetPresContext()->mInflationDisabledForShrinkWrap at the time they
533 : // were computed?
534 : // nsBlockFrame is the only thing that caches intrinsic widths that
535 : // needs to track this because it's the only thing that caches intrinsic
536 : // widths that lives inside of things (form controls) that do intrinsic
537 : // sizing with font inflation enabled.
538 0 : FRAME_STATE_BIT(Block, 62, NS_BLOCK_FRAME_INTRINSICS_INFLATED)
539 :
540 : // NS_BLOCK_HAS_FIRST_LETTER_CHILD means that there is an inflow first-letter
541 : // frame among the block's descendants. If there is a floating first-letter
542 : // frame, or the block has first-letter style but has no first letter, this
543 : // bit is not set. This bit is set on the first continuation only.
544 0 : FRAME_STATE_BIT(Block, 63, NS_BLOCK_HAS_FIRST_LETTER_CHILD)
545 :
546 :
547 : // == Frame state bits that apply to bullet frames ============================
548 :
549 0 : FRAME_STATE_GROUP(Bullet, nsBulletFrame)
550 :
551 0 : FRAME_STATE_BIT(Block, 62, BULLET_FRAME_HAS_FONT_INFLATION)
552 0 : FRAME_STATE_BIT(Block, 63, BULLET_FRAME_IMAGE_LOADING)
553 :
554 :
555 : // == Frame state bits that apply to scroll frames ============================
556 :
557 0 : FRAME_STATE_GROUP(Scroll, nsIScrollableFrame)
558 :
559 : // When set, the next scroll operation on the scrollframe will invalidate its
560 : // entire contents. Useful for text-overflow.
561 : // This bit is cleared after each time the scrollframe is scrolled. Whoever
562 : // needs to set it should set it again on each paint.
563 0 : FRAME_STATE_BIT(Scroll, 20, NS_SCROLLFRAME_INVALIDATE_CONTENTS_ON_SCROLL)
564 :
565 :
566 : // == Frame state bits that apply to image frames =============================
567 :
568 0 : FRAME_STATE_GROUP(Image, nsImageFrame)
569 :
570 0 : FRAME_STATE_BIT(Image, 20, IMAGE_SIZECONSTRAINED)
571 0 : FRAME_STATE_BIT(Image, 21, IMAGE_GOTINITIALREFLOW)
572 :
573 :
574 : // == Frame state bits that apply to inline frames ============================
575 :
576 0 : FRAME_STATE_GROUP(Inline, nsInlineFrame)
577 :
578 : /** In Bidi inline start (or end) margin/padding/border should be applied to
579 : * first (or last) frame (or a continuation frame).
580 : * This state value shows if this frame is first (or last) continuation
581 : * or not.
582 : */
583 :
584 0 : FRAME_STATE_BIT(Inline, 21, NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET)
585 0 : FRAME_STATE_BIT(Inline, 22, NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST)
586 0 : FRAME_STATE_BIT(Inline, 23, NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST)
587 : // nsRubyTextFrame inherits from nsInlineFrame
588 :
589 :
590 : // == Frame state bits that apply to ruby text frames =========================
591 :
592 0 : FRAME_STATE_GROUP(RubyText, nsRubyTextFrame)
593 :
594 : // inherits from nsInlineFrame
595 0 : FRAME_STATE_BIT(RubyText, 24, NS_RUBY_TEXT_FRAME_AUTOHIDE)
596 :
597 :
598 : // == Frame state bits that apply to ruby text container frames ===============
599 :
600 0 : FRAME_STATE_GROUP(RubyTextContainer, nsRubyTextContainerFrame)
601 :
602 0 : FRAME_STATE_BIT(RubyTextContainer, 20, NS_RUBY_TEXT_CONTAINER_IS_SPAN)
603 :
604 :
605 : // == Frame state bits that apply to placeholder frames =======================
606 :
607 0 : FRAME_STATE_GROUP(Placeholder, nsPlaceholderFrame)
608 :
609 : // Frame state bits that are used to keep track of what this is a
610 : // placeholder for.
611 :
612 0 : FRAME_STATE_BIT(Placeholder, 20, PLACEHOLDER_FOR_FLOAT)
613 0 : FRAME_STATE_BIT(Placeholder, 21, PLACEHOLDER_FOR_ABSPOS)
614 0 : FRAME_STATE_BIT(Placeholder, 22, PLACEHOLDER_FOR_FIXEDPOS)
615 0 : FRAME_STATE_BIT(Placeholder, 23, PLACEHOLDER_FOR_POPUP)
616 0 : FRAME_STATE_BIT(Placeholder, 24, PLACEHOLDER_FOR_TOPLAYER)
617 :
618 : // This bit indicates that the out-of-flow frame's static position needs to be
619 : // determined using the CSS Box Alignment properties
620 : // ([align,justify]-[self,content]). When this is set, the placeholder frame's
621 : // position doesn't represent the static position, as it usually would --
622 : // rather, it represents the logical start corner of the alignment containing
623 : // block. Then, after we've determined the out-of-flow frame's size, we can
624 : // resolve the actual static position using the alignment properties.
625 0 : FRAME_STATE_BIT(Placeholder, 25, PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN)
626 :
627 : // Are all earlier frames on the same block line empty?
628 0 : FRAME_STATE_BIT(Placeholder, 26, PLACEHOLDER_LINE_IS_EMPTY_SO_FAR)
629 : // Does the above bit have a valid value?
630 0 : FRAME_STATE_BIT(Placeholder, 27, PLACEHOLDER_HAVE_LINE_IS_EMPTY_SO_FAR)
631 :
632 : // == Frame state bits that apply to table cell frames ========================
633 :
634 0 : FRAME_STATE_GROUP(TableCell, nsTableCellFrame)
635 :
636 0 : FRAME_STATE_BIT(TableCell, 28, NS_TABLE_CELL_HAS_PCT_OVER_BSIZE)
637 0 : FRAME_STATE_BIT(TableCell, 29, NS_TABLE_CELL_HAD_SPECIAL_REFLOW)
638 0 : FRAME_STATE_BIT(TableCell, 31, NS_TABLE_CELL_CONTENT_EMPTY)
639 :
640 :
641 : // == Frame state bits that apply to table column frames ======================
642 :
643 : // Bits 28-31 on nsTableColFrames are used to store the column type.
644 :
645 :
646 : // == Frame state bits that apply to table column group frames ================
647 :
648 : // Bits 30-31 on nsTableColGroupFrames are used to store the column type.
649 :
650 :
651 : // == Frame state bits that apply to table rows and table row group frames ====
652 :
653 0 : FRAME_STATE_GROUP(TableRowAndRowGroup, nsTableRowFrame)
654 0 : FRAME_STATE_GROUP(TableRowAndRowGroup, nsTableRowGroupFrame)
655 :
656 : // see nsTableRowGroupFrame::InitRepeatedFrame
657 0 : FRAME_STATE_BIT(TableRowAndRowGroup, 28, NS_REPEATED_ROW_OR_ROWGROUP)
658 :
659 :
660 : // == Frame state bits that apply to table row frames =========================
661 :
662 0 : FRAME_STATE_GROUP(TableRow, nsTableRowFrame)
663 :
664 : // Indicates whether this row has any cells that have
665 : // non-auto-bsize and rowspan=1
666 0 : FRAME_STATE_BIT(TableRow, 29, NS_ROW_HAS_CELL_WITH_STYLE_BSIZE)
667 :
668 0 : FRAME_STATE_BIT(TableRow, 30, NS_TABLE_ROW_HAS_UNPAGINATED_BSIZE)
669 :
670 :
671 : // == Frame state bits that apply to table row group frames ===================
672 :
673 0 : FRAME_STATE_GROUP(TableRowGroup, nsTableRowGroupFrame)
674 :
675 0 : FRAME_STATE_BIT(TableRowGroup, 27, NS_ROWGROUP_HAS_ROW_CURSOR)
676 0 : FRAME_STATE_BIT(TableRowGroup, 30, NS_ROWGROUP_HAS_STYLE_BSIZE)
677 :
678 : // thead or tfoot should be repeated on every printed page
679 0 : FRAME_STATE_BIT(TableRowGroup, 31, NS_ROWGROUP_REPEATABLE)
680 :
681 0 : FRAME_STATE_GROUP(Table, nsTableFrame)
682 :
683 0 : FRAME_STATE_BIT(Table, 28, NS_TABLE_PART_HAS_FIXED_BACKGROUND)
684 :
685 : #ifdef DEFINED_FRAME_STATE_GROUP
686 : #undef DEFINED_FRAME_STATE_GROUP
687 : #undef FRAME_STATE_GROUP
688 : #endif
689 :
690 : #ifdef DEFINED_FRAME_STATE_BIT
691 : #undef DEFINED_FRAME_STATE_BIT
692 : #undef FRAME_STATE_BIT
693 : #endif
|
