Struct ribir_core::builtin_widgets::FatObj

pub struct FatObj<T> { /* private fields */ }

A fat object that extend the T object with all builtin widgets ability. A FatObj will create during the compose phase, and compose with the builtin widgets it actually use, and drop after composed.

It’s important to understand that FatObj is a temporary mixin object. It doesn’t persist in the final widget tree. Therefore, you can only clone a portion of its real widget. However, if you’re using the DSL macros, you don’t need to worry about this.

Example

If you want to modify the margin of a FatObj, you need to clone the writer of Margin widget within it.

use ribir_core::{prelude::*, test_helper::*};

let w = |ctx: &BuildCtx| {
  let mut multi = FatObj::new(MockMulti::default()).margin(EdgeInsets::all(10.));

  let w = multi.get_margin_widget().clone_writer();
  multi
    .on_tap(move |_| w.write().margin = EdgeInsets::all(20.))
    .build(ctx)
};

Implementations

impl<W> FatObj<W>

pub fn left_align_to( &mut self, wid: &LazyWidgetId, offset: f32, ctx: &BuildCtx<'_> ) -> impl Subscription

Anchor the widget’s horizontal position by placing its left edge right to the left edge of the specified widget (wid) with the given relative pixel value (relative).

pub fn right_align_to( &mut self, wid: &LazyWidgetId, relative: f32, ctx: &BuildCtx<'_> ) -> impl Subscription

Anchor the widget’s horizontal position by placing its right edge left to the right edge of the specified widget (wid) with the given relative pixel value (relative).

pub fn top_align_to( &mut self, wid: &LazyWidgetId, relative: f32, ctx: &BuildCtx<'_> ) -> impl Subscription

Anchors the widget’s vertical position by placing its top edge below the top edge of the specified widget (wid) with the given relative pixel value (relative).

pub fn bottom_align_to( &mut self, wid: &LazyWidgetId, relative: f32, ctx: &BuildCtx<'_> ) -> impl Subscription

Anchors the widget’s vertical position by placing its bottom edge above the bottom edge of the specified widget (wid) with the given relative pixel value (relative).

impl<T> FatObj<T>

pub fn new(host: T) -> Self

Create a new FatObj with the given host object.

pub fn map<V>(self, f: impl FnOnce(T) -> V) -> FatObj<V>

Maps an FatObj<T> to FatObj<V> by applying a function to the host object.

pub fn is_empty(&self) -> bool

Return true if the FatObj not contains any builtin widgets.

pub fn into_inner(self) -> T

Return the host object of the FatObj.

Panics

Panics if the FatObj contains builtin widgets.

pub fn lazy_host_id(&self) -> LazyWidgetId

Return the LazyWidgetId of the host widget, through which you can access the WidgetId after building.

pub fn lazy_id(&self) -> LazyWidgetId

Return the LazyWidgetId point to WidgetId of the root of the sub widget tree after the FatObj has built.

impl<T> FatObj<T>

pub fn get_mix_builtin_widget(&mut self) -> &mut State<MixBuiltin>

pub fn get_request_focus_widget(&mut self) -> &mut State<RequestFocus>

Returns the State<RequestFocus> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_has_focus_widget(&mut self) -> &mut State<HasFocus>

Returns the State<HasFocus> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_mouse_hover_widget(&mut self) -> &mut State<MouseHover>

Returns the State<MouseHover> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_pointer_pressed_widget(&mut self) -> &mut State<PointerPressed>

Returns the State<PointerPressed> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_fitted_box_widget(&mut self) -> &mut State<FittedBox>

Returns the State<FittedBox> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_box_decoration_widget(&mut self) -> &mut State<BoxDecoration>

Returns the State<BoxDecoration> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_padding_widget(&mut self) -> &mut State<Padding>

Returns the State<Padding> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_layout_box_widget(&mut self) -> &mut State<LayoutBox>

Returns the State<LayoutBox> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_cursor_widget(&mut self) -> &mut State<Cursor>

Returns the State<Cursor> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_margin_widget(&mut self) -> &mut State<Margin>

Returns the State<Margin> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_scrollable_widget(&mut self) -> &mut State<ScrollableWidget>

Returns the State<ScrollableWidget> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_transform_widget(&mut self) -> &mut State<TransformWidget>

Returns the State<TransformWidget> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_h_align_widget(&mut self) -> &mut State<HAlignWidget>

Returns the State<HAlignWidget> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_v_align_widget(&mut self) -> &mut State<VAlignWidget>

Returns the State<VAlignWidget> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_relative_anchor_widget(&mut self) -> &mut State<RelativeAnchor>

Returns the State<RelativeAnchor> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_global_anchor_widget(&mut self) -> &mut State<GlobalAnchor>

Returns the State<GlobalAnchor> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_visibility_widget(&mut self) -> &mut State<Visibility>

Returns the State<Visibility> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_opacity_widget(&mut self) -> &mut State<Opacity>

Returns the State<Opacity> widget from the FatObj. If it doesn’t exist, a new one is created.

pub fn get_keep_alive_widget(&mut self) -> &mut State<KeepAlive>

Returns the State<KeepAlive> widget from the FatObj. If it doesn’t exist, a new one is created.

impl<T> FatObj<T>

pub fn on_event(self, f: impl FnMut(&mut Event) + 'static) -> Self

Attaches an event handler to the widget. It’s triggered when any event or lifecycle change happens.

pub fn on_mounted(self, f: impl FnOnce(&mut LifecycleEvent) + 'static) -> Self

Attaches an event handler that runs when the widget is first mounted to the tree.

pub fn on_performed_layout( self, f: impl FnMut(&mut LifecycleEvent) + 'static ) -> Self

Attaches an event handler that runs after the widget is performed layout.

pub fn on_disposed(self, f: impl FnOnce(&mut LifecycleEvent) + 'static) -> Self

Attaches an event handler that runs when the widget is disposed.

pub fn on_pointer_down(self, f: impl FnMut(&mut PointerEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when a pointer down occurs.

pub fn on_pointer_down_capture( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a pointer down event. This is similar to on_pointer_down, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_pointer_up(self, f: impl FnMut(&mut PointerEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when a pointer up occurs.

pub fn on_pointer_up_capture( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a pointer up event. This is similar to on_pointer_up, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_pointer_move(self, f: impl FnMut(&mut PointerEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when a pointer move occurs.

pub fn on_pointer_move_capture( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a pointer move event. This is similar to on_pointer_move, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_pointer_cancel( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered when a pointer event cancels.

pub fn on_pointer_enter( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered when a pointer device is moved into the hit test boundaries of an widget or one of its descendants.

pub fn on_pointer_leave( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered when a pointer device is moved out of the hit test boundaries of an widget or one of its descendants.

pub fn on_tap(self, f: impl FnMut(&mut PointerEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when a tap(click) occurs.

pub fn on_tap_capture(self, f: impl FnMut(&mut PointerEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a tap event. This is similar to on_tap, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_double_tap(self, f: impl FnMut(&mut PointerEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when a double tap occurs.

pub fn on_double_tap_capture( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a double tap event. This is similar to on_double_tap, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_triple_tap(self, f: impl FnMut(&mut PointerEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when a triple tap occurs.

pub fn on_triple_tap_capture( self, f: impl FnMut(&mut PointerEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered when a triple tap occurs. This is similar to on_double_tap, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_x_times_tap( self, (times, f): (usize, impl FnMut(&mut PointerEvent) + 'static) ) -> Self

Attaches a handler to the widget that is triggered when a x-times tap occurs.

pub fn on_x_times_tap_capture( self, (times, f): (usize, impl FnMut(&mut PointerEvent) + 'static) ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a x-times tap event. This is similar to on_x_times_tap, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_wheel(self, f: impl FnMut(&mut WheelEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the user rotates a wheel button on a pointing device (typically a mouse).

pub fn on_wheel_capture(self, f: impl FnMut(&mut WheelEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a wheel event. This is similar to on_wheel, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_ime_pre_edit( self, f: impl FnMut(&mut ImePreEditEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered when the input method pre-edit area is changed.

pub fn on_ime_pre_edit_capture( self, f: impl FnMut(&mut ImePreEditEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a ime pre-edit event. This is similar to on_ime_pre_edit, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_chars(self, f: impl FnMut(&mut CharsEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the input method commits text or keyboard pressed the text key.

pub fn on_chars_capture(self, f: impl FnMut(&mut CharsEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a chars event. This is similar to on_chars, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_key_down(self, f: impl FnMut(&mut KeyboardEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the keyboard key is pressed.

pub fn on_key_down_capture( self, f: impl FnMut(&mut KeyboardEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a key down event. This is similar to on_key_down, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_key_up(self, f: impl FnMut(&mut KeyboardEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the keyboard key is released.

pub fn on_key_up_capture( self, f: impl FnMut(&mut KeyboardEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a key up event. This is similar to on_key_up, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_focus(self, f: impl FnMut(&mut FocusEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the widget is focused.

pub fn on_blur(self, f: impl FnMut(&mut FocusEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the widget is lost focus.

pub fn on_focus_in(self, f: impl FnMut(&mut FocusEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the widget or its descendants are focused. The main difference between this event and focus is that focusin bubbles while focus does not.

pub fn on_focus_in_capture( self, f: impl FnMut(&mut FocusEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a focus in event. This is similar to on_focus_in, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn on_focus_out(self, f: impl FnMut(&mut FocusEvent) + 'static) -> Self

Attaches a handler to the widget that is triggered when the widget or its descendants are lost focus. The main difference between this event and focusout is that focusout bubbles while blur does not.

pub fn on_focus_out_capture( self, f: impl FnMut(&mut FocusEvent) + 'static ) -> Self

Attaches a handler to the widget that is triggered during the capture phase of a focus out event. This is similar to on_focus_out, but it’s triggered earlier in the event flow. For more information on event capturing, see Event capture.

pub fn tab_index<V, M>(self, tab_idx: V) -> Self

where DeclareInit<i16>: DeclareFrom<V, M>,

Initializes the widget with a tab index. The tab index is used to allow or prevent widgets from being sequentially focusable(usually with the Tab key, hence the name) and determine their relative ordering for sequential focus navigation. It accepts an integer as a value, with different results depending on the integer’s value:

• A negative value (usually -1) means that the widget is not reachable via sequential keyboard navigation, but could be focused with API or visually by clicking with the mouse.
• Zero means that the element should be focusable in sequential keyboard navigation, after any positive tab_index values and its order is defined by the tree’s source order.
• A positive value means the element should be focusable in sequential keyboard navigation, with its order defined by the value of the number. That is, tab_index=4 is focused before tab_index=5 and tab_index=0, but after tab_index=3. If multiple elements share the same positive tab_index value, their order relative to each other follows their position in the tree source. The maximum value for tab_index is 32767. If not specified, it takes the default value 0.

pub fn auto_focus<V, M>(self, v: V) -> Self

where DeclareInit<bool>: DeclareFrom<V, M>,

Initializes whether the widget should automatically get focus when the window loads.

Only one widget should have this attribute specified. If there are several, the widget nearest the root, get the initial focus.

pub fn box_fit<V, M>(self, v: V) -> Self

where DeclareInit<BoxFit>: DeclareFrom<V, M>,

Initializes how its child should be scale to fit its box.

pub fn background<V, M>(self, v: V) -> Self

where DeclareInit<Option<Brush>>: DeclareFrom<V, M>,

Initializes the background of the widget.

pub fn border<V, M>(self, v: V) -> Self

where DeclareInit<Option<Border>>: DeclareFrom<V, M>,

Initializes the border of the widget.

pub fn border_radius<V, M>(self, v: V) -> Self

where DeclareInit<Option<Radius>>: DeclareFrom<V, M>,

Initializes the border radius of the widget.

pub fn padding<V, M>(self, v: V) -> Self

where DeclareInit<EdgeInsets>: DeclareFrom<V, M>,

Initializes the extra space within the widget.

pub fn cursor<V, M>(self, v: V) -> Self

where DeclareInit<CursorIcon>: DeclareFrom<V, M>,

Initializes the cursor of the widget.

pub fn margin<V, M>(self, v: V) -> Self

where DeclareInit<EdgeInsets>: DeclareFrom<V, M>,

Initializes the space around the widget.

pub fn scrollable<V, M>(self, v: V) -> Self

where DeclareInit<Scrollable>: DeclareFrom<V, M>,

Initializes how user can scroll the widget.

pub fn scroll_pos<V, M>(self, v: V) -> Self

where DeclareInit<Point>: DeclareFrom<V, M>,

Initializes the position of the widget’s scroll.

pub fn transform<V, M>(self, v: V) -> Self

where DeclareInit<Transform>: DeclareFrom<V, M>,

Initializes the transformation of the widget.

pub fn h_align<V, M>(self, v: V) -> Self

where DeclareInit<HAlign>: DeclareFrom<V, M>,

Initializes how the widget should be aligned horizontally.

pub fn v_align<V, M>(self, v: V) -> Self

where DeclareInit<VAlign>: DeclareFrom<V, M>,

Initializes how the widget should be aligned vertically.

pub fn anchor<V, M>(self, v: V) -> Self

where DeclareInit<Anchor>: DeclareFrom<V, M>,

Initializes the relative anchor to the parent of the widget.

pub fn global_anchor<V, M>(self, v: V) -> Self

where DeclareInit<Anchor>: DeclareFrom<V, M>,

Initializes the global anchor of the widget.

pub fn visible<V, M>(self, v: V) -> Self

where DeclareInit<bool>: DeclareFrom<V, M>,

Initializes the visibility of the widget.

pub fn opacity<V, M>(self, v: V) -> Self

where DeclareInit<f32>: DeclareFrom<V, M>,

Initializes the opacity of the widget.

pub fn keep_alive<V, M>(self, v: V) -> Self

where DeclareInit<bool>: DeclareFrom<V, M>,

Initializes the keep_alive value of the KeepAlive widget.

Trait Implementations

impl<T: ComposeBuilder> ComposeBuilder for FatObj<T>

fn build(self, ctx: &BuildCtx<'_>) -> Widget

impl<T: ComposeChildBuilder> ComposeChildBuilder for FatObj<T>

fn build(self, ctx: &BuildCtx<'_>) -> Widget

impl<T: ComposeWithChild<C, M>, C, M> ComposeWithChild<C, M> for FatObj<T>

type Target = FatObj<<T as ComposeWithChild<C, M>>::Target>

fn with_child(self, child: C, ctx: &BuildCtx<'_>) -> Self::Target

impl<T> DerefMut for FatObj<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T1, T2, M> FromAnother<FatObj<T1>, [M; 0]> for FatObj<T2>

where T2: FromAnother<T1, M>,

fn from_another(value: FatObj<T1>, ctx: &BuildCtx<'_>) -> Self

impl<T1, T2, M> FromAnother<T1, [M; 1]> for FatObj<T2>

where T2: ChildFrom<T1, M>,

fn from_another(value: T1, ctx: &BuildCtx<'_>) -> Self

impl<T> ObjDeclarer for FatObj<T>

type Target = FatObj<T>

fn finish(self, _: &BuildCtx<'_>) -> Self::Target

Finish the object creation with the given context.

impl<T: PairWithChild<C>, C> PairWithChild<C> for FatObj<T>

type Target = Pair<FatObj<T>, C>

fn with_child(self, child: C, _: &BuildCtx<'_>) -> Self::Target

impl<T: RenderBuilder> RenderBuilder for FatObj<T>

fn build(self, ctx: &BuildCtx<'_>) -> Widget

impl<C> SingleWithChild<C, ()> for FatObj<()>

type Target = FatObj<C>

fn with_child(self, child: C, _: &BuildCtx<'_>) -> Self::Target

impl<T: WidgetBuilder> WidgetBuilder for FatObj<T>

fn build(self, ctx: &BuildCtx<'_>) -> Widget

fn box_it(self) -> BoxedWidget

where Self: Sized + 'static,

Convert the widget to named type widget FnWidget, this is useful when you want store a widget and not want to call build(ctx!()) to build it into the widget tree.

impl WidgetBuilder for FatObj<Widget>

fn build(self, ctx: &BuildCtx<'_>) -> Widget

fn box_it(self) -> BoxedWidget

where Self: Sized + 'static,

Convert the widget to named type widget FnWidget, this is useful when you want store a widget and not want to call build(ctx!()) to build it into the widget tree.

impl<T> Deref for FatObj<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: MultiChild> MultiChild for FatObj<T>

impl<T: SingleChild> SingleChild for FatObj<T>