From 33ebfc3f101b182443636d54baf1f0bf16466c42 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Tue, 25 Oct 2022 12:18:23 +0200
Subject: [PATCH] Rename `depth` to `height` when referring to stacking
 contexts

---
 crates/gpui/src/presenter.rs | 16 ++++++++--------
 crates/gpui/src/scene.rs     | 14 +++++++-------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/crates/gpui/src/presenter.rs b/crates/gpui/src/presenter.rs
index b0a8d37301..7628edee03 100644
--- a/crates/gpui/src/presenter.rs
+++ b/crates/gpui/src/presenter.rs
@@ -360,14 +360,14 @@ impl Presenter {
         for mut mouse_event in mouse_events {
             let mut valid_regions = Vec::new();
 
-            // GPUI elements are arranged by depth but sibling elements can register overlapping
+            // GPUI elements are arranged by height but sibling elements can register overlapping
             // mouse regions. As such, hover events are only fired on overlapping elements which
-            // are at the same depth as the topmost element which overlaps with the mouse.
+            // are at the same height as the topmost element which overlaps with the mouse.
             match &mouse_event {
                 MouseEvent::Hover(_) => {
-                    let mut top_most_depth = None;
+                    let mut top_most_height = None;
                     let mouse_position = self.mouse_position.clone();
-                    for (region, depth) in self.mouse_regions.iter().rev() {
+                    for (region, height) in self.mouse_regions.iter().rev() {
                         // Allow mouse regions to appear transparent to hovers
                         if !region.hoverable {
                             continue;
@@ -375,15 +375,15 @@ impl Presenter {
 
                         let contains_mouse = region.bounds.contains_point(mouse_position);
 
-                        if contains_mouse && top_most_depth.is_none() {
-                            top_most_depth = Some(depth);
+                        if contains_mouse && top_most_height.is_none() {
+                            top_most_height = Some(height);
                         }
 
                         // This unwrap relies on short circuiting boolean expressions
                         // The right side of the && is only executed when contains_mouse
                         // is true, and we know above that when contains_mouse is true
-                        // top_most_depth is set
-                        if contains_mouse && depth == top_most_depth.unwrap() {
+                        // top_most_height is set
+                        if contains_mouse && height == top_most_height.unwrap() {
                             //Ensure that hover entrance events aren't sent twice
                             if self.hovered_region_ids.insert(region.id()) {
                                 valid_regions.push(region.clone());
diff --git a/crates/gpui/src/scene.rs b/crates/gpui/src/scene.rs
index 9dd9e6bf21..6c4b8a28f5 100644
--- a/crates/gpui/src/scene.rs
+++ b/crates/gpui/src/scene.rs
@@ -29,7 +29,7 @@ pub struct SceneBuilder {
 struct StackingContext {
     layers: Vec<Layer>,
     active_layer_stack: Vec<usize>,
-    depth: usize,
+    height: usize,
 }
 
 #[derive(Default)]
@@ -205,7 +205,7 @@ impl Scene {
                     .layers
                     .iter()
                     .flat_map(|layer| &layer.mouse_regions)
-                    .map(|region| (region.clone(), context.depth))
+                    .map(|region| (region.clone(), context.height))
             })
             .collect()
     }
@@ -224,7 +224,7 @@ impl SceneBuilder {
     }
 
     pub fn build(mut self) -> Scene {
-        self.stacking_contexts.sort_by_key(|context| context.depth);
+        self.stacking_contexts.sort_by_key(|context| context.height);
         Scene {
             scale_factor: self.scale_factor,
             stacking_contexts: self.stacking_contexts,
@@ -236,11 +236,11 @@ impl SceneBuilder {
     }
 
     pub fn push_stacking_context(&mut self, clip_bounds: Option<RectF>) {
-        let depth = self.active_stacking_context().depth + 1;
+        let height = self.active_stacking_context().height + 1;
         self.active_stacking_context_stack
             .push(self.stacking_contexts.len());
         self.stacking_contexts
-            .push(StackingContext::new(depth, clip_bounds))
+            .push(StackingContext::new(height, clip_bounds))
     }
 
     pub fn pop_stacking_context(&mut self) {
@@ -332,11 +332,11 @@ impl SceneBuilder {
 }
 
 impl StackingContext {
-    fn new(depth: usize, clip_bounds: Option<RectF>) -> Self {
+    fn new(height: usize, clip_bounds: Option<RectF>) -> Self {
         Self {
             layers: vec![Layer::new(clip_bounds)],
             active_layer_stack: vec![0],
-            depth,
+            height,
         }
     }