Struct AdaptiveView

pub struct AdaptiveView { /* private fields */ }

A widget that adapts its content based on the current context.

AdaptiveView allows you to define different layouts for various conditions, like display context, parent size or platform variations, (e.g., desktop vs. mobile) and automatically switches between them based on a selector function.

Optionally retains unused variants to preserve their state

Example

live_design! {
    // ...
    adaptive = <AdaptiveView> {
        Desktop = <CustomView> {
            label =  { text: "Desktop View" } // override specific values of the same widget
        }
        Mobile = <CustomView> {
            label =  { text: "Mobile View" }
        }
    }
 // ...
}

fn setup_adaptive_view(cx: &mut Cx) {;
    self.adaptive_view(id!(adaptive)).set_variant_selector(|cx, parent_size| {
        if cx.display_context.screen_size.x >= 1280.0 {
            live_id!(Desktop)
        } else {
            live_id!(Mobile)
        }
    });
}

In this example, the AdaptiveView switches between Desktop and Mobile layouts based on the screen width. The set_variant_selector method allows you to define custom logic for choosing the appropriate layout variant.

AdaptiveView implements a default variant selector based on the screen width for different device layouts (Currently Desktop and Mobile). You can override this through the set_variant_selector method.

Check out VariantSelector for more information on how to define custom selectors, and what information is available to them.

Implementations

impl AdaptiveView

pub fn set_variant_selector( &mut self, selector: impl FnMut(&mut Cx, &DVec2) -> LiveId + 'static, )

Set a variant selector for this widget. The selector is a closure that takes a DisplayContext and returns a LiveId, corresponding to the template to use.

pub fn set_default_variant_selector(&mut self)

Trait Implementations

impl LiveApply for AdaptiveView

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 AdaptiveView

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

impl LiveApplyValue for AdaptiveView

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

impl LiveHook for AdaptiveView

fn before_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 apply_value_instance( &mut self, cx: &mut Cx, apply: &mut Apply<'_, '_, '_>, index: usize, nodes: &[LiveNode], ) -> usize

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

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

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 AdaptiveView

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 AdaptiveView

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

fn live_design_with(cx: &mut Cx)

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

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 AdaptiveView

fn live_register(cx: &mut Cx)

impl Widget for AdaptiveView

fn handle_event( &mut self, cx: &mut Cx, event: &Event, scope: &mut Scope<'_, '_>, )

fn draw_walk( &mut self, cx: &mut Cx2d<'_, '_>, scope: &mut Scope<'_, '_>, walk: Walk, ) -> DrawStep

fn handle_event_with( &mut self, cx: &mut Cx, event: &Event, scope: &mut Scope<'_, '_>, _sweep_area: Area, )

fn widget(&self, path: &[LiveId]) -> WidgetRef

fn widgets(&self, paths: &[&[LiveId]]) -> WidgetSet

fn widget_uid(&self) -> WidgetUid

fn widget_to_data( &self, _cx: &mut Cx, _actions: &Actions, _nodes: &mut LiveNodeVec, _path: &[LiveId], ) -> bool

fn data_to_widget( &mut self, _cx: &mut Cx, _nodes: &[LiveNode], _path: &[LiveId], )

fn draw_3d( &mut self, _cx: &mut Cx3d<'_, '_>, _scope: &mut Scope<'_, '_>, ) -> DrawStep

fn draw_3d_all(&mut self, cx: &mut Cx3d<'_, '_>, scope: &mut Scope<'_, '_>)

fn draw(&mut self, cx: &mut Cx2d<'_, '_>, scope: &mut Scope<'_, '_>) -> DrawStep

fn draw_walk_all( &mut self, cx: &mut Cx2d<'_, '_>, scope: &mut Scope<'_, '_>, walk: Walk, )

fn draw_all(&mut self, cx: &mut Cx2d<'_, '_>, scope: &mut Scope<'_, '_>)

fn draw_unscoped(&mut self, cx: &mut Cx2d<'_, '_>) -> DrawStep

fn draw_all_unscoped(&mut self, cx: &mut Cx2d<'_, '_>)

fn text(&self) -> String

fn set_text(&mut self, _cx: &mut Cx, _v: &str)

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

fn key_focus(&self, cx: &Cx) -> bool

fn set_disabled(&mut self, _cx: &mut Cx, _disabled: bool)

fn disabled(&self, _cx: &Cx) -> bool

fn ref_cast_type_id(&self) -> LiveType

where Self: 'static,

fn ui_runner(&self) -> UiRunner<Self>

where Self: Sized + 'static,

impl WidgetMatchEvent for AdaptiveView

fn handle_actions( &mut self, cx: &mut Cx, actions: &Actions, _scope: &mut Scope<'_, '_>, )

fn handle_next_frame( &mut self, _cx: &mut Cx, _e: &NextFrameEvent, _scope: &mut Scope<'_, '_>, )

fn handle_signal(&mut self, _cx: &mut Cx, _scope: &mut Scope<'_, '_>)

fn handle_audio_devices( &mut self, _cx: &mut Cx, _e: &AudioDevicesEvent, _scope: &mut Scope<'_, '_>, )

fn handle_midi_ports( &mut self, _cx: &mut Cx, _e: &MidiPortsEvent, _scope: &mut Scope<'_, '_>, )

fn handle_video_inputs( &mut self, _cx: &mut Cx, _e: &VideoInputsEvent, _scope: &mut Scope<'_, '_>, )

fn handle_http_response( &mut self, _cx: &mut Cx, _request_id: LiveId, _response: &HttpResponse, _scope: &mut Scope<'_, '_>, )

fn handle_http_request_error( &mut self, _cx: &mut Cx, _request_id: LiveId, _err: &HttpError, _scope: &mut Scope<'_, '_>, )

fn handle_http_progress( &mut self, _cx: &mut Cx, _request_id: LiveId, _progress: &HttpProgress, _scope: &mut Scope<'_, '_>, )

fn handle_http_stream( &mut self, _cx: &mut Cx, _request_id: LiveId, _data: &HttpResponse, _scope: &mut Scope<'_, '_>, )

fn handle_http_stream_complete( &mut self, _cx: &mut Cx, _request_id: LiveId, _data: &HttpResponse, _scope: &mut Scope<'_, '_>, )

fn handle_network_responses( &mut self, cx: &mut Cx, e: &NetworkResponsesEvent, scope: &mut Scope<'_, '_>, )

fn widget_match_event( &mut self, cx: &mut Cx, event: &Event, scope: &mut Scope<'_, '_>, )

impl WidgetNode for AdaptiveView

fn walk(&mut self, cx: &mut Cx) -> Walk

fn area(&self) -> Area

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

fn find_widgets( &self, path: &[LiveId], cached: WidgetCache, results: &mut WidgetSet, )

fn uid_to_widget(&self, uid: WidgetUid) -> WidgetRef

fn widget_design(&mut self) -> Option<&mut dyn WidgetDesign>

fn set_action_data(&mut self, _data: Arc<dyn ActionTrait>)

fn action_data(&self) -> Option<Arc<dyn ActionTrait>>

fn set_visible(&mut self, _cx: &mut Cx, _visible: bool)

fn visible(&self) -> bool