iced_widget/

sensor.rs

//! Generate messages when content pops in and out of view.
use crate::core::layout;
use crate::core::mouse;
use crate::core::overlay;
use crate::core::renderer;
use crate::core::time::{Duration, Instant};
use crate::core::widget;
use crate::core::widget::tree::{self, Tree};
use crate::core::window;
use crate::core::{
    self, Element, Event, Layout, Length, Pixels, Rectangle, Shell, Size, Vector, Widget,
};

/// A widget that can generate messages when its content pops in and out of view.
///
/// It can even notify you with anticipation at a given distance!
pub struct Sensor<'a, Key, Message, Theme = crate::Theme, Renderer = crate::Renderer> {
    content: Element<'a, Message, Theme, Renderer>,
    key: Key,
    on_show: Option<Box<dyn Fn(Size) -> Message + 'a>>,
    on_resize: Option<Box<dyn Fn(Size) -> Option<Message> + 'a>>,
    on_hide: Option<Message>,
    anticipate: Pixels,
    delay: Duration,
}

impl<'a, Message, Theme, Renderer> Sensor<'a, (), Message, Theme, Renderer>
where
    Renderer: core::Renderer,
{
    /// Creates a new [`Sensor`] widget with the given content.
    pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) -> Self {
        Self {
            content: content.into(),
            key: (),
            on_show: None,
            on_resize: None,
            on_hide: None,
            anticipate: Pixels::ZERO,
            delay: Duration::ZERO,
        }
    }
}

