add relay panel

crates/dock/src/lib.rs

@@ -15,7 +15,6 @@ use crate::tab_panel::TabPanel;
 
 pub mod dock;
 pub mod panel;
-mod platforms;
 pub mod resizable;
 pub mod stack_panel;
 pub mod tab;

crates/dock/src/platforms/linux.rs

@@ -1,198 +0,0 @@
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::OnceLock;
-
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    svg, App, InteractiveElement, IntoElement, MouseButton, ParentElement, RenderOnce,
-    StatefulInteractiveElement, Styled, Window,
-};
-use linicon::{lookup_icon, IconType};
-use theme::ActiveTheme;
-use ui::{h_flex, Icon, IconName, Sizable};
-
-#[derive(IntoElement)]
-pub struct LinuxWindowControls {}
-
-impl LinuxWindowControls {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl RenderOnce for LinuxWindowControls {
-    fn render(self, window: &mut Window, _cx: &mut App) -> impl IntoElement {
-        h_flex()
-            .id("linux-window-controls")
-            .gap_2()
-            .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
-            .child(WindowControl::new(
-                LinuxControl::Minimize,
-                IconName::WindowMinimize,
-            ))
-            .child({
-                if window.is_maximized() {
-                    WindowControl::new(LinuxControl::Restore, IconName::WindowRestore)
-                } else {
-                    WindowControl::new(LinuxControl::Maximize, IconName::WindowMaximize)
-                }
-            })
-            .child(WindowControl::new(
-                LinuxControl::Close,
-                IconName::WindowClose,
-            ))
-    }
-}
-
-#[derive(IntoElement)]
-pub struct WindowControl {
-    kind: LinuxControl,
-    fallback: IconName,
-}
-
-impl WindowControl {
-    pub fn new(kind: LinuxControl, fallback: IconName) -> Self {
-        Self { kind, fallback }
-    }
-
-    #[allow(dead_code)]
-    pub fn is_gnome(&self) -> bool {
-        matches!(detect_desktop_environment(), DesktopEnvironment::Gnome)
-    }
-}
-
-impl RenderOnce for WindowControl {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        h_flex()
-            .id(self.kind.as_icon_name())
-            .group("")
-            .justify_center()
-            .items_center()
-            .rounded_full()
-            .size_6()
-            .map(|this| {
-                if let Some(Some(path)) = linux_controls().get(&self.kind).cloned() {
-                    this.child(
-                        svg()
-                            .external_path(path.into_os_string().into_string().unwrap())
-                            .text_color(cx.theme().text)
-                            .size_4(),
-                    )
-                } else {
-                    this.child(Icon::new(self.fallback).flex_grow().small())
-                }
-            })
-            .on_mouse_move(|_ev, _window, cx| cx.stop_propagation())
-            .on_click(move |_ev, window, cx| {
-                cx.stop_propagation();
-                match self.kind {
-                    LinuxControl::Minimize => window.minimize_window(),
-                    LinuxControl::Restore => window.zoom_window(),
-                    LinuxControl::Maximize => window.zoom_window(),
-                    LinuxControl::Close => cx.quit(),
-                }
-            })
-    }
-}
-
-static DE: OnceLock<DesktopEnvironment> = OnceLock::new();
-static LINUX_CONTROLS: OnceLock<HashMap<LinuxControl, Option<PathBuf>>> = OnceLock::new();
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum DesktopEnvironment {
-    Gnome,
-    Kde,
-    Unknown,
-}
-
-/// Detect the current desktop environment
-pub fn detect_desktop_environment() -> &'static DesktopEnvironment {
-    DE.get_or_init(|| {
-        // Try to use environment variables first
-        if let Ok(output) = std::env::var("XDG_CURRENT_DESKTOP") {
-            let desktop = output.to_lowercase();
-            if desktop.contains("gnome") {
-                return DesktopEnvironment::Gnome;
-            } else if desktop.contains("kde") {
-                return DesktopEnvironment::Kde;
-            }
-        }
-
-        // Fallback detection methods
-        if let Ok(output) = std::env::var("DESKTOP_SESSION") {
-            let session = output.to_lowercase();
-            if session.contains("gnome") {
-                return DesktopEnvironment::Gnome;
-            } else if session.contains("kde") || session.contains("plasma") {
-                return DesktopEnvironment::Kde;
-            }
-        }
-
-        DesktopEnvironment::Unknown
-    })
-}
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
-pub enum LinuxControl {
-    Minimize,
-    Restore,
-    Maximize,
-    Close,
-}
-
-impl LinuxControl {
-    pub fn as_icon_name(&self) -> &'static str {
-        match self {
-            LinuxControl::Close => "window-close",
-            LinuxControl::Minimize => "window-minimize",
-            LinuxControl::Maximize => "window-maximize",
-            LinuxControl::Restore => "window-restore",
-        }
-    }
-}
-
-fn linux_controls() -> &'static HashMap<LinuxControl, Option<PathBuf>> {
-    LINUX_CONTROLS.get_or_init(|| {
-        let mut icons = HashMap::new();
-        icons.insert(LinuxControl::Close, None);
-        icons.insert(LinuxControl::Minimize, None);
-        icons.insert(LinuxControl::Maximize, None);
-        icons.insert(LinuxControl::Restore, None);
-
-        let icon_names = [
-            (LinuxControl::Close, vec!["window-close", "dialog-close"]),
-            (
-                LinuxControl::Minimize,
-                vec!["window-minimize", "window-lower"],
-            ),
-            (
-                LinuxControl::Maximize,
-                vec!["window-maximize", "window-expand"],
-            ),
-            (
-                LinuxControl::Restore,
-                vec!["window-restore", "window-return"],
-            ),
-        ];
-
-        for (control, icon_names) in icon_names {
-            for icon_name in icon_names {
-                // Try GNOME-style naming first
-                let mut control_icon = lookup_icon(format!("{icon_name}-symbolic"))
-                    .find(|icon| matches!(icon, Ok(icon) if icon.icon_type == IconType::SVG));
-
-                // If not found, try KDE-style naming
-                if control_icon.is_none() {
-                    control_icon = lookup_icon(icon_name)
-                        .find(|icon| matches!(icon, Ok(icon) if icon.icon_type == IconType::SVG));
-                }
-
-                if let Some(Ok(icon)) = control_icon {
-                    icons.entry(control).and_modify(|v| *v = Some(icon.path));
-                }
-            }
-        }
-
-        icons
-    })
-}

