Struct RenderWrap 

pub struct RenderWrap { /* private fields */ }

Displays its children in multiple horizontal or vertical runs.

A RenderWrap lays out each child and attempts to place the child adjacent to the previous child in the main axis, given by direction, leaving spacing space in between. If there is not enough space to fit the child, RenderWrap creates a new run adjacent to the existing children in the cross axis.

After all the children have been allocated to runs, the children within the runs are positioned according to the alignment in the main axis and according to the cross_axis_alignment in the cross axis.

The runs themselves are then positioned in the cross axis according to the run_spacing and run_alignment.

Implementations

impl RenderWrap

pub fn new(app: &mut App) -> RenderHandle<RenderWrap>

Creates a wrap render object.

By default, the wrap layout is horizontal and both the children and the runs are aligned to the start. Add children with add or add_all; Dart’s constructor takes them, and its other named arguments are the setters.

pub fn direction(self: RenderHandle<Self>, app: &App) -> Axis

The direction to use as the main axis.

For example, if direction is Axis::Horizontal, the default, the children are placed adjacent to one another in a horizontal run until the available horizontal space is consumed, at which point a subsequent children are placed in a new run vertically adjacent to the previous run.

pub fn set_direction(self: RenderHandle<Self>, app: &mut App, value: Axis)

Sets direction.

pub fn alignment(self: RenderHandle<Self>, app: &App) -> WrapAlignment

How the children within a run should be placed in the main axis.

For example, if alignment is WrapAlignment::Center, the children in each run are grouped together in the center of their run in the main axis.

Defaults to WrapAlignment::Start.

See also:

• run_alignment, which controls how the runs are placed relative to each other in the cross axis.
• cross_axis_alignment, which controls how the children within each run are placed relative to each other in the cross axis.

pub fn set_alignment( self: RenderHandle<Self>, app: &mut App, value: WrapAlignment, )

Sets alignment.

pub fn spacing(self: RenderHandle<Self>, app: &App) -> f64

How much space to place between children in a run in the main axis.

For example, if spacing is 10.0, the children will be spaced at least 10.0 logical pixels apart in the main axis.

If there is additional free space in a run (e.g., because the wrap has a minimum size that is not filled or because some runs are longer than others), the additional free space will be allocated according to the alignment.

Defaults to 0.0.

pub fn set_spacing(self: RenderHandle<Self>, app: &mut App, value: f64)

Sets spacing.

pub fn run_alignment(self: RenderHandle<Self>, app: &App) -> WrapAlignment

How the runs themselves should be placed in the cross axis.

For example, if run_alignment is WrapAlignment::Center, the runs are grouped together in the center of the overall RenderWrap in the cross axis.

Defaults to WrapAlignment::Start.

See also:

• alignment, which controls how the children within each run are placed relative to each other in the main axis.
• cross_axis_alignment, which controls how the children within each run are placed relative to each other in the cross axis.

pub fn set_run_alignment( self: RenderHandle<Self>, app: &mut App, value: WrapAlignment, )

Sets run_alignment.

pub fn run_spacing(self: RenderHandle<Self>, app: &App) -> f64

How much space to place between the runs themselves in the cross axis.

For example, if run_spacing is 10.0, the runs will be spaced at least 10.0 logical pixels apart in the cross axis.

If there is additional free space in the overall RenderWrap (e.g., because the wrap has a minimum size that is not filled), the additional free space will be allocated according to the run_alignment.

Defaults to 0.0.

pub fn set_run_spacing(self: RenderHandle<Self>, app: &mut App, value: f64)

Sets run_spacing.

pub fn cross_axis_alignment( self: RenderHandle<Self>, app: &App, ) -> WrapCrossAlignment

How the children within a run should be aligned relative to each other in the cross axis.

For example, if this is set to WrapCrossAlignment::End, and the direction is Axis::Horizontal, then the children within each run will have their bottom edges aligned to the bottom edge of the run.

Defaults to WrapCrossAlignment::Start.

See also:

• alignment, which controls how the children within each run are placed relative to each other in the main axis.
• run_alignment, which controls how the runs are placed relative to each other in the cross axis.

pub fn set_cross_axis_alignment( self: RenderHandle<Self>, app: &mut App, value: WrapCrossAlignment, )

