Trait guion::widget::WidgetMut

pub trait WidgetMut<E>: Widget<E> + WBaseMut<E> where
    E: Env + 'static, {
    fn child_mut<'s>(&'s mut self, i: usize) -> Result<ResolvableMut<'s, E>, ()>;
    fn into_child_mut<'w>(
        self: Box<Self>, 
        i: usize
    ) -> Result<ResolvableMut<'w, E>, ()>
    where
        Self: 'w;
    fn childs_mut<'s>(&'s mut self) -> Vec<ResolvableMut<'s, E>>;
    fn into_childs_mut<'w>(self: Box<Self>) -> Vec<ResolvableMut<'w, E>>
    where
        Self: 'w;

    fn message(&mut self, m: E::Message) { ... }
    fn _set_invalid(&mut self, v: bool) { ... }
    fn resolve_mut<'s>(
        &'s mut self, 
        i: E::WidgetPath
    ) -> Result<ResolvableMut<'s, E>, GuionError<E>> { ... }
    fn into_resolve_mut<'w>(
        self: Box<Self>, 
        i: E::WidgetPath
    ) -> Result<ResolvableMut<'w, E>, GuionError<E>>
    where
        Self: 'w,
    { ... }
    fn resolve_child_mut(
        &mut self, 
        sub_path: &E::WidgetPath
    ) -> Result<(usize, E::WidgetPath), GuionError<E>> { ... }
    fn inner_mut(&mut self) -> Option<&mut dyn WidgetMut<E>> { ... }
    fn pass(self) -> Self
    where
        Self: Sized,
    { ... }
    fn debug_type_name_mut(&mut self, dest: &mut Vec<&'static str>) { ... }
    fn debugged_type_name_mut(&mut self) -> Vec<&'static str> { ... }
    fn box_mut<'s>(&'s mut self) -> WidgetRefMut<'s, E> { ... }
    fn box_box_mut<'w>(self: Box<Self>) -> WidgetRefMut<'w, E>
    where
        Self: 'w,
    { ... }
    fn boxed_mut<'w>(self) -> WidgetRefMut<'w, E>
    where
        Self: Sized + 'w,
    { ... }
    fn gen_diag_error_resolve_fail_mut(
        &mut self, 
        sub_path: &E::WidgetPath, 
        op: &'static str
    ) -> GuionError<E> { ... }
}

Mutable Widget

Required methods

fn child_mut<'s>(&'s mut self, i: usize) -> Result<ResolvableMut<'s, E>, ()>

fn into_child_mut<'w>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'w, E>, ()> where
    Self: 'w, 

fn childs_mut<'s>(&'s mut self) -> Vec<ResolvableMut<'s, E>>

👎 Deprecated

fn into_childs_mut<'w>(self: Box<Self>) -> Vec<ResolvableMut<'w, E>> where
    Self: 'w, 

Loading content...

Provided methods

fn message(&mut self, m: E::Message)

An alternative way to pass mutations. See [Widgets::message] and [link::enqueue_message]

fn _set_invalid(&mut self, v: bool)

fn resolve_mut<'s>(
    &'s mut self,
    i: E::WidgetPath
) -> Result<ResolvableMut<'s, E>, GuionError<E>>

Resolve a deep child item by the given relative path

An empty path will resolve to this widget

generally not used directly, but through Widgets::widget

fn into_resolve_mut<'w>(
    self: Box<Self>,
    i: E::WidgetPath
) -> Result<ResolvableMut<'w, E>, GuionError<E>> where
    Self: 'w, 

Resolve a deep child item by the given relative path

An empty path will resolve to this widget

generally not used directly, but through Widgets::widget

fn resolve_child_mut(
    &mut self,
    sub_path: &E::WidgetPath
) -> Result<(usize, E::WidgetPath), GuionError<E>>

To (or through) which child path would the given sub_path resolve?

Returns the child index and the subpath inside the child widget to resolve further

generally not used directly, but through Widgets::widget

fn inner_mut(&mut self) -> Option<&mut dyn WidgetMut<E>>

fn pass(self) -> Self where
    Self: Sized, 

