Struct layout_2013::inline::InlineFlow

#[repr(C)]
pub struct InlineFlow {
    pub base: BaseFlow,
    pub fragments: InlineFragments,
    pub lines: Vec<Line>,
    pub minimum_line_metrics: LineMetrics,
    pub first_line_indentation: Au,
}

Flows for inline layout.

Fields

base: BaseFlow

Data common to all flows.

fragments: InlineFragments

A vector of all inline fragments. Several fragments may correspond to one node/element.

lines: Vec<Line>

A vector of ranges into fragments that represents line positions. These ranges are disjoint and are the result of inline layout. This also includes some metadata used for positioning lines.

minimum_line_metrics: LineMetrics

The minimum metrics for each line, as specified by the line height and font style.

first_line_indentation: Au

The amount of indentation to use on the first line. This is determined by our block parent (because percentages are relative to the containing block, and we aren’t in a position to compute things relative to our parent’s containing block).

Implementations

impl InlineFlow

pub fn from_fragments( fragments: InlineFragments, writing_mode: WritingMode, ) -> InlineFlow

fn set_inline_fragment_positions( fragments: &mut InlineFragments, line: &Line, line_align: TextAlign, indentation: Au, is_last_line: bool, )

Sets fragment positions in the inline direction based on alignment for one line. This performs text justification if mandated by the style.

fn justify_inline_fragments( fragments: &mut InlineFragments, line: &Line, slack_inline_size: Au, )

Justifies the given set of inline fragments, distributing the slack_inline_size among all of them according to the value of text-justify.

fn set_block_fragment_positions( fragments: &mut InlineFragments, line: &Line, minimum_line_metrics: &LineMetrics, layout_context: &LayoutContext<'_>, )

Sets final fragment positions in the block direction for one line.

pub fn minimum_line_metrics( &self, font_context: &FontContext, style: &ComputedValues, ) -> LineMetrics

Computes the minimum metrics for each line. This is done during flow construction.

style is the style of the block.

pub fn minimum_line_metrics_for_fragments( fragments: &[Fragment], font_context: &FontContext, style: &ComputedValues, ) -> LineMetrics

Computes the minimum line metrics for the given fragments. This is typically done during flow construction.

style is the style of the block that these fragments belong to.

fn update_restyle_damage(&mut self)

fn containing_block_range_for_flow_surrounding_fragment_at_index( &self, fragment_index: FragmentIndex, ) -> Range<FragmentIndex>

fn containing_block_range_for_flow( &self, opaque_flow: OpaqueFlow, ) -> Range<FragmentIndex>

pub fn baseline_offset_of_last_line(&self) -> Option<Au>

fn last_line_containing_real_fragments(&self) -> Option<&Line>

fn build_display_list_for_inline_fragment_at_index( &mut self, state: &mut DisplayListBuildState<'_>, index: usize, )

Trait Implementations

impl Debug for InlineFlow

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

Formats the value using the given formatter.

impl Flow for InlineFlow

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

Recursively (top-down) determines the actual inline-size of child contexts and fragments. When called on this context, the context has had its inline-size set by the parent context.

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

Calculate and set the block-size of this flow. See CSS 2.1 § 10.6.1. Note that we do not need to do in-order traversal because the children are always block formatting context.

fn class(&self) -> FlowClass

Returns the class of flow that this is.

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

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

fn compute_stacking_relative_position(&mut self, _: &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, _: 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, _: 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 collect_stacking_contexts( &mut self, state: &mut StackingContextCollectionState, )

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

Phase 5 of reflow: builds display lists.

fn repair_style(&mut self, _: &ServoArc<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 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 contains_positioned_fragments(&self) -> bool

fn contains_relatively_positioned_fragments(&self) -> bool

fn generated_containing_block_size( &self, for_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 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_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 as_flex(&self) -> &FlexFlow

If this is a flex flow, returns the underlying object. 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 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 is_absolute_containing_block(&self) -> bool

Returns true if this is an absolute containing block.

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

impl Serialize for InlineFlow

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 InlineFlow