impl<'a, Key, Message, Theme, Renderer> Sensor<'a, Key, Message, Theme, Renderer>
where
    Key: self::Key,
    Renderer: core::Renderer,
{
    /// Sets the message to be produced when the content pops into view.
    ///
    /// The closure will receive the [`Size`] of the content in that moment.
    pub fn on_show(mut self, on_show: impl Fn(Size) -> Message + 'a) -> Self {
        self.on_show = Some(Box::new(on_show));
        self
    }

    /// Sets the message to be produced when the content changes [`Size`] once its in view.
    ///
    /// The closure will receive the new [`Size`] of the content.
    pub fn on_resize<T>(mut self, on_resize: impl Fn(Size) -> T + 'a) -> Self
    where
        T: Into<Option<Message>>,
    {
        self.on_resize = Some(Box::new(move |size| on_resize(size).into()));
        self
    }

    /// Sets the message to be produced when the content pops out of view.
    pub fn on_hide(mut self, on_hide: Message) -> Self {
        self.on_hide = Some(on_hide);
        self
    }

    /// Sets the key of the [`Sensor`] widget, for continuity.
    ///
    /// If the key changes, the [`Sensor`] widget will trigger again.
    pub fn key<K>(self, key: K) -> Sensor<'a, impl self::Key, Message, Theme, Renderer>
    where
        K: Clone + PartialEq + 'static,
    {
        Sensor {
            content: self.content,
            key: OwnedKey(key),
            on_show: self.on_show,
            on_resize: self.on_resize,
            on_hide: self.on_hide,
            anticipate: self.anticipate,
            delay: self.delay,
        }
    }

    /// Sets the key of the [`Sensor`], for continuity; using a reference.
    ///
    /// If the key changes, the [`Sensor`] will trigger again.
    pub fn key_ref<K>(self, key: &'a K) -> Sensor<'a, &'a K, Message, Theme, Renderer>
    where
        K: ToOwned + PartialEq<K::Owned> + ?Sized,
        K::Owned: 'static,
    {
        Sensor {
            content: self.content,
            key,
            on_show: self.on_show,
            on_resize: self.on_resize,
            on_hide: self.on_hide,
            anticipate: self.anticipate,
            delay: self.delay,
        }
    }

    /// Sets the distance in [`Pixels`] to use in anticipation of the
    /// content popping into view.
    ///
    /// This can be quite useful to lazily load items in a long scrollable
    /// behind the scenes before the user can notice it!
    pub fn anticipate(mut self, distance: impl Into<Pixels>) -> Self {
        self.anticipate = distance.into();
        self
    }

    /// Sets the amount of time to wait before firing an [`on_show`] or
    /// [`on_hide`] event; after the content is shown or hidden.
    ///
    /// When combined with [`key`], this can be useful to debounce key changes.
    ///
    /// [`on_show`]: Self::on_show
    /// [`on_hide`]: Self::on_hide
    /// [`key`]: Self::key
    pub fn delay(mut self, delay: impl Into<Duration>) -> Self {
        self.delay = delay.into();
        self
    }
}

#[derive(Debug, Clone)]
struct State<Key> {
    has_popped_in: bool,
    should_notify_at: Option<(bool, Instant)>,
    last_size: Option<Size>,
    last_key: Key,
}

impl<Key, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
    for Sensor<'_, Key, Message, Theme, Renderer>
where
    Key: self::Key,
    Renderer: core::Renderer,
{
    fn tag(&self) -> tree::Tag {
        tree::Tag::of::<State<Key::Owned>>()
    }

    fn state(&self) -> tree::State {
        tree::State::new(State {
            has_popped_in: false,
            should_notify_at: None,
            last_size: None,
            last_key: self.key.to_owned(),
        })
    }

    fn diff(&mut self, tree: &mut Tree) {
        tree.diff_children(std::slice::from_mut(&mut self.content));
    }

    fn update(
        &mut self,
        tree: &mut Tree,
        event: &Event,
        layout: Layout<'_>,
        cursor: mouse::Cursor,
        renderer: &Renderer,
        shell: &mut Shell<'_, Message>,
        viewport: &Rectangle,
    ) {
        if let Event::Window(window::Event::RedrawRequested(now)) = &event {
            let state = tree.state.downcast_mut::<State<Key::Owned>>();

            if state.has_popped_in && !self.key.eq(&state.last_key) {
                state.has_popped_in = false;
                state.should_notify_at = None;
                state.last_key = self.key.to_owned();
            }

            let bounds = layout.bounds();
            let top_left_distance = viewport.distance(bounds.position());

            let bottom_right_distance =
                viewport.distance(bounds.position() + Vector::from(bounds.size()));

            let distance = top_left_distance.min(bottom_right_distance);

            if self.on_show.is_none() {
                if let Some(on_resize) = &self.on_resize {
                    let size = bounds.size();

                    if Some(size) != state.last_size
                        && let Some(message) = on_resize(size)
                    {
                        state.last_size = Some(size);
                        shell.publish(message);
                    }
                }
            } else if state.has_popped_in {
                if distance <= self.anticipate.0 {
                    if let Some(on_resize) = &self.on_resize {
                        let size = bounds.size();

                        if Some(size) != state.last_size
                            && let Some(message) = on_resize(size)
                        {
                            state.last_size = Some(size);
                            shell.publish(message);
                        }
                    }
                } else if self.on_hide.is_some() {
                    state.has_popped_in = false;
                    state.should_notify_at = Some((false, *now + self.delay));
                }
            } else if distance <= self.anticipate.0 {
                let size = bounds.size();

                state.has_popped_in = true;
                state.should_notify_at = Some((true, *now + self.delay));
                state.last_size = Some(size);
            }

            match &state.should_notify_at {
                Some((has_popped_in, at)) if at <= now => {
                    if *has_popped_in {
                        if let Some(on_show) = &self.on_show {
                            shell.publish(on_show(layout.bounds().size()));
                        }
                    } else if let Some(on_hide) = self.on_hide.take() {
                        shell.publish(on_hide);
                    }

                    state.should_notify_at = None;
                }
                Some((_, at)) => {
                    shell.request_redraw_at(*at);
                }
                None => {}
            }
        }

        self.content.as_widget_mut().update(
            &mut tree.children[0],
            event,
            layout,
            cursor,
            renderer,
            shell,
            viewport,
        );
    }

    fn size(&self) -> Size<Length> {
        self.content.as_widget().size()
    }

    fn layout(
        &mut self,
        tree: &mut Tree,
        renderer: &Renderer,
        limits: &layout::Limits,
    ) -> layout::Node {
        self.content
            .as_widget_mut()
            .layout(&mut tree.children[0], renderer, limits)
    }

    fn draw(
        &self,
        tree: &Tree,
        renderer: &mut Renderer,
        theme: &Theme,
        style: &renderer::Style,
        layout: layout::Layout<'_>,
        cursor: mouse::Cursor,
        viewport: &Rectangle,
    ) {
        self.content.as_widget().draw(
            &tree.children[0],
            renderer,
            theme,
            style,
            layout,
            cursor,
            viewport,
        );
    }

    fn operate(
        &mut self,
        tree: &mut Tree,
        layout: core::Layout<'_>,
        renderer: &Renderer,
        operation: &mut dyn widget::Operation,
    ) {
        self.content
            .as_widget_mut()
            .operate(&mut tree.children[0], layout, renderer, operation);
    }

    fn mouse_interaction(
        &self,
        tree: &Tree,
        layout: core::Layout<'_>,
        cursor: mouse::Cursor,
        viewport: &Rectangle,
        renderer: &Renderer,
    ) -> mouse::Interaction {
        self.content.as_widget().mouse_interaction(
            &tree.children[0],
            layout,
            cursor,
            viewport,
            renderer,
        )
    }

    fn overlay<'b>(
        &'b mut self,
        tree: &'b mut Tree,
        layout: core::Layout<'b>,
        renderer: &Renderer,
        viewport: &Rectangle,
        translation: core::Vector,
    ) -> Vec<overlay::Element<'b, Message, Theme, Renderer>> {
        self.content.as_widget_mut().overlay(
            &mut tree.children[0],
            layout,
            renderer,
            viewport,
            translation,
        )
    }
}

