Struct layout_2013::flex::FlexFlow

#[repr(C)]
pub struct FlexFlow {
    block_flow: BlockFlow,
    main_mode: Direction,
    available_main_size: AxisSize,
    available_cross_size: AxisSize,
    lines: Vec<FlexLine>,
    items: Vec<FlexItem>,
    main_reverse: bool,
    is_wrappable: bool,
    cross_reverse: bool,
}

A block with the CSS display property equal to flex.

Fields

block_flow: BlockFlow

Data common to all block flows.

main_mode: Direction

The logical axis which the main axis will be parallel with. The cross axis will be parallel with the opposite logical axis.

available_main_size: AxisSize

The available main axis size

available_cross_size: AxisSize

The available cross axis size

lines: Vec<FlexLine>

List of flex lines in the container.

items: Vec<FlexItem>

List of flex-items that belong to this flex-container

main_reverse: bool

True if the flex-direction is *-reversed

is_wrappable: bool

True if this flex container can be multiline.

cross_reverse: bool

True if the cross direction is reversed.

Implementations

impl FlexFlow

pub fn from_fragment( fragment: Fragment, flotation: Option<FloatKind>, ) -> FlexFlow

pub fn main_mode(&self) -> Direction

fn get_flex_line(&mut self, container_size: Au) -> Option<FlexLine>

Returns a line start after the last item that is already in a line. Note that when the container main size is infinite(i.e. A column flexbox with auto height), we do not need to do flex resolving and this can be considered as a fast-path, so the ‘container_size’ param does not need to be ‘None’. A line has to contain at least one item; (except this) if the container can be multi-line the sum of outer main size of items should be less than the container size; a line should be filled by items as much as possible. After been collected in a line a item should have its main sizes initialized.

fn inline_mode_bubble_inline_sizes(&mut self)

fn block_mode_bubble_inline_sizes(&mut self)