Sets cross_axis_alignment.

pub fn text_direction( self: RenderHandle<Self>, app: &App, ) -> Option<TextDirection>

Determines the order to lay children out horizontally and how to interpret start and end in the horizontal direction.

If the direction is Axis::Horizontal, this controls the order in which children are positioned (left-to-right or right-to-left), and the meaning of the alignment property’s WrapAlignment::Start and WrapAlignment::End values.

If the direction is Axis::Horizontal, and either the alignment is either WrapAlignment::Start or WrapAlignment::End, or there’s more than one child, then the text_direction must not be None.

If the direction is Axis::Vertical, this controls the order in which runs are positioned, the meaning of the run_alignment property’s WrapAlignment::Start and WrapAlignment::End values, as well as the cross_axis_alignment property’s WrapCrossAlignment::Start and WrapCrossAlignment::End values.

If the direction is Axis::Vertical, and either the run_alignment is either WrapAlignment::Start or WrapAlignment::End, the cross_axis_alignment is either WrapCrossAlignment::Start or WrapCrossAlignment::End, or there’s more than one child, then the text_direction must not be None.

pub fn set_text_direction( self: RenderHandle<Self>, app: &mut App, value: Option<TextDirection>, )

Sets text_direction.

pub fn vertical_direction( self: RenderHandle<Self>, app: &App, ) -> VerticalDirection

Determines the order to lay children out vertically and how to interpret start and end in the vertical direction.

If the direction is Axis::Vertical, this controls which order children are painted in (down or up), the meaning of the alignment property’s WrapAlignment::Start and WrapAlignment::End values.

If the direction is Axis::Horizontal, this controls the order in which runs are positioned, the meaning of the run_alignment property’s WrapAlignment::Start and WrapAlignment::End values, as well as the cross_axis_alignment property’s WrapCrossAlignment::Start and WrapCrossAlignment::End values.

pub fn set_vertical_direction( self: RenderHandle<Self>, app: &mut App, value: VerticalDirection, )

Sets vertical_direction.

pub fn clip_behavior(self: RenderHandle<Self>, app: &App) -> Clip

The content will be clipped (or not) according to this option.

Defaults to Clip::None.

pub fn set_clip_behavior(self: RenderHandle<Self>, app: &mut App, value: Clip)

Sets clip_behavior.

Trait Implementations

impl ContainerRenderObjectMixin for RenderWrap

type ChildType = AnyRenderBox

Flutter’s ChildType: the protocol of this render object’s children.

type ParentDataType = WrapParentData

Flutter’s ParentDataType: the parent data this render object installs on its children.

fn container_data( self: RenderHandle<Self>, app: &App, ) -> &ContainerRenderObjectData<AnyRenderBox>

Mixin field access.

fn container_data_mut( self: RenderHandle<Self>, app: &mut App, ) -> &mut ContainerRenderObjectData<AnyRenderBox>

See container_data.

fn child_count(self: RenderHandle<Self>, app: &App) -> usize

The number of children.

fn insert( self: RenderHandle<Self>, app: &mut App, child: Self::ChildType, after: Option<Self::ChildType>, )

Insert child into this render object’s child list after the given child.

fn add(self: RenderHandle<Self>, app: &mut App, child: Self::ChildType)

Append child to the end of this render object’s child list.

fn add_all( self: RenderHandle<Self>, app: &mut App, children: Option<Vec<Self::ChildType>>, )

Add all the children to the end of this render object’s child list.

fn remove(self: RenderHandle<Self>, app: &mut App, child: Self::ChildType)

Remove this child from the child list.

fn remove_all(self: RenderHandle<Self>, app: &mut App)

Remove all their children from this render object’s child list.

fn move_child( self: RenderHandle<Self>, app: &mut App, child: Self::ChildType, after: Option<Self::ChildType>, )

Move the given child in the child list to be after another child.

fn did_attach( self: RenderHandle<Self>, app: &mut App, owner: Handle<PipelineOwner>, )

The body of Flutter’s attach override: attaches every child in the list.

fn did_detach(self: RenderHandle<Self>, app: &mut App)

The body of Flutter’s detach override: detaches every child in the list.

fn redepth_children(self: RenderHandle<Self>, app: &mut App)