fn debug_type_name_mut(&mut self, dest: &mut Vec<&'static str>)

fn debugged_type_name_mut(&mut self) -> Vec<&'static str>

fn box_mut<'s>(&'s mut self) -> WidgetRefMut<'s, E>

Box mut reference of this widget

fn box_box_mut<'w>(self: Box<Self>) -> WidgetRefMut<'w, E> where
    Self: 'w, 

Move widget into box

fn boxed_mut<'w>(self) -> WidgetRefMut<'w, E> where
    Self: Sized + 'w, 

Move widget into box

fn gen_diag_error_resolve_fail_mut(
    &mut self,
    sub_path: &E::WidgetPath,
    op: &'static str
) -> GuionError<E>

Loading content...

Implementations

impl<E> dyn WidgetMut<E> + '_ where
    E: Env, 

pub fn traitcast_ref<'s, T>(&'s self) -> Result<&'s T, GuionError<E>> where
    Self: Traitcast<T, E>,
    T: ?Sized, 

pub fn try_traitcast_ref<'s, T>(&'s self) -> Result<&'s T, ()> where
    Self: Traitcast<T, E>,
    T: ?Sized, 

pub fn traitcast_mut<'s, T>(&'s mut self) -> Result<&'s mut T, GuionError<E>> where
    Self: TraitcastMut<T, E>,
    T: ?Sized, 

pub fn try_traitcast_mut<'s, T>(&'s mut self) -> Result<&'s mut T, ()> where
    Self: TraitcastMut<T, E>,
    T: ?Sized, 

Trait Implementations

impl<'w, T, E> TraitcastMut<dyn AtomState<E, T> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env,
    T: 'static, 

type DestTypeID = dyn AtomState<E, T>

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, T, E> TraitcastMut<dyn AtomStateMut<E, T> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env,
    T: 'static, 

type DestTypeID = dyn AtomStateMut<E, T>

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn Caption<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn Caption<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn CaptionMut<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn CaptionMut<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn ICheckBox<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn ICheckBox<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn ICheckBoxMut<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn ICheckBoxMut<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn ITextBox<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn ITextBox<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn ITextBoxMut<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn ITextBoxMut<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn Validation<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn Validation<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<'w, E> TraitcastMut<dyn ValidationMut<E> + 'w, E> for dyn WidgetMut<E> + 'w where
    E: Env, 

type DestTypeID = dyn ValidationMut<E> + 'static

unsafe fn _traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, GuionError<E>>

unsafe fn _try_traitcast_mut<'s>(
    senf: &'s mut dyn WidgetMut<E>
) -> Result<&'s mut T, ()>

