wip

crates/ui/src/root.rs

@@ -2,10 +2,10 @@ use std::rc::Rc;
 
 use gpui::prelude::FluentBuilder;
 use gpui::{
-    canvas, div, point, px, rgba, AnyView, App, AppContext, Bounds, Context, CursorStyle,
+    canvas, div, point, px, size, AnyView, App, AppContext, Bounds, Context, CursorStyle,
     Decorations, Edges, Entity, FocusHandle, HitboxBehavior, Hsla, InteractiveElement, IntoElement,
     MouseButton, ParentElement as _, Pixels, Point, Render, ResizeEdge, SharedString, Size, Styled,
-    WeakFocusHandle, Window,
+    Tiling, WeakFocusHandle, Window,
 };
 use theme::{
     ActiveTheme, CLIENT_SIDE_DECORATION_BORDER, CLIENT_SIDE_DECORATION_ROUNDING,
@@ -241,7 +241,10 @@ impl Render for Root {
         window.set_rem_size(rem_size);
 
         // Set the client inset (linux only)
-        window.set_client_inset(CLIENT_SIDE_DECORATION_SHADOW);
+        match decorations {
+            Decorations::Client { .. } => window.set_client_inset(CLIENT_SIDE_DECORATION_SHADOW),
+            Decorations::Server => window.set_client_inset(px(0.0)),
+        }
 
         div()
             .id("window")
@@ -267,7 +270,7 @@ impl Render for Root {
                                 let size = window.window_bounds().get_bounds().size;
 
                                 let Some(edge) =
-                                    resize_edge(mouse, CLIENT_SIDE_DECORATION_SHADOW, size)
+                                    resize_edge(mouse, CLIENT_SIDE_DECORATION_SHADOW, size, tiling)
                                 else {
                                     return;
                                 };
@@ -314,7 +317,9 @@ impl Render for Root {
                         let size = window.window_bounds().get_bounds().size;
                         let pos = e.position;
 
-                        if let Some(edge) = resize_edge(pos, CLIENT_SIDE_DECORATION_SHADOW, size) {
+                        if let Some(edge) =
+                            resize_edge(pos, CLIENT_SIDE_DECORATION_SHADOW, size, tiling)
+                        {
                             window.start_window_resize(edge)
                         };
                     }),
@@ -324,9 +329,7 @@ impl Render for Root {
                     .map(|div| match decorations {
                         Decorations::Server => div,
                         Decorations::Client { tiling } => div
-                            .when(!cx.theme().platform.is_mac(), |div| {
-                                div.border_color(rgba(0x64748b33))
-                            })
+                            .border_color(cx.theme().border)
                             .when(!(tiling.top || tiling.right), |div| {
                                 div.rounded_tr(CLIENT_SIDE_DECORATION_ROUNDING)
                             })
@@ -401,25 +404,59 @@ pub(crate) fn window_paddings(window: &Window, _cx: &App) -> Edges<Pixels> {
 }
 
 /// Get the window resize edge.
-fn resize_edge(pos: Point<Pixels>, shadow_size: Pixels, size: Size<Pixels>) -> Option<ResizeEdge> {
-    let edge = if pos.y < shadow_size && pos.x < shadow_size {
-        ResizeEdge::TopLeft
-    } else if pos.y < shadow_size && pos.x > size.width - shadow_size {
-        ResizeEdge::TopRight
-    } else if pos.y < shadow_size {
-        ResizeEdge::Top
-    } else if pos.y > size.height - shadow_size && pos.x < shadow_size {
-        ResizeEdge::BottomLeft
-    } else if pos.y > size.height - shadow_size && pos.x > size.width - shadow_size {
-        ResizeEdge::BottomRight
-    } else if pos.y > size.height - shadow_size {
-        ResizeEdge::Bottom
-    } else if pos.x < shadow_size {
-        ResizeEdge::Left
-    } else if pos.x > size.width - shadow_size {
-        ResizeEdge::Right
-    } else {
+fn resize_edge(
+    pos: Point<Pixels>,
+    shadow_size: Pixels,
+    window_size: Size<Pixels>,
+    tiling: Tiling,
+) -> Option<ResizeEdge> {
+    let bounds = Bounds::new(Point::default(), window_size).inset(shadow_size * 1.5);
+    if bounds.contains(&pos) {
         return None;
-    };
-    Some(edge)
+    }
+
+    let corner_size = size(shadow_size * 1.5, shadow_size * 1.5);
+    let top_left_bounds = Bounds::new(Point::new(px(0.), px(0.)), corner_size);
+    if !tiling.top && top_left_bounds.contains(&pos) {
+        return Some(ResizeEdge::TopLeft);
+    }
+
+    let top_right_bounds = Bounds::new(
+        Point::new(window_size.width - corner_size.width, px(0.)),
+        corner_size,
+    );
+    if !tiling.top && top_right_bounds.contains(&pos) {
+        return Some(ResizeEdge::TopRight);
+    }
+
+    let bottom_left_bounds = Bounds::new(
+        Point::new(px(0.), window_size.height - corner_size.height),
+        corner_size,
+    );
+    if !tiling.bottom && bottom_left_bounds.contains(&pos) {
+        return Some(ResizeEdge::BottomLeft);
+    }
+
+    let bottom_right_bounds = Bounds::new(
+        Point::new(
+            window_size.width - corner_size.width,
+            window_size.height - corner_size.height,
+        ),
+        corner_size,
+    );
+    if !tiling.bottom && bottom_right_bounds.contains(&pos) {
+        return Some(ResizeEdge::BottomRight);
+    }
+
+    if !tiling.top && pos.y < shadow_size {
+        Some(ResizeEdge::Top)
+    } else if !tiling.bottom && pos.y > window_size.height - shadow_size {
+        Some(ResizeEdge::Bottom)
+    } else if !tiling.left && pos.x < shadow_size {
+        Some(ResizeEdge::Left)
+    } else if !tiling.right && pos.x > window_size.width - shadow_size {
+        Some(ResizeEdge::Right)
+    } else {
+        None
+    }
 }