Flutter’s redepthChildren: walks the child list.

fn visit_children( self: RenderHandle<Self>, app: &App, visitor: &mut dyn FnMut(AnyRenderObject), )

Flutter’s visitChildren: walks the child list.

fn first_child(self: RenderHandle<Self>, app: &App) -> Option<Self::ChildType>

The first child in the child list.

fn last_child(self: RenderHandle<Self>, app: &App) -> Option<Self::ChildType>

The last child in the child list.

fn child_before( self: RenderHandle<Self>, app: &App, child: Self::ChildType, ) -> Option<Self::ChildType>

The previous child before the given child in the child list.

fn child_after( self: RenderHandle<Self>, app: &App, child: Self::ChildType, ) -> Option<Self::ChildType>

The next child after the given child in the child list.

fn children_as_list(self: RenderHandle<Self>, app: &App) -> Vec<Self::ChildType>

Returns a list containing the children of this render object.

impl RenderBox for RenderWrap

fn render_box_data(self: RenderHandle<Self>, app: &App) -> &RenderBoxData

Mixin field access.

fn render_box_data_mut( self: RenderHandle<Self>, app: &mut App, ) -> &mut RenderBoxData

See render_box_data.

fn setup_parent_data( self: RenderHandle<Self>, app: &mut App, child: AnyRenderObject, )

Installs BoxParentData unless the child already has it.

fn compute_min_intrinsic_width( self: RenderHandle<Self>, app: &mut App, height: f64, ) -> f64

Computes the value returned by get_min_intrinsic_width. Do not call this function directly, instead, call get_min_intrinsic_width.

fn compute_max_intrinsic_width( self: RenderHandle<Self>, app: &mut App, height: f64, ) -> f64

Computes the value returned by get_max_intrinsic_width. Do not call this function directly, instead, call get_max_intrinsic_width.

fn compute_min_intrinsic_height( self: RenderHandle<Self>, app: &mut App, width: f64, ) -> f64

Computes the value returned by get_min_intrinsic_height. Do not call this function directly, instead, call get_min_intrinsic_height.

fn compute_max_intrinsic_height( self: RenderHandle<Self>, app: &mut App, width: f64, ) -> f64

Computes the value returned by get_max_intrinsic_height. Do not call this function directly, instead, call get_max_intrinsic_height.

fn compute_distance_to_actual_baseline( self: RenderHandle<Self>, app: &mut App, baseline: TextBaseline, ) -> Option<f64>

Returns the distance from the y-coordinate of the position of the box to the y-coordinate of the first given baseline in the box’s contents, if any, or None otherwise.

fn compute_dry_baseline( self: RenderHandle<Self>, app: &mut App, constraints: BoxConstraints, baseline: TextBaseline, ) -> Option<f64>

Computes the value returned by get_dry_baseline.

fn compute_dry_layout( self: RenderHandle<Self>, app: &mut App, constraints: BoxConstraints, ) -> Size

Computes the value returned by get_dry_layout. Do not call this function directly, instead, call get_dry_layout.

