TMP 4

src/app_delegate.rs

@@ -8,25 +8,22 @@ use std::collections::HashMap;
 use tracing::trace;
 
 use crate::action::Action;
-use crate::command::{Command, CommandQueue};
 use crate::ext_event::{ExtEventQueue, ExtEventSink};
 use crate::widget::{StoreInWidgetMut, WidgetMut, WidgetRef};
-use crate::{
-    Event, Handled, SingleUse, Target, Widget, WidgetId, WindowDescription, WindowId, WindowRoot,
-};
+use crate::{Event, Handled, Widget, WidgetId, WindowDescription, WindowId, WindowRoot};
 
 /// A context provided to [`AppDelegate`] methods.
-pub struct DelegateCtx<'a, 'b> {
+pub struct DelegateCtx<'a> {
     //pub(crate) command_queue: &'a mut CommandQueue,
     pub(crate) ext_event_queue: &'a ExtEventQueue,
     // FIXME - Ideally, we'd like to get a hashmap of all root widgets,
     // but that creates "aliasing mutable references" problems
     // See issue #17
-    pub(crate) main_root_widget: WidgetMut<'a, 'b, Box<dyn Widget>>,
+    pub(crate) main_root_widget: WidgetMut<'a, Box<dyn Widget>>,
     //pub(crate) active_windows: &'a mut HashMap<WindowId, WindowRoot>,
 }
 