impl<E> Widget<E> for &(dyn WidgetMut<E> + '_) where
    E: Env, 

fn id(&self) -> E::WidgetID

fn _render(&self, l: Link<'_, E>, r: &mut RenderLink<'_, E>)

RENDER

IMPL

RENDER

USER

generally not called directly, rather through Link::render

fn _event_direct(&self, l: Link<'_, E>, e: &EventCompound<E>) -> EventResp

EVENT

IMPL

EVENT

USER

generally not called directly, rather through Link::event

fn _size(&self, l: Link<'_, E>, e: &EStyle<E>) -> ESize<E>

LAYOUT

IMPL

LAYOUT

USER

generally not called directly, rather through Link::size

fn childs(&self) -> usize

CHILDS

fn childs_ref(&self) -> Vec<Resolvable<'_, E>>

👎 Deprecated

CHILDS

fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w, E>> where
    Self: 'w, 

CHILDS

fn child_bounds(
    &self,
    l: Link<'_, E>,
    b: &Bounds,
    e: &EStyle<E>,
    force: bool
) -> Result<Vec<Bounds>, ()>

LAYOUT

fn focusable(&self) -> bool

If the widget should be focusable

fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath>

👎 Deprecated

CHILDS

fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<'_, E>, GuionError<E>>

RESOLVING

Resolve a deep child item by the given relative path

fn into_resolve<'w>(
    self: Box<Self>,
    i: E::WidgetPath
) -> Result<Resolvable<'w, E>, GuionError<E>> where
    Self: 'w, 

RESOLVING

Resolve a deep child item by the given relative path

fn resolve_child(
    &self,
    p: &E::WidgetPath
) -> Result<(usize, E::WidgetPath), GuionError<E>>

RESOLVING

To (or through) which child path would the given sub_path resolve?

fn trace_bounds(
    &self,
    l: Link<'_, E>,
    i: E::WidgetPath,
    b: &Bounds,
    e: &EStyle<E>,
    force: bool
) -> Result<Bounds, GuionError<E>>

LAYOUT

fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath

👎 Deprecated

RESOLVING

Attach widget’s id to the given parent path

fn resolved_by_path(
    &self,
    sub_path: &E::WidgetPath
) -> Option<ResolvesThruResult<E>>

👎 Deprecated

RESOLVING

Refer WidgetPath::resolves_thru

fn _focus_on_mouse_down(&self) -> bool

fn _tabulate_by_tab(&self) -> bool

fn debug_type_name(&self, dest: &mut Vec<&'static str>)

fn inner(&self) -> Option<&dyn Widget<E>>

fn child(&self, i: usize) -> Result<Resolvable<'_, E>, ()>

CHILDS

fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w, E>, ()> where
    Self: 'w, 

CHILDS

fn box_ref(&self) -> WidgetRef<'_, E>

BOXING

Box reference of this widget immutable. Use WidgetMut::box_mut to box into mutable WidgetRef.

fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w, E> where
    Self: 'w, 

BOXING

Move widget into box immutable. Use WidgetMut::box_box_mut to box into mutable WidgetRef.

fn boxed<'w>(self) -> WidgetRef<'w, E> where
    Self: Sized + 'w, 

BOXING

Move widget into box immutable. Use WidgetMut::boxed_mut to box into mutable WidgetRef.

fn _tabulate_next_child(
    &self,
    _l: Link<'_, E>,
    origin: TabulateNextChildOrigin,
    dir: TabulateDirection
) -> TabulateNextChildResponse

Determines the next child in this widget in the tabulation step

fn _tabulate(
    &self,
    l: Link<'_, E>,
    op: TabulateOrigin<E>,
    dir: TabulateDirection
) -> Result<TabulateResponse<E>, GuionError<E>>

fn innest(&self) -> Option<&dyn Widget<E>>

fn debugged_type_name(&self) -> Vec<&'static str>

fn gen_diag_error_resolve_fail(
    &self,
    sub_path: &E::WidgetPath,
    op: &'static str
) -> GuionError<E>

impl<E> Widget<E> for &mut (dyn WidgetMut<E> + '_) where
    E: Env, 

fn id(&self) -> E::WidgetID

fn _render(&self, l: Link<'_, E>, r: &mut RenderLink<'_, E>)

RENDER

IMPL

RENDER

USER

generally not called directly, rather through Link::render

fn _event_direct(&self, l: Link<'_, E>, e: &EventCompound<E>) -> EventResp

EVENT

IMPL

EVENT

USER

generally not called directly, rather through Link::event

fn _size(&self, l: Link<'_, E>, e: &EStyle<E>) -> ESize<E>

LAYOUT

IMPL

LAYOUT

USER

generally not called directly, rather through Link::size

fn childs(&self) -> usize

CHILDS

fn childs_ref(&self) -> Vec<Resolvable<'_, E>>

👎 Deprecated

CHILDS

fn into_childs<'w>(self: Box<Self>) -> Vec<Resolvable<'w, E>> where
    Self: 'w, 

CHILDS

fn child_bounds(
    &self,
    l: Link<'_, E>,
    b: &Bounds,
    e: &EStyle<E>,
    force: bool
) -> Result<Vec<Bounds>, ()>

LAYOUT

fn focusable(&self) -> bool

If the widget should be focusable

fn child_paths(&self, own_path: E::WidgetPath) -> Vec<E::WidgetPath>

👎 Deprecated

CHILDS

fn resolve(&self, i: E::WidgetPath) -> Result<Resolvable<'_, E>, GuionError<E>>

RESOLVING

Resolve a deep child item by the given relative path

fn into_resolve<'w>(
    self: Box<Self>,
    i: E::WidgetPath
) -> Result<Resolvable<'w, E>, GuionError<E>> where
    Self: 'w, 

RESOLVING

Resolve a deep child item by the given relative path

fn resolve_child(
    &self,
    p: &E::WidgetPath
) -> Result<(usize, E::WidgetPath), GuionError<E>>

RESOLVING

To (or through) which child path would the given sub_path resolve?

fn trace_bounds(
    &self,
    l: Link<'_, E>,
    i: E::WidgetPath,
    b: &Bounds,
    e: &EStyle<E>,
    force: bool
) -> Result<Bounds, GuionError<E>>

LAYOUT

fn in_parent_path(&self, parent: E::WidgetPath) -> E::WidgetPath

👎 Deprecated

RESOLVING

Attach widget’s id to the given parent path

fn resolved_by_path(
    &self,
    sub_path: &E::WidgetPath
) -> Option<ResolvesThruResult<E>>

👎 Deprecated

RESOLVING

Refer WidgetPath::resolves_thru

fn _focus_on_mouse_down(&self) -> bool

fn _tabulate_by_tab(&self) -> bool

fn debug_type_name(&self, dest: &mut Vec<&'static str>)

fn inner(&self) -> Option<&dyn Widget<E>>

fn child(&self, i: usize) -> Result<Resolvable<'_, E>, ()>

CHILDS

fn into_child<'w>(self: Box<Self>, i: usize) -> Result<Resolvable<'w, E>, ()> where
    Self: 'w, 

CHILDS

fn box_ref(&self) -> WidgetRef<'_, E>

BOXING

Box reference of this widget immutable. Use WidgetMut::box_mut to box into mutable WidgetRef.

fn box_box<'w>(self: Box<Self>) -> WidgetRef<'w, E> where
    Self: 'w, 

BOXING

Move widget into box immutable. Use WidgetMut::box_box_mut to box into mutable WidgetRef.

fn boxed<'w>(self) -> WidgetRef<'w, E> where
    Self: Sized + 'w, 

BOXING

Move widget into box immutable. Use WidgetMut::boxed_mut to box into mutable WidgetRef.

fn _tabulate_next_child(
    &self,
    _l: Link<'_, E>,
    origin: TabulateNextChildOrigin,
    dir: TabulateDirection
) -> TabulateNextChildResponse

Determines the next child in this widget in the tabulation step

fn _tabulate(
    &self,
    l: Link<'_, E>,
    op: TabulateOrigin<E>,
    dir: TabulateDirection
) -> Result<TabulateResponse<E>, GuionError<E>>

fn innest(&self) -> Option<&dyn Widget<E>>

fn debugged_type_name(&self) -> Vec<&'static str>

fn gen_diag_error_resolve_fail(
    &self,
    sub_path: &E::WidgetPath,
    op: &'static str
) -> GuionError<E>

impl<E> WidgetMut<E> for &mut (dyn WidgetMut<E> + '_) where
    E: Env, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

CHILDS

fn into_childs_mut<'w>(self: Box<Self>) -> Vec<ResolvableMut<'w, E>> where
    Self: 'w, 

CHILDS

fn _set_invalid(&mut self, v: bool)

fn resolve_mut(
    &mut self,
    i: E::WidgetPath
) -> Result<ResolvableMut<'_, E>, GuionError<E>>

RESOLVING

Resolve a deep child item by the given relative path

fn into_resolve_mut<'w>(
    self: Box<Self>,
    i: E::WidgetPath
) -> Result<ResolvableMut<'w, E>, GuionError<E>> where
    Self: 'w, 

RESOLVING

Resolve a deep child item by the given relative path

fn resolve_child_mut(
    &mut self,
    p: &E::WidgetPath
) -> Result<(usize, E::WidgetPath), GuionError<E>>

RESOLVING

To (or through) which child path would the given sub_path resolve?

fn inner_mut(&mut self) -> Option<&mut dyn WidgetMut<E>>

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

CHILDS

fn into_child_mut<'w>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'w, E>, ()> where
    Self: 'w, 

CHILDS

fn message(&mut self, m: E::Message)

EVENT

An alternative way to pass mutations. See [Widgets::message] and [link::enqueue_message]

fn debug_type_name_mut(&mut self, dest: &mut Vec<&'static str>)

fn box_mut(&mut self) -> WidgetRefMut<'_, E>

BOXING

Box mut reference of this widget

fn box_box_mut<'w>(self: Box<Self>) -> WidgetRefMut<'w, E> where
    Self: 'w, 

BOXING

Move widget into box

fn boxed_mut<'w>(self) -> WidgetRefMut<'w, E> where
    Self: Sized + 'w, 

BOXING

Move widget into box

fn pass(self) -> Self where
    Self: Sized, 

fn debugged_type_name_mut(&mut self) -> Vec<&'static str>

fn gen_diag_error_resolve_fail_mut(
    &mut self,
    sub_path: &E::WidgetPath,
    op: &'static str
) -> GuionError<E>

Implementations on Foreign Types

impl<E> WidgetMut<E> for Box<dyn WidgetMut<E> + '_> where
    E: Env, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'w>(self: Box<Self>) -> Vec<ResolvableMut<'w, E>> where
    Self: 'w, 

fn _set_invalid(&mut self, v: bool)

fn resolve_mut(
    &mut self,
    i: E::WidgetPath
) -> Result<ResolvableMut<'_, E>, GuionError<E>>

fn into_resolve_mut<'w>(
    self: Box<Self>,
    i: E::WidgetPath
) -> Result<ResolvableMut<'w, E>, GuionError<E>> where
    Self: 'w, 

fn resolve_child_mut(
    &mut self,
    p: &E::WidgetPath
) -> Result<(usize, E::WidgetPath), GuionError<E>>

fn inner_mut(&mut self) -> Option<&mut dyn WidgetMut<E>>

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'w>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'w, E>, ()> where
    Self: 'w, 

fn message(&mut self, m: E::Message)

fn debug_type_name_mut(&mut self, dest: &mut Vec<&'static str>)

fn box_mut(&mut self) -> WidgetRefMut<'_, E>

fn box_box_mut<'w>(self: Box<Self>) -> WidgetRefMut<'w, E> where
    Self: 'w, 

fn boxed_mut<'w>(self) -> WidgetRefMut<'w, E> where
    Self: Sized + 'w, 

Loading content...

Implementors

impl<'w, E> WidgetMut<E> for ProgressBar<'w, E> where
    E: Env,
    ERenderer<E>: RenderStdWidgets<E>, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, _: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    _: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

unsafe fn _as_trait_mut<'impl_traitcast_lt_a>(
    &'impl_traitcast_lt_a mut self,
    t: TypeId
) -> Option<TraitObject>

impl<'w, E, L, R, V> WidgetMut<E> for SplitPane<'w, E, L, R, V> where
    E: Env,
    ERenderer<E>: RenderStdWidgets<E>,
    EEvent<E>: StdVarSup<E>,
    E::Context: CtxStdState<E>,
    L: AsWidgetMut<E>,
    R: AsWidgetMut<E>,
    V: AtomStateMut<E, f32>, 

fn _set_invalid(&mut self, v: bool)

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

unsafe fn _as_trait_mut<'impl_traitcast_lt_a>(
    &'impl_traitcast_lt_a mut self,
    t: TypeId
) -> Option<TraitObject>

impl<'w, E, State, Text> WidgetMut<E> for CheckBox<'w, E, State, Text> where
    E: Env,
    ERenderer<E>: RenderStdWidgets<E>,
    EEvent<E>: StdVarSup<E>,
    E::Context: CtxStdState<E>,
    State: AtomStateMut<E, bool>,
    Text: AsWidgetMut<E>, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

unsafe fn _as_trait_mut<'impl_traitcast_lt_a>(
    &'impl_traitcast_lt_a mut self,
    t: TypeId
) -> Option<TraitObject>

impl<'w, E, T> WidgetMut<E> for Pane<'w, E, T> where
    E: Env,
    T: WidgetArrayMut<E> + 'w, 

fn _set_invalid(&mut self, v: bool)

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

impl<'w, E, Text> WidgetMut<E> for Button<'w, E, Text> where
    E: Env,
    ERenderer<E>: RenderStdWidgets<E>,
    EEvent<E>: StdVarSup<E>,
    E::Context: CtxStdState<E>,
    Text: AsWidgetMut<E>, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

impl<'w, E, Text, GlyphCache> WidgetMut<E> for Label<'w, E, Text, GlyphCache> where
    E: Env,
    ERenderer<E>: RenderStdWidgets<E>,
    EEvent<E>: StdVarSup<E>,
    Text: CaptionMut<E> + ValidationMut<E> + 'w,
    GlyphCache: AtomStateMut<E, LocalGlyphCache<E>> + Clone, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, _: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    _: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

unsafe fn _as_trait_mut<'impl_traitcast_lt_a>(
    &'impl_traitcast_lt_a mut self,
    t: TypeId
) -> Option<TraitObject>

impl<'w, E, Text, Scroll, Curs, CursorStickX, GlyphCache> WidgetMut<E> for TextBox<'w, E, Text, Scroll, Curs, CursorStickX, GlyphCache> where
    E: Env,
    ERenderer<E>: RenderStdWidgets<E>,
    EEvent<E>: StdVarSup<E>,
    E::Context: CtxStdState<E> + CtxClipboardAccess<E>,
    Text: CaptionMut<E> + ValidationMut<E> + 'w,
    Scroll: AtomStateMut<E, (u32, u32)>,
    Curs: AtomStateMut<E, Cursor>,
    CursorStickX: AtomStateMut<E, Option<u32>>,
    GlyphCache: AtomStateMut<E, LocalGlyphCache<E>> + Clone, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, _: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    _: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

unsafe fn _as_trait_mut<'impl_traitcast_lt_a>(
    &'impl_traitcast_lt_a mut self,
    t: TypeId
) -> Option<TraitObject>

impl<'w, E, W, Scroll> WidgetMut<E> for Area<'w, E, W, Scroll> where
    E: Env,
    ERenderer<E>: RenderStdWidgets<E>,
    EEvent<E>: StdVarSup<E>,
    E::Context: CtxStdState<E> + CtxClipboardAccess<E>,
    W: AsWidgetMut<E> + 'w,
    Scroll: AtomStateMut<E, (u32, u32)>, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'a>(self: Box<Self>) -> Vec<ResolvableMut<'a, E>> where
    Self: 'a, 

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'a>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'a, E>, ()> where
    Self: 'a, 

unsafe fn _as_trait_mut<'impl_traitcast_lt_a>(
    &'impl_traitcast_lt_a mut self,
    t: TypeId
) -> Option<TraitObject>

impl<E> WidgetMut<E> for &mut (dyn WidgetMut<E> + '_) where
    E: Env, 

fn childs_mut(&mut self) -> Vec<ResolvableMut<'_, E>>

👎 Deprecated

fn into_childs_mut<'w>(self: Box<Self>) -> Vec<ResolvableMut<'w, E>> where
    Self: 'w, 

fn _set_invalid(&mut self, v: bool)

fn resolve_mut(
    &mut self,
    i: E::WidgetPath
) -> Result<ResolvableMut<'_, E>, GuionError<E>>

fn into_resolve_mut<'w>(
    self: Box<Self>,
    i: E::WidgetPath
) -> Result<ResolvableMut<'w, E>, GuionError<E>> where
    Self: 'w, 

fn resolve_child_mut(
    &mut self,
    p: &E::WidgetPath
) -> Result<(usize, E::WidgetPath), GuionError<E>>

fn inner_mut(&mut self) -> Option<&mut dyn WidgetMut<E>>

fn child_mut(&mut self, i: usize) -> Result<ResolvableMut<'_, E>, ()>

fn into_child_mut<'w>(
    self: Box<Self>,
    i: usize
) -> Result<ResolvableMut<'w, E>, ()> where
    Self: 'w, 

fn message(&mut self, m: E::Message)

fn debug_type_name_mut(&mut self, dest: &mut Vec<&'static str>)

fn box_mut(&mut self) -> WidgetRefMut<'_, E>

fn box_box_mut<'w>(self: Box<Self>) -> WidgetRefMut<'w, E> where
    Self: 'w, 

fn boxed_mut<'w>(self) -> WidgetRefMut<'w, E> where
    Self: Sized + 'w, 

Loading content...