Struct Walk

pub struct Walk {
    pub abs_pos: Option<DVec2>,
    pub margin: Margin,
    pub width: Size,
    pub height: Size,
}

Fields

abs_pos: Option<DVec2>

margin: Margin

width: Size

height: Size

Implementations

impl Walk

pub fn empty() -> Walk

pub fn size(w: Size, h: Size) -> Walk

pub fn abs_rect(rect: Rect) -> Walk

pub fn fixed(w: f64, h: f64) -> Walk

pub fn fixed_size(size: DVec2) -> Walk

pub fn fit() -> Walk

pub fn fill() -> Walk

pub fn fill_fit() -> Walk

pub fn with_abs_pos(self, v: DVec2) -> Walk

pub fn with_margin_all(self, v: f64) -> Walk

pub fn with_margin_top(self, v: f64) -> Walk

pub fn with_margin_right(self, v: f64) -> Walk

pub fn with_margin_bottom(self, v: f64) -> Walk

pub fn with_margin_left(self, v: f64) -> Walk

pub fn with_margin(self, v: Margin) -> Walk

pub fn with_add_padding(self, v: Padding) -> Walk

Trait Implementations

impl Clone for Walk

fn clone(&self) -> Walk

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Walk

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

Formats the value using the given formatter.

impl Default for Walk

fn default() -> Walk

Returns the “default value” for a type.

impl LiveApply for Walk

fn apply( &mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, start_index: usize, nodes: &[LiveNode], ) -> usize

fn apply_over(&mut self, cx: &mut Cx, nodes: &[LiveNode])

impl LiveApplyReset for Walk

fn apply_reset( &mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, start_index: usize, nodes: &[LiveNode], )

impl LiveApplyValue for Walk

fn apply_value( &mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> usize

impl LiveHook for Walk

fn apply_value_unknown( &mut self, cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> usize

fn skip_apply_animator( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], ) -> bool

fn apply_value_instance( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> usize

fn skip_apply( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], ) -> Option<usize>

fn before_apply( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], )

fn after_apply( &mut self, _cx: &mut Cx, _apply: &mut Apply<'_, '_, '_>, _index: usize, _nodes: &[LiveNode], )

fn after_apply_from(&mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>)

fn after_new_from_doc(&mut self, _cx: &mut Cx)

fn after_update_from_doc(&mut self, _cx: &mut Cx)

fn after_apply_from_doc(&mut self, _cx: &mut Cx)

fn after_new_before_apply(&mut self, _cx: &mut Cx)

impl LiveHookDeref for Walk

fn deref_before_apply( &mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], )

fn deref_after_apply( &mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], )

impl LiveNew for Walk

fn live_type_info(cx: &mut Cx) -> LiveTypeInfo

fn live_design_with(cx: &mut Cx)

fn new(cx: &mut Cx) -> Walk

fn new_apply( cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> Self

where Self: Sized,

fn new_apply_over(cx: &mut Cx, nodes: &[LiveNode]) -> Self

where Self: Sized,

fn new_apply_mut_index( cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: &mut usize, nodes: &[LiveNode], ) -> Self

where Self: Sized,

fn new_from_ptr(cx: &mut Cx, live_ptr: Option<LivePtr>) -> Self

where Self: Sized,

fn update_from_ptr(&mut self, cx: &mut Cx, live_ptr: Option<LivePtr>)

fn update_from_ptr_with_scope( &mut self, cx: &mut Cx, live_ptr: Option<LivePtr>, scope: &mut Scope<'_, '_>, )

fn new_from_ptr_with_scope( cx: &mut Cx, live_ptr: Option<LivePtr>, scope: &mut Scope<'_, '_>, ) -> Self

where Self: Sized,

fn new_main(cx: &mut Cx) -> Option<Self>

where Self: Sized,

fn register_main_module(cx: &mut Cx)

fn update_main(&mut self, cx: &mut Cx)

fn new_local(cx: &mut Cx) -> Self

where Self: Sized,

fn new_from_module( cx: &mut Cx, module_id: LiveModuleId, id: LiveId, ) -> Option<Self>

where Self: Sized,

fn update_from_module( &mut self, cx: &mut Cx, module_id: LiveModuleId, id: LiveId, )

impl LiveRegister for Walk

fn live_register(_cx: &mut Cx)

impl Copy for Walk