fn hit_test_children( self: RenderHandle<Self>, app: &mut App, result: &mut BoxHitTestResult<'_>, position: Offset, ) -> bool

Override this method to check whether any children are located at the given position.

fn constraints(self: RenderHandle<Self>, app: &App) -> BoxConstraints

The box constraints most recently supplied by the parent.

fn get_min_intrinsic_width( self: RenderHandle<Self>, app: &mut App, height: f64, ) -> f64

See AnyRenderBox::get_min_intrinsic_width.

fn get_max_intrinsic_width( self: RenderHandle<Self>, app: &mut App, height: f64, ) -> f64

See AnyRenderBox::get_max_intrinsic_width.

fn get_min_intrinsic_height( self: RenderHandle<Self>, app: &mut App, width: f64, ) -> f64

See AnyRenderBox::get_min_intrinsic_height.

fn get_max_intrinsic_height( self: RenderHandle<Self>, app: &mut App, width: f64, ) -> f64

See AnyRenderBox::get_max_intrinsic_height.

fn get_dry_layout( self: RenderHandle<Self>, app: &mut App, constraints: BoxConstraints, ) -> Size

See AnyRenderBox::get_dry_layout.

fn get_dry_baseline( self: RenderHandle<Self>, app: &mut App, constraints: BoxConstraints, baseline: TextBaseline, ) -> Option<f64>

See AnyRenderBox::get_dry_baseline.

fn debug_cannot_compute_dry_layout( self: RenderHandle<Self>, failure: DryLayoutFailure<'_>, )

Called from compute_dry_layout or compute_dry_baseline if this box does not support calculating a dry layout.

fn get_distance_to_baseline( self: RenderHandle<Self>, app: &mut App, baseline: TextBaseline, only_real: bool, ) -> Option<f64>

See AnyRenderBox::get_distance_to_baseline.

fn get_distance_to_actual_baseline( self: RenderHandle<Self>, app: &mut App, baseline: TextBaseline, ) -> Option<f64>

See AnyRenderBox::get_distance_to_actual_baseline.

fn mark_needs_layout(self: RenderHandle<Self>, app: &mut App)

Mark this render object’s layout information as dirty.

fn perform_resize(self: RenderHandle<Self>, app: &mut App)

Updates the box’s size using only the constraints.

fn size(self: RenderHandle<Self>, app: &App) -> Size

The size of this box.

fn apply_paint_transform( self: RenderHandle<Self>, app: &App, child: AnyRenderObject, transform: &mut Matrix4, )

Multiply the transform from the parent’s coordinate system to this box’s coordinate system into the given transform.

fn paint_bounds(self: RenderHandle<Self>, app: &App) -> Rect

An estimate of the bounds within which this render object will paint: the box’s own size.

fn has_size(self: RenderHandle<Self>, app: &App) -> bool

Whether this render object has undergone layout and has a size.

fn handle_event( self: RenderHandle<Self>, app: &mut App, event: &PointerEvent, entry: &BoxHitTestEntry, )

Override this method to handle pointer events that hit this render object.

fn hit_test( self: RenderHandle<Self>, app: &mut App, result: &mut BoxHitTestResult<'_>, position: Offset, ) -> bool

Determines the set of render objects located at the given position.

fn hit_test_self( self: RenderHandle<Self>, _app: &App, _position: Offset, ) -> bool

Override this method if this render object can be hit even if its children were not hit.

fn set_size(self: RenderHandle<Self>, app: &mut App, size: Size)

Sets the size of this box. Call from RenderObject::perform_layout or RenderObject::perform_resize.

fn layout( self: RenderHandle<Self>, app: &mut App, constraints: BoxConstraints, parent_uses_size: bool, )

See AnyRenderBox::layout.

fn as_box(self: RenderHandle<Self>) -> AnyRenderBox

The type-erased RenderBox handle. Free: the vtable is a const, and the id is copied.

fn as_object(self: RenderHandle<Self>) -> AnyRenderObject

The type-erased RenderObject handle, through as_box.

fn adopt_child(self: RenderHandle<Self>, app: &mut App, child: AnyRenderObject)

See AnyRenderObject::adopt_child.

fn drop_child(self: RenderHandle<Self>, app: &mut App, child: AnyRenderObject)

See AnyRenderObject::drop_child.

fn mark_needs_paint(self: RenderHandle<Self>, app: &mut App)

See AnyRenderObject::mark_needs_paint.

fn mark_needs_composited_layer_update(self: RenderHandle<Self>, app: &mut App)

See AnyRenderObject::mark_needs_composited_layer_update.

fn mark_needs_compositing_bits_update(self: RenderHandle<Self>, app: &mut App)

See AnyRenderObject::mark_needs_compositing_bits_update.

fn schedule_initial_layout(self: RenderHandle<Self>, app: &mut App)

See AnyRenderObject::schedule_initial_layout.

fn parent(self: RenderHandle<Self>, app: &App) -> Option<AnyRenderObject>

See AnyRenderObject::parent.

fn owner(self: RenderHandle<Self>, app: &App) -> Option<Handle<PipelineOwner>>

See AnyRenderObject::owner.

fn attached(self: RenderHandle<Self>, app: &App) -> bool

See AnyRenderObject::attached.

fn debug_needs_layout(self: RenderHandle<Self>, app: &App) -> bool

See AnyRenderObject::debug_needs_layout.

impl RenderBoxContainerDefaultsMixin for RenderWrap

fn default_compute_distance_to_first_actual_baseline( self: RenderHandle<Self>, app: &mut App, baseline: TextBaseline, ) -> Option<f64>

Returns the baseline of the first child with a baseline.

fn default_compute_distance_to_highest_actual_baseline( self: RenderHandle<Self>, app: &mut App, baseline: TextBaseline, ) -> Option<f64>

Returns the minimum baseline value among every child.

fn default_hit_test_children( self: RenderHandle<Self>, app: &mut App, result: &mut BoxHitTestResult<'_>, position: Offset, ) -> bool

Performs a hit test on each child by walking the child list backwards.

fn default_paint( self: RenderHandle<Self>, app: &mut App, context: &mut PaintingContext, offset: Offset, )

Paints each child by walking the child list forwards.

impl RenderObject for RenderWrap

fn paint( self: RenderHandle<Self>, app: &mut App, context: &mut PaintingContext, offset: Offset, )

Paints the children, clipping them to this wrap when they overflow it and clip_behavior asks for it.

fn dispose(self: RenderHandle<Self>, app: &mut App)

Flutter’s dispose: drop the clip layer handle, then super.dispose().

fn render_object_data(self: RenderHandle<Self>, app: &App) -> &RenderObjectData

Mixin field access.

fn render_object_data_mut( self: RenderHandle<Self>, app: &mut App, ) -> &mut RenderObjectData

See render_object_data.

fn perform_layout(self: RenderHandle<Self>, app: &mut App)

Do the work of computing the layout for this render object.

fn visit_children( self: RenderHandle<Self>, app: &App, visitor: &mut dyn FnMut(AnyRenderObject), )

Calls visitor for each immediate child.

fn did_attach( self: RenderHandle<Self>, app: &mut App, owner: Handle<PipelineOwner>, )

The body of Flutter’s attach override after super.attach(owner); the base body has already run. The default attaches the children reported by visit_children.

fn did_detach(self: RenderHandle<Self>, app: &mut App)

The body of Flutter’s detach override after super.detach(). The default detaches the children reported by visit_children.

fn redepth_children(self: RenderHandle<Self>, app: &mut App)

Adjusts the depth of each child reported by visit_children.

fn as_render_object(self: RenderHandle<Self>, app: &App) -> AnyRenderObject

Dart’s implicit upcast of a concrete render object to RenderObject: this object’s type-erased handle, through the vtable the protocol recorded when it created it.

fn perform_resize(self: RenderHandle<Self>, _app: &mut App)

Updates the render object’s size using only the constraints.

fn setup_parent_data( self: RenderHandle<Self>, app: &mut App, child: AnyRenderObject, )

Sets up parent data for child if it has none.

fn sized_by_parent(self: RenderHandle<Self>, _app: &App) -> bool

Whether the constraints are the only input to the sizing algorithm.

fn apply_paint_transform( self: RenderHandle<Self>, app: &App, child: AnyRenderObject, transform: &mut Matrix4, )

Applies the transform that would be applied when painting the given child to the given matrix.

fn is_repaint_boundary(self: RenderHandle<Self>, _app: &App) -> bool

Whether this render object repaints separately from its parent.

fn always_needs_compositing(self: RenderHandle<Self>, _app: &App) -> bool

Whether this render object always needs compositing.

fn mouse_tracker_annotation( self: RenderHandle<Self>, _app: &App, ) -> Option<MouseTrackerAnnotation>

Dart’s this is MouseTrackerAnnotation: the annotation this render object implements, read live each time the mouse tracker consults it. None for a render object that is not an annotation, which is the default.

fn update_composited_layer( self: RenderHandle<Self>, app: &mut App, old_layer: Option<AnyOffsetLayer>, ) -> AnyOffsetLayer

Update the composited layer owned by this render object.

fn show_on_screen( self: RenderHandle<Self>, app: &mut App, descendant: Option<AnyRenderObject>, rect: Option<Rect>, duration: Duration, curve: Rc<dyn Curve>, )

Attempt to make (a portion of) this or a descendant RenderObject visible on screen.

fn interface(self: RenderHandle<Self>, id: TypeId) -> Option<Box<dyn Any>>

Dart’s object is RenderAbstractViewport for any interface: the erased handle of the interface id names, if this type implements it.