Paint debug widget ids with z-order

This ensures that the ids of children will not be obscured by
the ids of their parents.

This also adds caching of the textlayout object.

Author: cmyr

druid/src/contexts.rs

@@ -114,6 +114,8 @@ pub struct PaintCtx<'a, 'b: 'a> {
     pub(crate) region: Region,
     pub(crate) base_state: &'a BaseState,
     pub(crate) focus_widget: Option<WidgetId>,
+    /// The approximate depth in the tree at the time of painting.
+    pub(crate) depth: u32,
 }
 
 /// A region of a widget, generally used to describe what needs to be drawn.
@@ -341,7 +343,10 @@ impl<'a> EventCtx<'a> {
         if self.is_focused() {
             self.base_state.request_focus = Some(FocusChange::Resign);
         } else {
-            log::warn!("resign_focus can only be called by the currently focused widget");
+            log::warn!(
+                "resign_focus can only be called by the currently focused widget ({:?})",
+                self.widget_id()
+            );
         }
     }
 
@@ -660,6 +665,20 @@ impl<'a, 'b: 'a> PaintCtx<'a, 'b> {
         self.base_state.has_focus
     }
 
+    /// The depth in the tree of the currently painting widget.
+    ///
+    /// This may be used in combination with [`paint_with_z_index`] in order
+    /// to correctly order painting operations.
+    ///
+    /// The `depth` here may not be exact; it is only guaranteed that a child will
+    /// have a greater depth than its parent.
+    ///
+    /// [`paint_with_z_index`]: #method.paint_with_z_index
+    #[inline]
+    pub fn depth(&self) -> u32 {
+        self.depth
+    }
+
     /// Returns the currently visible [`Region`].
     ///
     /// [`Region`]: struct.Region.html
@@ -681,6 +700,7 @@ impl<'a, 'b: 'a> PaintCtx<'a, 'b> {
             window_id: self.window_id,
             focus_widget: self.focus_widget,
             region: region.into(),
+            depth: self.depth + 1,
         };
         f(&mut child_ctx);
         self.z_ops.append(&mut child_ctx.z_ops);

druid/src/core.rs

@@ -18,7 +18,9 @@ use std::collections::VecDeque;
 
 use crate::bloom::Bloom;
 use crate::kurbo::{Affine, Insets, Point, Rect, Shape, Size, Vec2};
-use crate::piet::{FontBuilder, RenderContext, Text, TextLayout, TextLayoutBuilder};
+use crate::piet::{
+    FontBuilder, PietTextLayout, RenderContext, Text, TextLayout, TextLayoutBuilder,
+};
 use crate::{
     BoxConstraints, Color, Command, Data, Env, Event, EventCtx, InternalEvent, InternalLifeCycle,
     LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Region, Target, UpdateCtx, Widget, WidgetId,
@@ -45,6 +47,8 @@ pub struct WidgetPod<T, W> {
     old_data: Option<T>,
     env: Option<Env>,
     inner: W,
+    // stashed layout so we don't recompute this when debugging
+    debug_widget_text: Option<PietTextLayout>,
 }
 
 /// Generic state for all widgets in the hierarchy.
@@ -139,6 +143,7 @@ impl<T, W: Widget<T>> WidgetPod<T, W> {
             old_data: None,
             env: None,
             inner,
+            debug_widget_text: None,
         }
     }
 
