Struct layout_2013::table_row::TableRowFlow

#[repr(C)]
pub struct TableRowFlow {
    pub block_flow: BlockFlow,
    pub cell_intrinsic_inline_sizes: Vec<CellIntrinsicInlineSize>,
    pub column_computed_inline_sizes: Vec<ColumnComputedInlineSize>,
    pub incoming_rowspan: Vec<u32>,
    pub spacing: T,
    pub table_writing_mode: WritingMode,
    pub preliminary_collapsed_borders: CollapsedBordersForRow,
    pub final_collapsed_borders: CollapsedBordersForRow,
    pub collapsed_border_spacing: CollapsedBorderSpacingForRow,
}

A single row of a table.

Fields

block_flow: BlockFlow

Fields common to all block flows.

cell_intrinsic_inline_sizes: Vec<CellIntrinsicInlineSize>

Information about the intrinsic inline-sizes of each cell.

column_computed_inline_sizes: Vec<ColumnComputedInlineSize>

Information about the computed inline-sizes of each column.

incoming_rowspan: Vec<u32>

The number of remaining rows spanned by cells in previous rows, indexed by column.

Columns that are not included in this vector have the default rowspan of “1”. If there are no cells with rowspan != 1 in previous rows, this vector may be empty.

spacing: T

The spacing for this row, propagated down from the table during the inline-size assignment phase.

table_writing_mode: WritingMode

The direction of the columns, propagated down from the table during the inline-size assignment phase.

preliminary_collapsed_borders: CollapsedBordersForRow

Information about the borders for each cell that we bubble up to our parent. This is only computed if border-collapse is collapse.

final_collapsed_borders: CollapsedBordersForRow

Information about the borders for each cell, post-collapse. This is only computed if border-collapse is collapse.

collapsed_border_spacing: CollapsedBorderSpacingForRow

The computed cell spacing widths post-collapse.

Implementations

impl TableRowFlow

pub fn from_fragment(fragment: Fragment) -> TableRowFlow

pub fn compute_block_size_table_row_base( &mut self, layout_context: &LayoutContext<'_>, incoming_rowspan_data: &mut Vec<Au>, border_info: &[TableRowSizeData], row_index: usize, ) -> Au

Compute block-size for table-row flow.

TODO(pcwalton): This doesn’t handle floats and positioned elements right.

Returns the block size

pub fn assign_block_size_to_self_and_children( &mut self, sizes: &[TableRowSizeData], index: usize, )

pub fn populate_collapsed_border_spacing<'a, I>( &mut self, collapsed_inline_direction_border_widths_for_table: &[Au], collapsed_block_direction_border_widths_for_table: &mut Peekable<I>, )

where I: Iterator<Item = &'a Au>,

Trait Implementations

impl Debug for TableRowFlow

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

Formats the value using the given formatter.

impl Flow for TableRowFlow

fn bubble_inline_sizes(&mut self)

Recursively (bottom-up) determines the context’s preferred and minimum inline-sizes. When called on this context, all child contexts have had their min/pref inline-sizes set. This function must decide min/pref inline-sizes based on child context inline-sizes and dimensions of any fragments it is responsible for flowing. Min/pref inline-sizes set by this function are used in automatic table layout calculation. The specified column inline-sizes of children cells are used in fixed table layout calculation.

fn class(&self) -> FlowClass

Returns the class of flow that this is.

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_block(&mut self) -> &mut BlockFlow

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

fn as_block(&self) -> &BlockFlow

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

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

Pass 2 of reflow: computes inline-size.

fn assign_block_size(&mut self, _: &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 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, _: &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 print_extra_flow_children(&self, print_tree: &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 as_flex(&self) -> &FlexFlow

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

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_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 place_float_if_applicable(&mut self)

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

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 mark_as_root(&mut self)

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

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 clipping_and_scrolling(&self) -> ClippingAndScrolling

impl Serialize for TableRowFlow

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl HasBaseFlow for TableRowFlow