impl<'a, Key, Message, Theme, Renderer> From<Sensor<'a, Key, Message, Theme, Renderer>>
    for Element<'a, Message, Theme, Renderer>
where
    Message: 'a,
    Key: self::Key + 'a,
    Renderer: core::Renderer + 'a,
    Theme: 'a,
{
    fn from(pop: Sensor<'a, Key, Message, Theme, Renderer>) -> Self {
        Element::new(pop)
    }
}

/// The key of a widget.
///
/// You should generally not need to care about this trait.
pub trait Key {
    /// The owned version of the key.
    type Owned: 'static;

    /// Returns the owned version of the key.
    fn to_owned(&self) -> Self::Owned;

    /// Compares the key with the given owned version.
    fn eq(&self, other: &Self::Owned) -> bool;
}

impl<T> Key for &T
where
    T: ToOwned + PartialEq<T::Owned> + ?Sized,
    T::Owned: 'static,
{
    type Owned = T::Owned;

    fn to_owned(&self) -> <Self as Key>::Owned {
        ToOwned::to_owned(*self)
    }

    fn eq(&self, other: &Self::Owned) -> bool {
        *self == other
    }
}

struct OwnedKey<T>(T);

impl<T> Key for OwnedKey<T>
where
    T: PartialEq + Clone + 'static,
{
    type Owned = T;

    fn to_owned(&self) -> Self::Owned {
        self.0.clone()
    }

    fn eq(&self, other: &Self::Owned) -> bool {
        &self.0 == other
    }
}

impl<T> PartialEq<T> for OwnedKey<T>
where
    T: PartialEq,
{
    fn eq(&self, other: &T) -> bool {
        &self.0 == other
    }
}

impl Key for () {
    type Owned = ();

    fn to_owned(&self) -> Self::Owned {}

    fn eq(&self, _other: &Self::Owned) -> bool {
        true
    }
}