Merge pull request #122 from hecrj/feature/event-subscriptions

Event subscriptions

native/src/lib.rs

@@ -42,6 +42,7 @@
 pub mod input;
 pub mod layout;
 pub mod renderer;
+pub mod subscription;
 pub mod widget;
 
 mod element;
@@ -63,5 +64,6 @@ pub use layout::Layout;
 pub use mouse_cursor::MouseCursor;
 pub use renderer::Renderer;
 pub use size::Size;
+pub use subscription::Subscription;
 pub use user_interface::{Cache, UserInterface};
 pub use widget::*;

native/src/subscription.rs

@@ -0,0 +1,42 @@
+//! Listen to external events in your application.
+use crate::{Event, Hasher};
+use futures::stream::BoxStream;
+
+/// A request to listen to external events.
+///
+/// Besides performing async actions on demand with [`Command`], most
+/// applications also need to listen to external events passively.
+///
+/// A [`Subscription`] is normally provided to some runtime, like a [`Command`],
+/// and it will generate events as long as the user keeps requesting it.
+///
+/// For instance, you can use a [`Subscription`] to listen to a WebSocket
+/// connection, keyboard presses, mouse events, time ticks, etc.
+///
+/// [`Command`]: ../struct.Command.html
+/// [`Subscription`]: struct.Subscription.html
+pub type Subscription<T> = iced_core::Subscription<Hasher, EventStream, T>;
+
+/// A stream of runtime events.
+///
+/// It is the input of a [`Subscription`] in the native runtime.
+///
+/// [`Subscription`]: type.Subscription.html
+pub type EventStream = BoxStream<'static, Event>;
+
+pub use iced_core::subscription::Recipe;
+
+mod events;
+
+use events::Events;
+
+/// Returns a [`Subscription`] to all the runtime events.
+///
+/// This subscription will notify your application of any [`Event`] handled by
+/// the runtime.
+///
+/// [`Subscription`]: type.Subscription.html
+/// [`Event`]: ../enum.Event.html
+pub fn events() -> Subscription<Event> {
+    Subscription::from_recipe(Events)
+}

native/src/subscription/events.rs

@@ -0,0 +1,23 @@
+use crate::{
+    subscription::{EventStream, Recipe},
+    Event, Hasher,
+};
+
+pub struct Events;
+
+impl Recipe<Hasher, EventStream> for Events {
+    type Output = Event;
+
+    fn hash(&self, state: &mut Hasher) {
+        use std::hash::Hash;
+
+        std::any::TypeId::of::<Self>().hash(state);
+    }
+
+    fn stream(
+        self: Box<Self>,
+        event_stream: EventStream,
+    ) -> futures::stream::BoxStream<'static, Self::Output> {
+        event_stream
+    }
+}

native/src/widget/checkbox.rs

@@ -31,6 +31,7 @@ pub struct Checkbox<Message> {
     on_toggle: Box<dyn Fn(bool) -> Message>,
     label: String,
     label_color: Option<Color>,
+    width: Length,
 }
 
 impl<Message> Checkbox<Message> {
@@ -53,6 +54,7 @@ impl<Message> Checkbox<Message> {
             on_toggle: Box::new(f),
             label: String::from(label),
             label_color: None,
+            width: Length::Fill,
         }
     }
 
@@ -63,6 +65,14 @@ impl<Message> Checkbox<Message> {
         self.label_color = Some(color.into());
         self
     }
+
+    /// Sets the width of the [`Checkbox`].
+    ///
+    /// [`Checkbox`]: struct.Checkbox.html
+    pub fn width(mut self, width: Length) -> Self {
+        self.width = width;
+        self
+    }
 }
 
 impl<Message, Renderer> Widget<Message, Renderer> for Checkbox<Message>
@@ -70,7 +80,7 @@ where
     Renderer: self::Renderer + text::Renderer + row::Renderer,
 {
     fn width(&self) -> Length {
-        Length::Fill
+        self.width
     }
 
     fn height(&self) -> Length {
@@ -85,6 +95,7 @@ where
         let size = self::Renderer::default_size(renderer);
 
         Row::<(), Renderer>::new()
+            .width(self.width)
             .spacing(15)
             .align_items(Align::Center)
             .push(
@@ -92,7 +103,7 @@ where
                     .width(Length::Units(size as u16))
                     .height(Length::Units(size as u16)),
             )
-            .push(Text::new(&self.label))
+            .push(Text::new(&self.label).width(self.width))
             .layout(renderer, limits)
     }