Struct Adapt 

pub struct Adapt<A, W: Widget> { /* private fields */ }

Data adaption node

Where Map allows mapping to a sub-set of input data, Adapt allows mapping to a super-set (including internal storage). Further, Adapt supports message handlers which mutate internal storage.

Inner data type

Note that, at least for now, the type of state stored by Adapt must equal the data type of the inner widget: state: <W as Widget>::Data. Since W::Data must outlive W (for our purposes this is not much different than if Widget::Data: 'static), we cannot support W::Data like (&A, &S) where state: S, so we might as well simply pass &S to the inner widget W. This implies that any state from A which needs to be passed into W must be copied into state: W::Data by Adapt::on_update.

(It is possible that the above restrictions will change in the future, but they would require Rust to support generic associated types in dyn-safe traits (also known as object safe GATs), at least for lifetime parameters. There was an unstable feature for this, generic_associated_types_extended, but it was removed due to being stale, experimental and unsound. But even if Rust did gain this feature, it is not clear that Widget::Data should be generic.)

Implementations

impl<A, W: Widget> Adapt<A, W>

pub fn new(inner: W, state: W::Data) -> Self

Construct over inner with additional state

pub fn on_configure<F>(self, handler: F) -> Self

where F: Fn(&mut AdaptConfigCx<'_, '_>, &mut W::Data) + 'static,

Add a handler to be called on configuration

pub fn on_update<F>(self, handler: F) -> Self

where F: Fn(&mut AdaptConfigCx<'_, '_>, &mut W::Data, &A) + 'static,

Add a handler to be called on update of input data

Children will be updated after the handler is called.

pub fn on_timer<H>(self, timer_id: TimerHandle, handler: H) -> Self

where H: Fn(&mut AdaptEventCx<'_, '_>, &mut W::Data, &A) + 'static,

Set a timer handler

It is assumed that state is modified by this timer. Frequent usage of timers which don’t do anything may be inefficient; prefer usage of EventState::send_async.

pub fn on_message<M, H>(self, handler: H) -> Self

where M: Debug + 'static, H: Fn(&mut AdaptEventCx<'_, '_>, &mut W::Data, M) + 'static,

Add a handler on message of type M

Children will be updated whenever this handler is invoked.

Where access to input data (from parent widgets) is required, use Self::on_messages instead.

pub fn on_messages<H>(self, handler: H) -> Self

where H: Fn(&mut AdaptEventCx<'_, '_>, &mut W::Data, &A) + 'static,

Add a generic message handler

Trait Implementations

impl<A, W: Widget> Events for Adapt<A, W>

fn configure(&mut self, cx: &mut ConfigCx<'_>)

Configure self

fn update(&mut self, cx: &mut ConfigCx<'_>, data: &A)

Update self using input data

fn handle_event( &mut self, cx: &mut EventCx<'_>, data: &Self::Data, event: Event<'_>, ) -> IsUsed

Handle an Event

fn handle_messages(&mut self, cx: &mut EventCx<'_>, data: &A)

Handler for messages from children/descendants

const REDRAW_ON_MOUSE_OVER: bool = false

Does this widget have a different appearance on mouse over?

fn mouse_over_icon(&self) -> Option<CursorIcon>

The mouse cursor icon to use on mouse over

fn make_child_id(&mut self, index: usize) -> Id

Make an identifier for a child

fn configure_recurse(&mut self, cx: &mut ConfigCx<'_>, data: &Self::Data)

Configure children

fn update_recurse(&mut self, cx: &mut ConfigCx<'_>, data: &Self::Data)

Update children

fn handle_mouse_over(&mut self, cx: &mut EventCx<'_>, state: bool)

Mouse focus handler

fn handle_scroll( &mut self, cx: &mut EventCx<'_>, data: &Self::Data, scroll: Scroll, )

Handler for scrolling

impl<A, W: Widget> Layout for Adapt<A, W>

fn rect(&self) -> Rect

Get the widget’s region

fn size_rules(&mut self, sizer: SizeCx<'_>, axis: AxisInfo) -> SizeRules

Get size rules for the given axis

fn set_rect(&mut self, cx: &mut ConfigCx<'_>, rect: Rect, hints: AlignHints)

Set size and position

fn try_probe(&self, coord: Coord) -> Option<Id>

Probe a coordinate for a widget’s Id

fn draw(&self, draw: DrawCx<'_>)

Draw a widget and its children

impl<A, W: Widget> MacroDefinedLayout for Adapt<A, W>

fn rect(&self) -> Rect

Get the widget’s region

fn size_rules(&mut self, sizer: SizeCx<'_>, axis: AxisInfo) -> SizeRules

Get size rules for the given axis

fn set_rect(&mut self, cx: &mut ConfigCx<'_>, rect: Rect, hints: AlignHints)

Set size and position

fn try_probe(&self, coord: Coord) -> Option<Id>

Probe a coordinate for a widget’s Id

fn draw(&self, draw: DrawCx<'_>)

Draw a widget and its children

impl<A, W> Scrollable for Adapt<A, W>

where W: Scrollable + Widget,

fn content_size(&self) -> Size

Get the content size (the inner size of the scrolled pane)

fn max_scroll_offset(&self) -> Offset

Get the maximum scroll offset

fn scroll_offset(&self) -> Offset

Get the current scroll offset

fn set_scroll_offset(&mut self, cx: &mut EventCx<'_>, offset: Offset) -> Offset

Set the scroll offset

impl<A, W: Widget> Tile for Adapt<A, W>

fn as_tile(&self) -> &dyn Tile

Get as a dyn Tile

fn id_ref(&self) -> &Id

Get a reference to the widget’s identifier

fn identify(&self) -> IdentifyWidget<'_>

Return a Display-able widget identifier

fn role(&self, _: &mut dyn RoleCx) -> Role<'_>

Describe the widget’s role

fn get_child(&self, index: usize) -> Option<&dyn Tile>

Access a child as a dyn Tile, if available

fn child_indices(&self) -> ChildIndices

Get child indices available to recursion

fn nav_next(&self, reverse: bool, from: Option<usize>) -> Option<usize>

Navigation in spatial order

fn probe(&self, coord: Coord) -> Id

Probe a coordinate for a widget’s Id

fn id(&self) -> Id

Get the widget’s identifier

fn navigable(&self) -> bool

Whether this widget supports navigation focus

fn tooltip(&self) -> Option<&str>

Tooltip

fn role_child_properties(&self, cx: &mut dyn RoleCx, index: usize)

Specify additional role properties for child index

fn find_child_index(&self, id: &Id) -> Option<usize>

Find the child which is an ancestor of this id, if any

fn translation(&self, index: usize) -> Offset

Get translation of child index relative to this widget

impl<A, W: Widget> Widget for Adapt<A, W>

type Data = A

Input data type

fn as_node<'__a>(&'__a mut self, data: &'__a Self::Data) -> Node<'__a>

Erase type

fn child_node<'__n>( &'__n mut self, data: &'__n Self::Data, index: usize, ) -> Option<Node<'__n>>

Access a child as a Node, if available