@@ -333,25 +338,32 @@ impl<T: Data, W: Widget<T>> WidgetPod<T, W> {
     /// [`paint`]: trait.Widget.html#tymethod.paint
     /// [`paint_with_offset`]: #method.paint_with_offset
     pub fn paint(&mut self, ctx: &mut PaintCtx, data: &T, env: &Env) {
+        // we need to do this before we borrow from self
+        if env.get(Env::DEBUG_WIDGET_ID) {
+            self.make_widget_id_layout_if_needed(self.state.id, ctx, env);
+        }
+
         let mut inner_ctx = PaintCtx {
             render_ctx: ctx.render_ctx,
             window_id: ctx.window_id,
             z_ops: Vec::new(),
             region: ctx.region.clone(),
             base_state: &self.state,
             focus_widget: ctx.focus_widget,
+            depth: ctx.depth,
         };
         self.inner.paint(&mut inner_ctx, data, env);
-        ctx.z_ops.append(&mut inner_ctx.z_ops);
 
-        if env.get(Env::DEBUG_PAINT) {
+        let debug_layout = env.get(Env::DEBUG_PAINT);
+        let debug_ids = env.get(Env::DEBUG_WIDGET_ID) && inner_ctx.is_hot();
+
+        if debug_layout {
             self.debug_paint_layout_bounds(&mut inner_ctx, env);
         }
-
-        if env.get(Env::DEBUG_WIDGET_ID) {
+        if debug_ids {
             self.debug_paint_widget_ids(&mut inner_ctx, env);
         }
-
+        ctx.z_ops.append(&mut inner_ctx.z_ops);
         self.state.invalid = Region::EMPTY;
     }
 
@@ -390,30 +402,43 @@ impl<T: Data, W: Widget<T>> WidgetPod<T, W> {
         });
     }
 
+    fn make_widget_id_layout_if_needed(&mut self, id: WidgetId, ctx: &mut PaintCtx, env: &Env) {
+        if self.debug_widget_text.is_none() {
+            let font = ctx
+                .text()
+                .new_font_by_name(env.get(crate::theme::FONT_NAME), 10.0)
+                .build()
+                .unwrap();
+            let id_string = id.to_raw().to_string();
+            self.debug_widget_text = ctx
+                .text()
+                .new_text_layout(&font, &id_string, f64::INFINITY)
+                .build()
+                .ok();
+        }
+    }
+
     fn debug_paint_widget_ids(&self, ctx: &mut PaintCtx, env: &Env) {
-        let font = ctx
-            .text()
-            .new_font_by_name(env.get(crate::theme::FONT_NAME), 10.0)
-            .build()
-            .unwrap();
-        let id_string = ctx.widget_id().to_raw().to_string();
-        let text = ctx
-            .text()
-            .new_text_layout(&font, &id_string, f64::INFINITY)
-            .build()
-            .unwrap();
-        let text_size = Size::new(text.width(), 10.0);
-        let origin = ctx.size().to_vec2() - text_size.to_vec2();
-        let origin = Point::new(origin.x.max(0.0), origin.y.max(0.0));
-
-        let text_pos = origin + Vec2::new(0., 8.0);
-        ctx.fill(Rect::from_origin_size(origin, text_size), &Color::WHITE);
-        ctx.stroke(
-            Rect::from_origin_size(origin, text_size),
-            &Color::rgb(1.0, 0., 0.),
-            1.0,
-        );
-        ctx.draw_text(&text, text_pos, &Color::BLACK);
+        // we clone because we need to move it for paint_with_z_index
+        let text = self.debug_widget_text.clone();
+        if let Some(text) = text {
+            let text_size = Size::new(text.width(), 10.0);
+            let origin = ctx.size().to_vec2() - text_size.to_vec2();
+            let border_color = env.get_debug_color(ctx.widget_id().to_raw());
+
+            ctx.paint_with_z_index(ctx.depth(), move |ctx| {
+                let origin = Point::new(origin.x.max(0.0), origin.y.max(0.0));
+
+                let text_pos = origin + Vec2::new(0., 8.0);
+                ctx.fill(Rect::from_origin_size(origin, text_size), &Color::WHITE);
+                ctx.stroke(
+                    Rect::from_origin_size(origin, text_size),
+                    &border_color,
+                    1.0,
+                );
+                ctx.draw_text(&text, text_pos, &Color::BLACK);
+            })
+        }
     }
 
     fn debug_paint_layout_bounds(&self, ctx: &mut PaintCtx, env: &Env) {
@@ -739,14 +764,21 @@ impl<T: Data, W: Widget<T>> WidgetPod<T, W> {
 
         ctx.base_state.merge_up(&self.state);
 
-        // we need to (re)register children in case of one of the following events
+        // any work we need to do after certain 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.base_state.children = ctx.base_state.children.union(self.state.children);
                 ctx.base_state.focus_chain.extend(&self.state.focus_chain);
                 ctx.register_child(self.id());
             }
+            // if we're painting widget ids, we should always paint when hot changes
+            LifeCycle::HotChanged(_) => {
+                if env.get(Env::DEBUG_WIDGET_ID) {
+                    ctx.request_paint();
+                }
+            }
             _ => (),
         }
     }

druid/src/widget/widget_ext.rs

@@ -182,7 +182,13 @@ pub trait WidgetExt<T: Data>: Widget<T> + Sized + 'static {
         EnvScope::new(|env, _| env.set(Env::DEBUG_PAINT, true), self)
     }
 
-    /// Display the `WidgetId`s for this widget and its children.
+    /// Display the `WidgetId`s for this widget and its children, when hot.
+    ///
+    /// When this is `true`, widgets that are `hot` (are under the mouse cursor)
+    /// will display their ids in their bottom right corner.
+    ///
+    /// These ids may overlap; in this case the id of a child will obscure
+    /// the id of its parent.
     fn debug_widget_id(self) -> EnvScope<T, Self> {
         EnvScope::new(|env, _| env.set(Env::DEBUG_WIDGET_ID, true), self)
     }

druid/src/window.rs

@@ -351,6 +351,7 @@ impl<T: Data> Window<T> {
             z_ops: Vec::new(),
             focus_widget: self.focus,
             region: invalid_rect.into(),
+            depth: 0,
         };
         ctx.with_child_ctx(invalid_rect, |ctx| self.root.paint(ctx, data, env));