1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// use std::ops::Range;

// use gpui::{
//     geometry::{
//         rect::RectF,
//         vector::{vec2f, Vector2F},
//     },
//     json::ToJson,
//     serde_json::{self, json},
//     AnyElement, Axis, Element, View, ViewContext,
// };

// pub(crate) struct FacePile<V: View> {
//     overlap: f32,
//     faces: Vec<AnyElement<V>>,
// }

// impl<V: View> FacePile<V> {
//     pub fn new(overlap: f32) -> Self {
//         Self {
//             overlap,
//             faces: Vec::new(),
//         }
//     }
// }

// impl<V: View> Element<V> for FacePile<V> {
//     type LayoutState = ();
//     type PaintState = ();

//     fn layout(
//         &mut self,
//         constraint: gpui::SizeConstraint,
//         view: &mut V,
//         cx: &mut ViewContext<V>,
//     ) -> (Vector2F, Self::LayoutState) {
//         debug_assert!(constraint.max_along(Axis::Horizontal) == f32::INFINITY);

//         let mut width = 0.;
//         let mut max_height = 0.;
//         for face in &mut self.faces {
//             let layout = face.layout(constraint, view, cx);
//             width += layout.x();
//             max_height = f32::max(max_height, layout.y());
//         }
//         width -= self.overlap * self.faces.len().saturating_sub(1) as f32;

//         (
//             Vector2F::new(width, max_height.clamp(1., constraint.max.y())),
//             (),
//         )
//     }

//     fn paint(
//         &mut self,
//         bounds: RectF,
//         visible_bounds: RectF,
//         _layout: &mut Self::LayoutState,
//         view: &mut V,
//         cx: &mut ViewContext<V>,
//     ) -> Self::PaintState {
//         let visible_bounds = bounds.intersection(visible_bounds).unwrap_or_default();

//         let origin_y = bounds.upper_right().y();
//         let mut origin_x = bounds.upper_right().x();

//         for face in self.faces.iter_mut().rev() {
//             let size = face.size();
//             origin_x -= size.x();
//             let origin_y = origin_y + (bounds.height() - size.y()) / 2.0;

//             cx.scene().push_layer(None);
//             face.paint(vec2f(origin_x, origin_y), visible_bounds, view, cx);
//             cx.scene().pop_layer();
//             origin_x += self.overlap;
//         }

//         ()
//     }

//     fn rect_for_text_range(
//         &self,
//         _: Range<usize>,
//         _: RectF,
//         _: RectF,
//         _: &Self::LayoutState,
//         _: &Self::PaintState,
//         _: &V,
//         _: &ViewContext<V>,
//     ) -> Option<RectF> {
//         None
//     }

//     fn debug(
//         &self,
//         bounds: RectF,
//         _: &Self::LayoutState,
//         _: &Self::PaintState,
//         _: &V,
//         _: &ViewContext<V>,
//     ) -> serde_json::Value {
//         json!({
//             "type": "FacePile",
//             "bounds": bounds.to_json()
//         })
//     }
// }

// impl<V: View> Extend<AnyElement<V>> for FacePile<V> {
//     fn extend<T: IntoIterator<Item = AnyElement<V>>>(&mut self, children: T) {
//         self.faces.extend(children);
//     }
// }