Disable widgets

druid/src/contexts.rs

@@ -276,6 +276,23 @@ impl_context_method!(
         pub fn has_focus(&self) -> bool {
             self.widget_state.has_focus
         }
+
+        /// The disabled state of a widget.
+        ///
+        /// Returns `true` if this widget or any of its ancestors is explicitly disabled.
+        /// To make this widget explicitly disabled use [`set_disabled`].
+        ///
+        /// Disabled means that this widget should not change the state of the application. What
+        /// that means is not entirely clear but in any it should not change its data. Therefore
+        /// others can use this as a safety mechanism to prevent the application from entering an
+        /// illegal state.
+        /// For an example the decrease button of a counter of type `usize` should be disabled if the
+        /// value is `0`.
+        ///
+        /// [`set_disabled`]: EventCtx::set_disabled
+        pub fn is_disabled(&self) -> bool {
+            self.widget_state.is_disabled()
+        }
     }
 );
 
@@ -374,9 +391,25 @@ impl_context_method!(EventCtx<'_, '_>, UpdateCtx<'_, '_>, LifeCycleCtx<'_, '_>,
     pub fn children_changed(&mut self) {
         trace!("children_changed");
         self.widget_state.children_changed = true;
+        self.widget_state.update_focus_chain = true;
         self.request_layout();
     }
 
+    /// Set the disabled state for this widget.
+    ///
+    /// Setting this to `false` does not mean a widget is not still disabled; for instance it may
+    /// still be disabled by an ancestor. See [`is_disabled`] for more information.
+    ///
+    /// Calling this method during [`LifeCycle::DisabledChanged`] has no effect.
+    ///
+    /// [`LifeCycle::DisabledChanged`]: struct.LifeCycle.html#variant.DisabledChanged
+    /// [`is_disabled`]: EventCtx::is_disabled
+    pub fn set_disabled(&mut self, disabled: bool) {
+        // widget_state.children_disabled_changed is not set because we want to be able to delete
+        // changes that happened during DisabledChanged.
+        self.widget_state.is_explicitly_disabled_new = disabled;
+    }
+
     /// Indicate that text input state has changed.
     ///
     /// A widget that accepts text input should call this anytime input state

druid/src/core.rs

@@ -106,6 +106,21 @@ pub(crate) struct WidgetState {
     pub(crate) viewport_offset: Vec2,
 
     // TODO: consider using bitflags for the booleans.
+    // `true` if a descendent of this widget changed its disabled state and should receive
+    // LifeCycle::DisabledChanged or InternalLifeCycle::RouteDisabledChanged
+    pub(crate) children_disabled_changed: bool,
+
+    // `true` if one of our ancestors is disabled (meaning we are also disabled).
+    pub(crate) ancestor_disabled: bool,
+
+    // `true` if this widget has been explicitly disabled.
+    // A widget can be disabled without being *explicitly* disabled if an ancestor is disabled.
+    pub(crate) is_explicitly_disabled: bool,
+
+    // `true` if this widget has been explicitly disabled, but has not yet seen one of
+    // LifeCycle::DisabledChanged or InternalLifeCycle::RouteDisabledChanged
+    pub(crate) is_explicitly_disabled_new: bool,
+
     pub(crate) is_hot: bool,
 
     pub(crate) is_active: bool,
@@ -125,6 +140,8 @@ pub(crate) struct WidgetState {
     /// Any descendant has requested update.
     pub(crate) request_update: bool,
 
+    pub(crate) update_focus_chain: bool,
+
     pub(crate) focus_chain: Vec<WidgetId>,
     pub(crate) request_focus: Option<FocusChange>,
     pub(crate) children: Bloom<WidgetId>,
@@ -908,11 +925,29 @@ impl<T: Data, W: Widget<T>> WidgetPod<T, W> {
                     } else {
                         if self.state.children_changed {
                             self.state.children.clear();
-                            self.state.focus_chain.clear();
                         }
                         self.state.children_changed
                     }
                 }
+                InternalLifeCycle::RouteDisabledChanged => {
+                    let was_disabled = self.state.is_disabled();
+
+                    self.state.is_explicitly_disabled = self.state.is_explicitly_disabled_new;
+
+                    if was_disabled != self.state.is_disabled() {
+                        // In case we change but none of our children we still need to update the
+                        // focus-chain
+                        self.state.update_focus_chain = true;
+                        extra_event = Some(LifeCycle::DisabledChanged(self.state.is_disabled()));
+                        //Each widget needs only one of DisabledChanged and RouteDisabledChanged
+                        false
+                    } else if self.state.children_disabled_changed {
+                        self.state.update_focus_chain = true;
+                        true
+                    } else {
+                        false
+                    }
+                }
                 InternalLifeCycle::RouteFocusChanged { old, new } => {
                     let this_changed = if *old == Some(self.state.id) {
                         Some(false)
@@ -962,6 +997,8 @@ impl<T: Data, W: Widget<T>> WidgetPod<T, W> {
                 assert!(self.old_data.is_none());
                 trace!("Received LifeCycle::WidgetAdded");
 
+                self.state.update_focus_chain = true;
+
                 self.old_data = Some(data.clone());
                 self.env = Some(env.clone());
 
@@ -980,13 +1017,37 @@ impl<T: Data, W: Widget<T>> WidgetPod<T, W> {
                 // This event was meant only for our parent, so don't recurse.
                 false
             }
+            LifeCycle::DisabledChanged(ancestors_disabled) => {
+                let was_disabled = self.state.is_disabled();
+
+                self.state.is_explicitly_disabled = self.state.is_explicitly_disabled_new;
+                self.state.ancestor_disabled = *ancestors_disabled;
+
+                // the change direction (true -> false or false -> true) of our parent and ourself
+                // is always the same, or we dont change at all, because we stay disabled if either
+                // we or our parent are disabled.
+                if was_disabled != self.state.is_disabled() {
+                    self.state.update_focus_chain = true;
+                    true
+                } else {
+                    false
+                }
+            }
             //NOTE: this is not sent here, but from the special set_hot_state method
             LifeCycle::HotChanged(_) => false,
             LifeCycle::FocusChanged(_) => {
                 // We are a descendant of a widget that has/had focus.
                 // Descendants don't inherit focus, so don't recurse.
                 false
             }
+            LifeCycle::BuildFocusChain => {
+                if self.state.update_focus_chain {
+                    self.state.focus_chain.clear();
+                    true
+                } else {
+                    false
+                }
+            }
         };
 
         let mut child_ctx = LifeCycleCtx {
@@ -1002,18 +1063,40 @@ impl<T: Data, W: Widget<T>> WidgetPod<T, W> {
             self.inner.lifecycle(&mut child_ctx, event, data, env);
         }
 
-        ctx.widget_state.merge_up(&mut self.state);
+        // Sync our state with our parent's state after the event!
 
-        // we need to (re)register children in case of one of the following events
         match event {
+            // we need to (re)register children in case of one of the following events
             LifeCycle::WidgetAdded | LifeCycle::Internal(InternalLifeCycle::RouteWidgetAdded) => {
                 self.state.children_changed = false;
                 ctx.widget_state.children = ctx.widget_state.children.union(self.state.children);
-                ctx.widget_state.focus_chain.extend(&self.state.focus_chain);
                 ctx.register_child(self.id());
             }
+            LifeCycle::DisabledChanged(_)
+            | LifeCycle::Internal(InternalLifeCycle::RouteDisabledChanged) => {
+                self.state.children_disabled_changed = false;
+
+                if self.state.is_disabled() && self.state.has_focus {
+                    // This may gets overwritten. This is ok because it still ensures that a
+                    // FocusChange is routed after we updated the focus-chain.
+                    self.state.request_focus = Some(FocusChange::Resign);
+                }
+
+                // Delete changes of disabled state that happened during DisabledChanged to avoid
+                // recursions.
+                self.state.is_explicitly_disabled_new = self.state.is_explicitly_disabled;
+            }
+            // Update focus-chain of our parent
+            LifeCycle::BuildFocusChain => {
+                self.state.update_focus_chain = false;
+                if !self.state.is_disabled() {
+                    ctx.widget_state.focus_chain.extend(&self.state.focus_chain);
+                }
+            }
             _ => (),
         }
+
+        ctx.widget_state.merge_up(&mut self.state);
     }
 
     /// Propagate a data update.
@@ -1114,6 +1197,9 @@ impl WidgetState {
             paint_insets: Insets::ZERO,
             invalid: Region::EMPTY,
             viewport_offset: Vec2::ZERO,
+            children_disabled_changed: false,
+            ancestor_disabled: false,
+            is_explicitly_disabled: false,
             baseline_offset: 0.0,
             is_hot: false,
             needs_layout: false,
@@ -1130,10 +1216,21 @@ impl WidgetState {
             cursor_change: CursorChange::Default,
             cursor: None,
             sub_window_hosts: Vec::new(),
+            is_explicitly_disabled_new: false,
             text_registrations: Vec::new(),
+            update_focus_chain: true,
         }
     }
 
+    pub(crate) fn is_disabled(&self) -> bool {
+        self.is_explicitly_disabled || self.ancestor_disabled
+    }
+
+    pub(crate) fn tree_disabled_changed(&self) -> bool {
+        self.children_disabled_changed
+            || self.is_explicitly_disabled != self.is_explicitly_disabled_new
+    }
+
     pub(crate) fn add_timer(&mut self, timer_token: TimerToken) {
         self.timers.insert(timer_token, self.id);
     }
@@ -1168,6 +1265,9 @@ impl WidgetState {
 
         self.needs_layout |= child_state.needs_layout;
         self.request_anim |= child_state.request_anim;
+        self.children_disabled_changed |= child_state.children_disabled_changed;
+        self.children_disabled_changed |=
+            child_state.is_explicitly_disabled_new != child_state.is_explicitly_disabled;
         self.has_active |= child_state.has_active;
         self.has_focus |= child_state.has_focus;
         self.children_changed |= child_state.children_changed;
@@ -1176,6 +1276,7 @@ impl WidgetState {
         self.timers.extend_drain(&mut child_state.timers);
         self.text_registrations
             .extend(child_state.text_registrations.drain(..));
+        self.update_focus_chain |= child_state.update_focus_chain;
 
         // We reset `child_state.cursor` no matter what, so that on the every pass through the tree,
         // things will be recalculated just from `cursor_change`.

druid/src/event.rs

@@ -265,6 +265,13 @@ pub enum LifeCycle {
     /// [`Size`]: struct.Size.html
     /// [`Widget::layout`]: trait.Widget.html#tymethod.layout
     Size(Size),
+    /// Called when the Disabled state of the widgets is changed.
+    ///
+    /// [`is_disabled`](struct.EventCtx.html#method.is_disabled) returns if the widget is disabled.
+    ///
+    /// [`set_disabled`](struct.EventCtx.html#method.set_disabled) to change the widgets disabled
+    /// state.
+    DisabledChanged(bool),
     /// Called when the "hot" status changes.
     ///
     /// This will always be called _before_ the event that triggered it; that is,
@@ -274,6 +281,16 @@ pub enum LifeCycle {
     /// See [`is_hot`](struct.EventCtx.html#method.is_hot) for
     /// discussion about the hot status.
     HotChanged(bool),
+    /// This is called when the widget-tree changes and druid wants to rebuild the
+    /// Focus-chain.
+    ///
+    /// It is the only place from witch [`register_for_focus`] should be called.
+    /// By doing so the widget can get focused by other widgets using [`focus_next`] or [`focus_prev`].
+    ///
+    /// [`register_for_focus`](struct.LifecycleCtx.html#method.register_for_focus)
+    /// [`focus_next`](struct.LifecycleCtx.html#method.register_for_focus)
+    /// [`focus_prev`](struct.LifecycleCtx.html#method.register_for_focus)
+    BuildFocusChain,
     /// Called when the focus status changes.
     ///
     /// This will always be called immediately after a new widget gains focus.
@@ -310,6 +327,8 @@ pub enum InternalLifeCycle {
         /// the widget that is gaining focus, if any
         new: Option<WidgetId>,
     },
+    /// Used to route the `DisabledChanged` event to the required widgets.
+    RouteDisabledChanged,
     /// The parents widget origin in window coordinate space has changed.
     ParentWindowOrigin,
     /// Testing only: request the `WidgetState` of a specific widget.
@@ -407,7 +426,9 @@ impl LifeCycle {
     pub fn should_propagate_to_hidden(&self) -> bool {
         match self {
             LifeCycle::Internal(internal) => internal.should_propagate_to_hidden(),
-            LifeCycle::WidgetAdded => true,
+            LifeCycle::WidgetAdded | LifeCycle::DisabledChanged(_) | LifeCycle::BuildFocusChain => {
+                true
+            }
             LifeCycle::Size(_) | LifeCycle::HotChanged(_) | LifeCycle::FocusChanged(_) => false,
         }
     }
@@ -418,9 +439,9 @@ impl InternalLifeCycle {
     /// (for example the hidden tabs in a tabs widget).
     pub fn should_propagate_to_hidden(&self) -> bool {
         match self {
-            InternalLifeCycle::RouteWidgetAdded | InternalLifeCycle::RouteFocusChanged { .. } => {
-                true
-            }
+            InternalLifeCycle::RouteWidgetAdded
+            | InternalLifeCycle::RouteFocusChanged { .. }
+            | InternalLifeCycle::RouteDisabledChanged => true,
             InternalLifeCycle::ParentWindowOrigin => false,
             #[cfg(test)]
             InternalLifeCycle::DebugRequestState { .. }

druid/src/tests/harness.rs

@@ -253,7 +253,7 @@ impl<T: Data> Harness<'_, T> {
         }
     }
 
-    fn lifecycle(&mut self, event: LifeCycle) {
+    pub(crate) fn lifecycle(&mut self, event: LifeCycle) {
         self.inner.lifecycle(event)
     }