-impl<'a, 'b> DelegateCtx<'a, 'b> {
+impl<'a> DelegateCtx<'a> {
     #[cfg(FALSE)]
     pub fn submit_command(&mut self, command: impl Into<Command>) {
         self.command_queue
@@ -53,7 +50,7 @@ impl<'a, 'b> DelegateCtx<'a, 'b> {
     /// Try to return a [`WidgetMut`] to the root widget.
     ///
     /// Returns null if the returned type doesn't match the root widget type.
-    pub fn try_get_root<W: Widget + StoreInWidgetMut>(&mut self) -> Option<WidgetMut<'_, 'b, W>> {
+    pub fn try_get_root<W: Widget + StoreInWidgetMut>(&mut self) -> Option<WidgetMut<'_, W>> {
         self.main_root_widget.downcast()
     }
 
@@ -62,7 +59,7 @@ impl<'a, 'b> DelegateCtx<'a, 'b> {
     /// ## Panics
     ///
     /// Panics if the returned type doesn't match the root widget type.
-    pub fn get_root<W: Widget + StoreInWidgetMut>(&mut self) -> WidgetMut<'_, 'b, W> {
+    pub fn get_root<W: Widget + StoreInWidgetMut>(&mut self) -> WidgetMut<'_, W> {
         self.main_root_widget.downcast().expect("wrong widget type")
     }
 }
@@ -81,15 +78,6 @@ pub trait AppDelegate {
         Handled::No
     }
 
-    /// The handler for [`Command`]s.
-    ///
-    /// This function receives all command events, before they are passed down
-    /// the tree. If it returns [`Handled::Yes`], commands are short-circuited.
-    fn on_command(&mut self, ctx: &mut DelegateCtx, cmd: &Command) -> Handled {
-        #![allow(unused)]
-        Handled::No
-    }
-
     /// The handler for [`Action`]s.
     ///
     /// Note: Actions are still a WIP part of masonry.

src/ext_event.rs

@@ -3,21 +3,21 @@
 // details.
 
 //! Simple handle for submitting external events.
+#![allow(unused)]
 
 use std::any::Any;
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
 use druid_shell::IdleHandle;
 
-use crate::command::SelectorSymbol;
-use crate::platform::EXT_EVENT_IDLE_TOKEN;
 use crate::promise::PromiseResult;
 use crate::widget::WidgetId;
-use crate::{Selector, Target, WindowId};
+
+// FIXME - Remove
+pub struct WindowId;
 
 pub(crate) enum ExtMessage {
-    Command(SelectorSymbol, Box<dyn Any + Send>, Target),
     Promise(PromiseResult, WidgetId, WindowId),
 }
 
@@ -78,35 +78,6 @@ impl ExtEventQueue {
 }
 
 impl ExtEventSink {
-    /// Submit a [`Command`] to the running application.
-    ///
-    /// [`Command`] is not thread safe, so you cannot submit it directly;
-    /// instead you have to pass the [`Selector`] and the payload
-    /// separately, and it will be turned into a [`Command`] when it is received.
-    ///
-    /// For the **target** argument, [`Target::Auto`] is equivalent to [`Target::Global`].
-    ///
-    /// [`Command`]: struct.Command.html
-    /// [`Target::Auto`]: enum.Target.html#variant.Auto
-    /// [`Target::Global`]: enum.Target.html#variant.Global
-    pub fn submit_command<T: Any + Send>(
-        &self,
-        selector: Selector<T>,
-        payload: impl Into<Box<T>>,
-        target: impl Into<Target>,
-    ) -> Result<(), ExtEventError> {
-        let target = target.into();
-        let payload = payload.into();
-        if let Some(handle) = self.handle.lock().unwrap().as_mut() {
-            handle.schedule_idle(EXT_EVENT_IDLE_TOKEN);
-        }
-        self.queue
-            .lock()
-            .map_err(|_| ExtEventError)?
-            .push_back(ExtMessage::Command(selector.symbol(), payload, target));
-        Ok(())
-    }
-
     #[allow(missing_docs)]
     pub fn resolve_promise(
         &self,
@@ -115,7 +86,7 @@ impl ExtEventSink {
         target_window: WindowId,
     ) -> Result<(), ExtEventError> {
         if let Some(handle) = self.handle.lock().unwrap().as_mut() {
-            handle.schedule_idle(EXT_EVENT_IDLE_TOKEN);
+            todo!()
         }
         self.queue
             .lock()

src/lib.rs

@@ -119,7 +119,7 @@ pub mod debug_values;
 pub use action::Action;
 pub use box_constraints::BoxConstraints;
 pub use contexts::{EventCtx, LayoutCtx, LifeCycleCtx, PaintCtx, WidgetCtx};
-pub use event::{InternalLifeCycle, LifeCycle, StatusChange, WindowTheme};
+pub use event::{InternalLifeCycle, LifeCycle, PointerEvent, StatusChange, TextEvent, WindowTheme};
 pub use kurbo::{Affine, Insets, Point, Rect, Size, Vec2};
 pub use util::{AsAny, Handled};
 pub use vello::peniko::{Color, Gradient};

src/platform/mod.rs

@@ -1,12 +1,3 @@
 // This software is licensed under Apache License 2.0 and distributed on an
 // "as-is" basis without warranties of any kind. See the LICENSE file for
 // details.
-
-#[cfg(not(tarpaulin_include))]
-mod win_handler;
-#[cfg(not(tarpaulin_include))]
-mod window_description;
-
-pub use win_handler::{DialogInfo, MasonryAppHandler, MasonryWinHandler};
-pub(crate) use win_handler::{EXT_EVENT_IDLE_TOKEN, RUN_COMMANDS_TOKEN};
-pub use window_description::{WindowConfig, WindowDescription, WindowId, WindowSizePolicy};

src/platform/window_description.rs

@@ -23,6 +23,7 @@ pub struct WindowId(u64);
 ///     .window_size((400.0, 400.0));
 /// ```
 pub struct WindowDescription {
+    #[allow(dead_code)]
     pub(crate) root: Box<dyn Widget>,
     pub(crate) title: ArcStr,
     pub(crate) config: WindowConfig,
@@ -33,18 +34,7 @@ pub struct WindowDescription {
     pub id: WindowId,
 }
 
-/// Defines how a windows size should be determined
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub enum WindowSizePolicy {
-    /// Use the content of the window to determine the size.
-    ///
-    /// If you use this option, your root widget will be passed infinite constraints;
-    /// you are responsible for ensuring that your content picks an appropriate size.
-    Content,
-    /// Use the provided window size.
-    #[default]
-    User,
-}
+pub use crate::render_root::WindowSizePolicy;
 
 /// Window configuration that can be applied to a [WindowBuilder], or to an existing [WindowHandle].
 ///

src/promise.rs

@@ -6,6 +6,7 @@
 
 use std::any::Any;
 use std::num::NonZeroU64;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
@@ -24,9 +25,9 @@ pub struct PromiseResult {
 
 impl PromiseTokenId {
     pub fn next() -> PromiseTokenId {
-        use druid_shell::Counter;
-        static WIDGET_ID_COUNTER: Counter = Counter::new();
-        PromiseTokenId(WIDGET_ID_COUNTER.next_nonzero())
+        static WIDGET_ID_COUNTER: AtomicU64 = AtomicU64::new(1);
+        let id = WIDGET_ID_COUNTER.fetch_add(1, Ordering::Relaxed);
+        PromiseTokenId(id.try_into().unwrap())
     }
 
     pub fn to_raw(self) -> u64 {

src/widget/tests/layout.rs

@@ -4,8 +4,6 @@
 
 //! Tests related to layout.
 
-#![allow(unused_imports)]
-
 use crate::kurbo::{Insets, Size};
 use crate::testing::{widget_ids, ModularWidget, TestHarness, TestWidgetExt};
 use crate::widget::{Flex, SizedBox};