fn block_mode_assign_inline_sizes( &mut self, _layout_context: &LayoutContext<'_>, inline_start_content_edge: Au, inline_end_content_edge: Au, content_inline_size: Au, )

fn inline_mode_assign_inline_sizes( &mut self, layout_context: &LayoutContext<'_>, inline_start_content_edge: Au, _inline_end_content_edge: Au, content_inline_size: Au, )

fn block_mode_assign_block_size(&mut self)

fn inline_mode_assign_block_size(&mut self, layout_context: &LayoutContext<'_>)

Trait Implementations

impl Debug for FlexFlow

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Flow for FlexFlow

fn class(&self) -> FlowClass

Returns the class of flow that this is.

fn as_flex(&self) -> &FlexFlow

If this is a flex flow, returns the underlying object. Fails otherwise.

fn as_block(&self) -> &BlockFlow

If this is a block flow, returns the underlying object. Fails otherwise.

fn as_mut_block(&mut self) -> &mut BlockFlow

If this is a block flow, returns the underlying object, borrowed mutably. Fails otherwise.

fn mark_as_root(&mut self)

Marks this flow as the root flow. The default implementation is a no-op.

fn bubble_inline_sizes(&mut self)

Pass 1 of reflow: computes minimum and preferred inline-sizes.

fn assign_inline_sizes(&mut self, layout_context: &LayoutContext<'_>)

Pass 2 of reflow: computes inline-size.

fn assign_block_size(&mut self, layout_context: &LayoutContext<'_>)

Pass 3a of reflow: computes block-size.

fn compute_stacking_relative_position( &mut self, layout_context: &LayoutContext<'_>, )

Phase 4 of reflow: Compute the stacking-relative position (origin of the content box, in coordinates relative to the nearest ancestor stacking context).

fn place_float_if_applicable<'a>(&mut self)

If this is a float, places it. The default implementation does nothing.

fn update_late_computed_inline_position_if_necessary( &mut self, inline_position: Au, )

Updates the inline position of a child flow during the assign-height traversal. At present, this is only used for absolutely-positioned inline-blocks.

fn update_late_computed_block_position_if_necessary( &mut self, block_position: Au, )

Updates the block position of a child flow during the assign-height traversal. At present, this is only used for absolutely-positioned inline-blocks.

fn build_display_list(&mut self, state: &mut DisplayListBuildState<'_>)

Phase 5 of reflow: builds display lists.

fn collect_stacking_contexts( &mut self, state: &mut StackingContextCollectionState, )

fn repair_style(&mut self, new_style: &Arc<ComputedValues>)

Attempts to perform incremental fixup of this flow by replacing its fragment’s style with the new style. This can only succeed if the flow has exactly one fragment.

fn compute_overflow(&self) -> Overflow

Returns the union of all overflow rects of all of this flow’s fragments.

fn contains_roots_of_absolute_flow_tree(&self) -> bool

Returns true if this flow contains fragments that are roots of an absolute flow tree.

fn is_absolute_containing_block(&self) -> bool

Returns true if this is an absolute containing block.

fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au>

Return the size of the containing block generated by this flow for the absolutely- positioned descendant referenced by for_flow. For block flows, this is the padding box.

fn iterate_through_fragment_border_boxes( &self, iterator: &mut dyn FragmentBorderBoxIterator, level: i32, stacking_context_position: &Point2D<Au>, )

Iterates through border boxes of all of this flow’s fragments. Level provides a zero based index indicating the current depth of the flow tree during fragment iteration.

fn mutate_fragments(&mut self, mutator: &mut dyn FnMut(&mut Fragment))

Mutably iterates through fragments in this flow.

fn as_inline(&self) -> &InlineFlow

If this is an inline flow, returns the underlying object. Fails otherwise.

fn as_mut_inline(&mut self) -> &mut InlineFlow

If this is an inline flow, returns the underlying object, borrowed mutably. Fails otherwise.

fn as_table_wrapper(&self) -> &TableWrapperFlow

If this is a table wrapper flow, returns the underlying object. Fails otherwise.

fn as_mut_table(&mut self) -> &mut TableFlow

If this is a table flow, returns the underlying object, borrowed mutably. Fails otherwise.

fn as_table(&self) -> &TableFlow

If this is a table flow, returns the underlying object. Fails otherwise.

fn as_mut_table_colgroup(&mut self) -> &mut TableColGroupFlow

If this is a table colgroup flow, returns the underlying object, borrowed mutably. Fails otherwise.

fn as_table_colgroup(&self) -> &TableColGroupFlow

If this is a table colgroup flow, returns the underlying object. Fails otherwise.

fn as_mut_table_rowgroup(&mut self) -> &mut TableRowGroupFlow

If this is a table rowgroup flow, returns the underlying object, borrowed mutably. Fails otherwise.

fn as_table_rowgroup(&self) -> &TableRowGroupFlow

If this is a table rowgroup flow, returns the underlying object. Fails otherwise.

fn as_mut_table_row(&mut self) -> &mut TableRowFlow

If this is a table row flow, returns the underlying object, borrowed mutably. Fails otherwise.

fn as_table_row(&self) -> &TableRowFlow

If this is a table row flow, returns the underlying object. Fails otherwise.

fn as_mut_table_cell(&mut self) -> &mut TableCellFlow

If this is a table cell flow, returns the underlying object, borrowed mutably. Fails otherwise.

fn as_table_cell(&self) -> &TableCellFlow

If this is a table cell flow, returns the underlying object. Fails otherwise.

fn fragment( &mut self, layout_context: &LayoutContext<'_>, _fragmentation_context: Option<FragmentationContext>, ) -> Option<Arc<dyn Flow>>

Like assign_block_size, but is recurses explicitly into descendants. Fit as much content as possible within available_block_size. If that’s not all of it, truncate the contents of self and return a new flow similar to self with the rest of the content.

fn assign_block_size_for_inorder_child_if_necessary( &mut self, layout_context: &LayoutContext<'_>, parent_thread_id: u8, _content_box: LogicalRect<Au>, ) -> bool

Assigns block-sizes in-order; or, if this is a float, places the float. The default implementation simply assigns block-sizes if this flow might have floats in. Returns true if it was determined that this child might have had floats in or false otherwise.

fn has_non_invertible_transform_or_zero_scale(&self) -> bool

fn get_overflow_in_parent_coordinates(&self) -> Overflow

fn store_overflow(&mut self, _: &LayoutContext<'_>)

CSS Section 11.1 This is the union of rectangles of the flows for which we define the Containing Block.

fn is_root(&self) -> bool

fn positioning(&self) -> Position

The ‘position’ property of this flow.

fn is_fixed(&self) -> bool

Return true if this flow has position ‘fixed’.

fn contains_positioned_fragments(&self) -> bool

fn contains_relatively_positioned_fragments(&self) -> bool

fn print_extra_flow_children(&self, _: &mut PrintTree)

Print any extra children (such as fragments) contained in this Flow for debugging purposes. Any items inserted into the tree will become children of this flow.

fn clipping_and_scrolling(&self) -> ClippingAndScrolling

impl Serialize for FlexFlow

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl HasBaseFlow for FlexFlow