Struct titanium::desktop::gui::libdruid::widget::Scope

pub struct Scope<SP, W>where
    SP: ScopePolicy,
    W: Widget<<SP as ScopePolicy>::State>,{ /* private fields */ }

A widget that allows encapsulation of application state.

This is useful in circumstances where

• A (potentially reusable) widget is composed of a tree of multiple cooperating child widgets
• Those widgets communicate amongst themselves using Druid’s reactive data mechanisms
• It is undesirable to complicate the surrounding application state with the internal details of the widget.

Examples include:

• In a tabs widget composed of a tab bar, and a widget switching body, those widgets need to cooperate on which tab is selected. However not every user of a tabs widget wishes to encumber their application state with this internal detail - especially as many tabs widgets may reasonably exist in an involved application.
• In a table/grid widget composed of various internal widgets, many things need to be synchronised. Scroll position, heading moves, drag operations, sort/filter operations. For many applications access to this internal data outside of the table widget isn’t needed. For this reason it may be useful to use a Scope to establish private state.

A scope embeds some input state (from its surrounding application or parent scope) into a larger piece of internal state. This is controlled by a user provided policy.

The ScopePolicy needs to do two things a) Create a new scope from the initial value of its input, b) Provide two way synchronisation between the input and the state via a ScopeTransfer

Convenience methods are provided to make a policy from a function and a lens. It may sometimes be advisable to implement ScopePolicy directly if you need to mention the type of a Scope.

Examples

use druid::{Data, Lens, WidgetExt};
use druid::widget::{TextBox, Scope};
#[derive(Clone, Data, Lens)]
struct AppState {
    name: String,
}

#[derive(Clone, Data, Lens)]
struct PrivateState {
    text: String,
    other: u32,
}

impl PrivateState {
    pub fn new(text: String) -> Self {
        PrivateState { text, other: 0 }
    }
}

fn main() {
    let scope = Scope::from_lens(
        PrivateState::new,
        PrivateState::text,
        TextBox::new().lens(PrivateState::text),
    );
}

Implementations

impl<SP, W> Scope<SP, W>where SP: ScopePolicy, W: Widget<<SP as ScopePolicy>::State>,

pub fn new(policy: SP, inner: W) -> Scope<SP, W>

Create a new scope from a policy and an inner widget

pub fn state(&self) -> Option<&<SP as ScopePolicy>::State>

A reference to the contents of the Scope’s state.

This allows you to access the content from outside the widget.

pub fn state_mut(&mut self) -> Option<&mut <SP as ScopePolicy>::State>

A mutable reference to the contents of the Scope’s state.

This allows you to mutably access the content of the Scope’ s state from outside the widget. Mainly useful for composite widgets.

Note:

If you modify the state through this reference, the Scope will not call update on its children until the next event it receives.

impl<F, Transfer, W> Scope<DefaultScopePolicy<F, Transfer>, W>where F: FnOnce(<Transfer as ScopeTransfer>::In) -> <Transfer as ScopeTransfer>::State, Transfer: ScopeTransfer, W: Widget<<Transfer as ScopeTransfer>::State>,

pub fn from_function( make_state: F, transfer: Transfer, inner: W ) -> Scope<DefaultScopePolicy<F, Transfer>, W>

Create a new policy from a function creating the state, and a ScopeTransfer synchronising it

impl<In, State, F, L, W> Scope<DefaultScopePolicy<F, LensScopeTransfer<L, In, State>>, W>where In: Data, State: Data, F: Fn(In) -> State, L: Lens<State, In>, W: Widget<State>,

pub fn from_lens( make_state: F, lens: L, inner: W ) -> Scope<DefaultScopePolicy<F, LensScopeTransfer<L, In, State>>, W>

Create a new policy from a function creating the state, and a Lens synchronising it

Trait Implementations

impl<SP, W> Widget<<SP as ScopePolicy>::In> for Scope<SP, W>where SP: ScopePolicy, W: Widget<<SP as ScopePolicy>::State>,

fn event( &mut self, ctx: &mut EventCtx<'_, '_>, event: &Event, data: &mut <SP as ScopePolicy>::In, env: &Env )

Handle an event.

fn lifecycle( &mut self, ctx: &mut LifeCycleCtx<'_, '_>, event: &LifeCycle, data: &<SP as ScopePolicy>::In, env: &Env )

Handle a life cycle notification.

fn update( &mut self, ctx: &mut UpdateCtx<'_, '_>, _old_data: &<SP as ScopePolicy>::In, data: &<SP as ScopePolicy>::In, env: &Env )

Update the widget’s appearance in response to a change in the app’s Data or Env.

fn layout( &mut self, ctx: &mut LayoutCtx<'_, '_>, bc: &BoxConstraints, data: &<SP as ScopePolicy>::In, env: &Env ) -> Size

Compute layout.

fn paint( &mut self, ctx: &mut PaintCtx<'_, '_, '_>, data: &<SP as ScopePolicy>::In, env: &Env )

Paint the widget appearance.

fn compute_max_intrinsic( &mut self, axis: Axis, ctx: &mut LayoutCtx<'_, '_>, bc: &BoxConstraints, data: &T, env: &Env ) -> f64

Computes max intrinsic/preferred dimension of a widget on the provided axis.

impl<SP, W> WidgetWrapper for Scope<SP, W>where SP: ScopePolicy, W: Widget<<SP as ScopePolicy>::State>,

type Wrapped = W

The type of the wrapped widget. Maybe we would like to constrain this to Widget<impl Data> (if existential bounds were supported). Any other scheme leads to T being unconstrained in unification at some point

fn wrapped(&self) -> &<Scope<SP, W> as WidgetWrapper>::Wrapped

Get immutable access to the wrapped child

fn wrapped_mut(&mut self) -> &mut <Scope<SP, W> as WidgetWrapper>::Wrapped

Get mutable access to the wrapped child