Struct pixel_widgets::widget::layers::Layers

pub struct Layers<'a, T, Id> { /* fields omitted */ }

Stack child widgets on top of each other, while only the topmost receives events.

Implementations

impl<'a, T: 'a, Id: 'a + Eq + Clone> Layers<'a, T, Id>

pub fn new(state: &'a mut State<Id>) -> Self

Construct new Layers

pub fn with_background(
    state: &'a mut State<Id>,
    background: impl IntoNode<'a, T>
) -> Self

Construct new Layers with a background layer

pub fn push(self, id: Id, layer: impl IntoNode<'a, T>) -> Self

Adds a widget

pub fn extend<I: IntoIterator<Item = (Id, N)>, N: IntoNode<'a, T> + 'a>(
    self,
    iter: I
) -> Self

Adds child widgets using an iterator

Trait Implementations

impl<'a, T, Id> Drop for Layers<'a, T, Id>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T: 'a + Send, Id: 'a + Send + Eq + Clone> IntoNode<'a, T> for Layers<'a, T, Id>

pub fn into_node(self) -> Node<'a, T>

Perform the conversion.

pub fn class(self, class: &'a str) -> Node<'a, Message>

Convenience function that converts to a node and then adds a style class to the Node.

pub fn on_event(
    self,
    event: NodeEvent,
    f: impl 'a + Send + Fn(&mut Context<Message>)
) -> Node<'a, Message>

Convenience function that converts to a node and then sets a handler for when a node event occurs.

impl<'a, T: 'a + Send, Id: 'a + Send> Widget<'a, T> for Layers<'a, T, Id>

pub fn widget(&self) -> &'static str

The name of this widget, used to identify widgets of this type in stylesheets.

pub fn len(&self) -> usize

Should return the amount of children this widget has. Must be consistent with visit_children().

pub fn visit_children(&mut self, visitor: &mut dyn FnMut(&mut Node<'a, T>))

Applies a visitor to all childs of the widget. If an widget fails to visit it's children, the children won't be able to resolve their stylesheet, resulting in a panic when calling size, hit, event or draw.

pub fn focused(&self) -> bool

Test the widget for focus exclusivity. If the widget or one of it's descendants is in an exclusive focus state, this function should return true. In all other cases, it should return false. When a widget is in an exclusive focus state it is the only widget that is allowed to receive events in event. Widgets that intended to use this behaviour are modal dialogs, dropdown boxes, context menu's, etc.

pub fn size(&self, style: &Stylesheet) -> (Size, Size)

Returns the (width, height) of this widget. The extents are defined as a Size, which will later be resolved to actual dimensions.

pub fn event(
    &mut self,
    layout: Rectangle,
    clip: Rectangle,
    _: &Stylesheet,
    event: Event,
    context: &mut Context<T>
)

Handle an event. If an event changes the graphical appearance of an Widget, redraw should be called to let the Ui know that the ui should be redrawn.

pub fn draw(
    &mut self,
    layout: Rectangle,
    clip: Rectangle,
    _: &Stylesheet
) -> Vec<Primitive<'a>>

Draw the widget. Returns a list of Primitives that should be drawn.

pub fn state(&self) -> StateVec

The state of this widget, used for computing the style. If None is returned, Node will automatically compute a state, such as "hover" and "pressed".

pub fn hit(
    &self,
    layout: Rectangle,
    clip: Rectangle,
    _style: &Stylesheet,
    x: f32,
    y: f32
) -> bool

Perform a hit detect on the widget. Most widgets are fine with the default implementation, but some widgets (like Window need to report a miss (false) even when the queried position is within their layout.

pub fn node_event(
    &mut self,
    _layout: Rectangle,
    _style: &Stylesheet,
    _event: NodeEvent,
    _context: &mut Context<Message>
)

Handle a node event. If an event changes the graphical appearance of an Widget, redraw should be called to let the Ui know that the ui should be redrawn.