crates/dock/src/platforms/mod.rs

@@ -1,3 +0,0 @@
-#[cfg(target_os = "linux")]
-pub mod linux;
-pub mod windows;

crates/dock/src/platforms/windows.rs

@@ -1,147 +0,0 @@
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    div, px, App, ElementId, Hsla, InteractiveElement, IntoElement, ParentElement, Pixels,
-    RenderOnce, Rgba, StatefulInteractiveElement, Styled, Window, WindowControlArea,
-};
-use theme::ActiveTheme;
-use ui::h_flex;
-
-#[derive(IntoElement)]
-pub struct WindowsWindowControls {
-    button_height: Pixels,
-}
-
-impl WindowsWindowControls {
-    pub fn new(button_height: Pixels) -> Self {
-        Self { button_height }
-    }
-
-    #[cfg(not(target_os = "windows"))]
-    fn get_font() -> &'static str {
-        "Segoe Fluent Icons"
-    }
-
-    #[cfg(target_os = "windows")]
-    fn get_font() -> &'static str {
-        use windows::Wdk::System::SystemServices::RtlGetVersion;
-
-        let mut version = unsafe { std::mem::zeroed() };
-        let status = unsafe { RtlGetVersion(&mut version) };
-
-        if status.is_ok() && version.dwBuildNumber >= 22000 {
-            "Segoe Fluent Icons"
-        } else {
-            "Segoe MDL2 Assets"
-        }
-    }
-}
-
-impl RenderOnce for WindowsWindowControls {
-    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let close_button_hover_color = Rgba {
-            r: 232.0 / 255.0,
-            g: 17.0 / 255.0,
-            b: 32.0 / 255.0,
-            a: 1.0,
-        };
-
-        let button_hover_color = cx.theme().ghost_element_hover;
-        let button_active_color = cx.theme().ghost_element_active;
-
-        div()
-            .id("windows-window-controls")
-            .font_family(Self::get_font())
-            .flex()
-            .flex_row()
-            .justify_center()
-            .content_stretch()
-            .max_h(self.button_height)
-            .min_h(self.button_height)
-            .child(WindowsCaptionButton::new(
-                "minimize",
-                WindowsCaptionButtonIcon::Minimize,
-                button_hover_color,
-                button_active_color,
-            ))
-            .child(WindowsCaptionButton::new(
-                "maximize-or-restore",
-                if window.is_maximized() {
-                    WindowsCaptionButtonIcon::Restore
-                } else {
-                    WindowsCaptionButtonIcon::Maximize
-                },
-                button_hover_color,
-                button_active_color,
-            ))
-            .child(WindowsCaptionButton::new(
-                "close",
-                WindowsCaptionButtonIcon::Close,
-                close_button_hover_color,
-                button_active_color,
-            ))
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
-enum WindowsCaptionButtonIcon {
-    Minimize,
-    Restore,
-    Maximize,
-    Close,
-}
-
-#[derive(IntoElement)]
-struct WindowsCaptionButton {
-    id: ElementId,
-    icon: WindowsCaptionButtonIcon,
-    hover_background_color: Hsla,
-    active_background_color: Hsla,
-}
-
-impl WindowsCaptionButton {
-    pub fn new(
-        id: impl Into<ElementId>,
-        icon: WindowsCaptionButtonIcon,
-        hover_background_color: impl Into<Hsla>,
-        active_background_color: impl Into<Hsla>,
-    ) -> Self {
-        Self {
-            id: id.into(),
-            icon,
-            hover_background_color: hover_background_color.into(),
-            active_background_color: active_background_color.into(),
-        }
-    }
-}
-
-impl RenderOnce for WindowsCaptionButton {
-    fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
-        h_flex()
-            .id(self.id)
-            .justify_center()
-            .content_center()
-            .occlude()
-            .w(px(36.))
-            .h_full()
-            .text_size(px(10.0))
-            .hover(|style| style.bg(self.hover_background_color))
-            .active(|style| style.bg(self.active_background_color))
-            .map(|this| match self.icon {
-                WindowsCaptionButtonIcon::Close => {
-                    this.window_control_area(WindowControlArea::Close)
-                }
-                WindowsCaptionButtonIcon::Maximize | WindowsCaptionButtonIcon::Restore => {
-                    this.window_control_area(WindowControlArea::Max)
-                }
-                WindowsCaptionButtonIcon::Minimize => {
-                    this.window_control_area(WindowControlArea::Min)
-                }
-            })
-            .child(match self.icon {
-                WindowsCaptionButtonIcon::Minimize => "\u{e921}",
-                WindowsCaptionButtonIcon::Restore => "\u{e923}",
-                WindowsCaptionButtonIcon::Maximize => "\u{e922}",
-                WindowsCaptionButtonIcon::Close => "\u{e8bb}",
-            })
-    }
-}

crates/dock/src/stack_panel.rs

@@ -6,7 +6,7 @@ use gpui::{
     Window,
 };
 use smallvec::SmallVec;
-use theme::{ActiveTheme, CLIENT_SIDE_DECORATION_ROUNDING};
+use theme::ActiveTheme;
 use ui::{h_flex, AxisExt as _, Placement};
 
 use super::{DockArea, PanelEvent};
@@ -386,7 +386,6 @@ impl Render for StackPanel {
         h_flex()
             .size_full()
             .overflow_hidden()
-            .rounded(CLIENT_SIDE_DECORATION_ROUNDING)
             .bg(cx.theme().elevated_surface_background)
             .child(
                 ResizablePanelGroup::new("stack-panel-group")

crates/dock/src/tab_panel.rs

@@ -7,7 +7,7 @@ use gpui::{
     MouseButton, ParentElement, Pixels, Render, ScrollHandle, SharedString,
     StatefulInteractiveElement, Styled, WeakEntity, Window,
 };
-use theme::{ActiveTheme, CLIENT_SIDE_DECORATION_ROUNDING, TITLEBAR_HEIGHT};
+use theme::{ActiveTheme, TITLEBAR_HEIGHT};
 use ui::button::{Button, ButtonVariants as _};
 use ui::popup_menu::{PopupMenu, PopupMenuExt};
 use ui::{h_flex, v_flex, AxisExt, IconName, Placement, Selectable, Sizable, StyledExt};
@@ -594,7 +594,6 @@ impl TabPanel {
                 .py_2()
                 .pl_3()
                 .pr_2()
-                .rounded_tr(CLIENT_SIDE_DECORATION_ROUNDING)
                 .when(left_dock_button.is_some(), |this| this.pl_2())
                 .when(right_dock_button.is_some(), |this| this.pr_2())
                 .when(has_extend_dock_button, |this| {
@@ -647,10 +646,6 @@ impl TabPanel {
         TabBar::new()
             .track_scroll(&self.tab_bar_scroll_handle)
             .h(TITLEBAR_HEIGHT)
-            .rounded_tr(CLIENT_SIDE_DECORATION_ROUNDING)
-            .when(self.zoomed, |this| {
-                this.rounded_tl(CLIENT_SIDE_DECORATION_ROUNDING)
-            })
             .when(has_extend_dock_button, |this| {
                 this.prefix(
                     h_flex()