Present Servo BGRA hardware surfaces

third_party/gpui/src/platform/app_menu.rs

@@ -0,0 +1,252 @@
+use crate::{Action, App, Platform, SharedString};
+use util::ResultExt;
+
+/// A menu of the application, either a main menu or a submenu
+pub struct Menu {
+    /// The name of the menu
+    pub name: SharedString,
+
+    /// The items in the menu
+    pub items: Vec<MenuItem>,
+}
+
+impl Menu {
+    /// Create an OwnedMenu from this Menu
+    pub fn owned(self) -> OwnedMenu {
+        OwnedMenu {
+            name: self.name.to_string().into(),
+            items: self.items.into_iter().map(|item| item.owned()).collect(),
+        }
+    }
+}
+
+/// OS menus are menus that are recognized by the operating system
+/// This allows the operating system to provide specialized items for
+/// these menus
+pub struct OsMenu {
+    /// The name of the menu
+    pub name: SharedString,
+
+    /// The type of menu
+    pub menu_type: SystemMenuType,
+}
+
+impl OsMenu {
+    /// Create an OwnedOsMenu from this OsMenu
+    pub fn owned(self) -> OwnedOsMenu {
+        OwnedOsMenu {
+            name: self.name.to_string().into(),
+            menu_type: self.menu_type,
+        }
+    }
+}
+
+/// The type of system menu
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum SystemMenuType {
+    /// The 'Services' menu in the Application menu on macOS
+    Services,
+}
+
+/// The different kinds of items that can be in a menu
+pub enum MenuItem {
+    /// A separator between items
+    Separator,
+
+    /// A submenu
+    Submenu(Menu),
+
+    /// A menu, managed by the system (for example, the Services menu on macOS)
+    SystemMenu(OsMenu),
+
+    /// An action that can be performed
+    Action {
+        /// The name of this menu item
+        name: SharedString,
+
+        /// the action to perform when this menu item is selected
+        action: Box<dyn Action>,
+
+        /// The OS Action that corresponds to this action, if any
+        /// See [`OsAction`] for more information
+        os_action: Option<OsAction>,
+    },
+}
+
+impl MenuItem {
+    /// Creates a new menu item that is a separator
+    pub fn separator() -> Self {
+        Self::Separator
+    }
+
+    /// Creates a new menu item that is a submenu
+    pub fn submenu(menu: Menu) -> Self {
+        Self::Submenu(menu)
+    }
+
+    /// Creates a new submenu that is populated by the OS
+    pub fn os_submenu(name: impl Into<SharedString>, menu_type: SystemMenuType) -> Self {
+        Self::SystemMenu(OsMenu {
+            name: name.into(),
+            menu_type,
+        })
+    }
+
+    /// Creates a new menu item that invokes an action
+    pub fn action(name: impl Into<SharedString>, action: impl Action) -> Self {
+        Self::Action {
+            name: name.into(),
+            action: Box::new(action),
+            os_action: None,
+        }
+    }
+
+    /// Creates a new menu item that invokes an action and has an OS action
+    pub fn os_action(
+        name: impl Into<SharedString>,
+        action: impl Action,
+        os_action: OsAction,
+    ) -> Self {
+        Self::Action {
+            name: name.into(),
+            action: Box::new(action),
+            os_action: Some(os_action),
+        }
+    }
+
+    /// Create an OwnedMenuItem from this MenuItem
+    pub fn owned(self) -> OwnedMenuItem {
+        match self {
+            MenuItem::Separator => OwnedMenuItem::Separator,
+            MenuItem::Submenu(submenu) => OwnedMenuItem::Submenu(submenu.owned()),
+            MenuItem::Action {
+                name,
+                action,
+                os_action,
+            } => OwnedMenuItem::Action {
+                name: name.into(),
+                action,
+                os_action,
+            },
+            MenuItem::SystemMenu(os_menu) => OwnedMenuItem::SystemMenu(os_menu.owned()),
+        }
+    }
+}
+
+/// OS menus are menus that are recognized by the operating system
+/// This allows the operating system to provide specialized items for
+/// these menus
+#[derive(Clone)]
+pub struct OwnedOsMenu {
+    /// The name of the menu
+    pub name: SharedString,
+
+    /// The type of menu
+    pub menu_type: SystemMenuType,
+}
+
+/// A menu of the application, either a main menu or a submenu
+#[derive(Clone)]
+pub struct OwnedMenu {
+    /// The name of the menu
+    pub name: SharedString,
+
+    /// The items in the menu
+    pub items: Vec<OwnedMenuItem>,
+}
+
+/// The different kinds of items that can be in a menu
+pub enum OwnedMenuItem {
+    /// A separator between items
+    Separator,
+
+    /// A submenu
+    Submenu(OwnedMenu),
+
+    /// A menu, managed by the system (for example, the Services menu on macOS)
+    SystemMenu(OwnedOsMenu),
+
+    /// An action that can be performed
+    Action {
+        /// The name of this menu item
+        name: String,
+
+        /// the action to perform when this menu item is selected
+        action: Box<dyn Action>,
+
+        /// The OS Action that corresponds to this action, if any
+        /// See [`OsAction`] for more information
+        os_action: Option<OsAction>,
+    },
+}
+
+impl Clone for OwnedMenuItem {
+    fn clone(&self) -> Self {
+        match self {
+            OwnedMenuItem::Separator => OwnedMenuItem::Separator,
+            OwnedMenuItem::Submenu(submenu) => OwnedMenuItem::Submenu(submenu.clone()),
+            OwnedMenuItem::Action {
+                name,
+                action,
+                os_action,
+            } => OwnedMenuItem::Action {
+                name: name.clone(),
+                action: action.boxed_clone(),
+                os_action: *os_action,
+            },
+            OwnedMenuItem::SystemMenu(os_menu) => OwnedMenuItem::SystemMenu(os_menu.clone()),
+        }
+    }
+}
+
+// TODO: As part of the global selections refactor, these should
+// be moved to GPUI-provided actions that make this association
+// without leaking the platform details to GPUI users
+
+/// OS actions are actions that are recognized by the operating system
+/// This allows the operating system to provide specialized behavior for
+/// these actions
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum OsAction {
+    /// The 'cut' action
+    Cut,
+
+    /// The 'copy' action
+    Copy,
+
+    /// The 'paste' action
+    Paste,
+
+    /// The 'select all' action
+    SelectAll,
+
+    /// The 'undo' action
+    Undo,
+
+    /// The 'redo' action
+    Redo,
+}
+
+pub(crate) fn init_app_menus(platform: &dyn Platform, cx: &App) {
+    platform.on_will_open_app_menu(Box::new({
+        let cx = cx.to_async();
+        move || {
+            cx.update(|cx| cx.clear_pending_keystrokes()).ok();
+        }
+    }));
+
+    platform.on_validate_app_menu_command(Box::new({
+        let cx = cx.to_async();
+        move |action| {
+            cx.update(|cx| cx.is_action_available(action))
+                .unwrap_or(false)
+        }
+    }));
+
+    platform.on_app_menu_action(Box::new({
+        let cx = cx.to_async();
+        move |action| {
+            cx.update(|cx| cx.dispatch_action(action)).log_err();
+        }
+    }));
+}

third_party/gpui/src/platform/blade.rs

@@ -0,0 +1,11 @@
+#[cfg(target_os = "macos")]
+mod apple_compat;
+mod blade_atlas;
+mod blade_context;
+mod blade_renderer;
+
+#[cfg(target_os = "macos")]
+pub(crate) use apple_compat::*;
+pub(crate) use blade_atlas::*;
+pub(crate) use blade_context::*;
+pub(crate) use blade_renderer::*;

third_party/gpui/src/platform/blade/apple_compat.rs

@@ -0,0 +1,60 @@
+use super::{BladeContext, BladeRenderer, BladeSurfaceConfig};
+use blade_graphics as gpu;
+use std::{ffi::c_void, ptr::NonNull};
+
+#[derive(Clone)]
+pub struct Context {
+    inner: BladeContext,
+}
+impl Default for Context {
+    fn default() -> Self {
+        Self {
+            inner: BladeContext::new().unwrap(),
+        }
+    }
+}
+
+pub type Renderer = BladeRenderer;
+
+pub unsafe fn new_renderer(
+    context: Context,
+    _native_window: *mut c_void,
+    native_view: *mut c_void,
+    bounds: crate::Size<f32>,
+    transparent: bool,
+) -> Renderer {
+    use raw_window_handle as rwh;
+    struct RawWindow {
+        view: *mut c_void,
+    }
+
+    impl rwh::HasWindowHandle for RawWindow {
+        fn window_handle(&self) -> Result<rwh::WindowHandle<'_>, rwh::HandleError> {
+            let view = NonNull::new(self.view).unwrap();
+            let handle = rwh::AppKitWindowHandle::new(view);
+            Ok(unsafe { rwh::WindowHandle::borrow_raw(handle.into()) })
+        }
+    }
+    impl rwh::HasDisplayHandle for RawWindow {
+        fn display_handle(&self) -> Result<rwh::DisplayHandle<'_>, rwh::HandleError> {
+            let handle = rwh::AppKitDisplayHandle::new();
+            Ok(unsafe { rwh::DisplayHandle::borrow_raw(handle.into()) })
+        }
+    }
+
+    BladeRenderer::new(
+        &context.inner,
+        &RawWindow {
+            view: native_view as *mut _,
+        },
+        BladeSurfaceConfig {
+            size: gpu::Extent {
+                width: bounds.width as u32,
+                height: bounds.height as u32,
+                depth: 1,
+            },
+            transparent,
+        },
+    )
+    .unwrap()
+}

third_party/gpui/src/platform/blade/blade_atlas.rs

@@ -0,0 +1,384 @@
+use crate::{
+    AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTile, Bounds, DevicePixels, PlatformAtlas,
+    Point, Size, platform::AtlasTextureList,
+};
+use anyhow::Result;
+use blade_graphics as gpu;
+use blade_util::{BufferBelt, BufferBeltDescriptor};
+use collections::FxHashMap;
+use etagere::BucketedAtlasAllocator;
+use parking_lot::Mutex;
+use std::{borrow::Cow, ops, sync::Arc};
+
+pub(crate) struct BladeAtlas(Mutex<BladeAtlasState>);
+
+struct PendingUpload {
+    id: AtlasTextureId,
+    bounds: Bounds<DevicePixels>,
+    data: gpu::BufferPiece,
+}
+
+struct BladeAtlasState {
+    gpu: Arc<gpu::Context>,
+    upload_belt: BufferBelt,
+    storage: BladeAtlasStorage,
+    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
+    initializations: Vec<AtlasTextureId>,
+    uploads: Vec<PendingUpload>,
+}
+
+#[cfg(gles)]
+unsafe impl Send for BladeAtlasState {}
+
+impl BladeAtlasState {
+    fn destroy(&mut self) {
+        self.storage.destroy(&self.gpu);
+        self.upload_belt.destroy(&self.gpu);
+    }
+}
+
+pub struct BladeTextureInfo {
+    pub raw_view: gpu::TextureView,
+}
+
+impl BladeAtlas {
+    pub(crate) fn new(gpu: &Arc<gpu::Context>) -> Self {
+        BladeAtlas(Mutex::new(BladeAtlasState {
+            gpu: Arc::clone(gpu),
+            upload_belt: BufferBelt::new(BufferBeltDescriptor {
+                memory: gpu::Memory::Upload,
+                min_chunk_size: 0x10000,
+                alignment: 64, // Vulkan `optimalBufferCopyOffsetAlignment` on Intel XE
+            }),
+            storage: BladeAtlasStorage::default(),
+            tiles_by_key: Default::default(),
+            initializations: Vec::new(),
+            uploads: Vec::new(),
+        }))
+    }
+
+    pub(crate) fn destroy(&self) {
+        self.0.lock().destroy();
+    }
+
+    pub fn before_frame(&self, gpu_encoder: &mut gpu::CommandEncoder) {
+        let mut lock = self.0.lock();
+        lock.flush(gpu_encoder);
+    }
+
+    pub fn after_frame(&self, sync_point: &gpu::SyncPoint) {
+        let mut lock = self.0.lock();
+        lock.upload_belt.flush(sync_point);
+    }
+
+    pub fn get_texture_info(&self, id: AtlasTextureId) -> BladeTextureInfo {
+        let lock = self.0.lock();
+        let texture = &lock.storage[id];
+        BladeTextureInfo {
+            raw_view: texture.raw_view,
+        }
+    }
+}
+
+impl PlatformAtlas for BladeAtlas {
+    fn get_or_insert_with<'a>(
+        &self,
+        key: &AtlasKey,
+        build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,
+    ) -> Result<Option<AtlasTile>> {
+        let mut lock = self.0.lock();
+        if let Some(tile) = lock.tiles_by_key.get(key) {
+            Ok(Some(tile.clone()))
+        } else {
+            profiling::scope!("new tile");
+            let Some((size, bytes)) = build()? else {
+                return Ok(None);
+            };
+            let tile = lock.allocate(size, key.texture_kind());
+            lock.upload_texture(tile.texture_id, tile.bounds, &bytes);
+            lock.tiles_by_key.insert(key.clone(), tile.clone());
+            Ok(Some(tile))
+        }
+    }
+
+    fn remove(&self, key: &AtlasKey) {
+        let mut lock = self.0.lock();
+
+        let Some(id) = lock.tiles_by_key.remove(key).map(|tile| tile.texture_id) else {
+            return;
+        };
+
+        let Some(texture_slot) = lock.storage[id.kind].textures.get_mut(id.index as usize) else {
+            return;
+        };
+
+        if let Some(mut texture) = texture_slot.take() {
+            texture.decrement_ref_count();
+            if texture.is_unreferenced() {
+                lock.storage[id.kind]
+                    .free_list
+                    .push(texture.id.index as usize);
+                texture.destroy(&lock.gpu);
+            } else {
+                *texture_slot = Some(texture);
+            }
+        }
+    }
+}
+
+impl BladeAtlasState {
+    fn allocate(&mut self, size: Size<DevicePixels>, texture_kind: AtlasTextureKind) -> AtlasTile {
+        {
+            let textures = &mut self.storage[texture_kind];
+
+            if let Some(tile) = textures
+                .iter_mut()
+                .rev()
+                .find_map(|texture| texture.allocate(size))
+            {
+                return tile;
+            }
+        }
+
+        let texture = self.push_texture(size, texture_kind);
+        texture.allocate(size).unwrap()
+    }
+
+    fn push_texture(
+        &mut self,
+        min_size: Size<DevicePixels>,
+        kind: AtlasTextureKind,
+    ) -> &mut BladeAtlasTexture {
+        const DEFAULT_ATLAS_SIZE: Size<DevicePixels> = Size {
+            width: DevicePixels(1024),
+            height: DevicePixels(1024),
+        };
+
+        let size = min_size.max(&DEFAULT_ATLAS_SIZE);
+        let format;
+        let usage;
+        match kind {
+            AtlasTextureKind::Monochrome => {
+                format = gpu::TextureFormat::R8Unorm;
+                usage = gpu::TextureUsage::COPY | gpu::TextureUsage::RESOURCE;
+            }
+            AtlasTextureKind::Polychrome => {
+                format = gpu::TextureFormat::Bgra8Unorm;
+                usage = gpu::TextureUsage::COPY | gpu::TextureUsage::RESOURCE;
+            }
+        }
+
+        let raw = self.gpu.create_texture(gpu::TextureDesc {
+            name: "atlas",
+            format,
+            size: gpu::Extent {
+                width: size.width.into(),
+                height: size.height.into(),
+                depth: 1,
+            },
+            array_layer_count: 1,
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: gpu::TextureDimension::D2,
+            usage,
+            external: None,
+        });
+        let raw_view = self.gpu.create_texture_view(
+            raw,
+            gpu::TextureViewDesc {
+                name: "",
+                format,
+                dimension: gpu::ViewDimension::D2,
+                subresources: &Default::default(),
+            },
+        );
+
+        let texture_list = &mut self.storage[kind];
+        let index = texture_list.free_list.pop();
+
+        let atlas_texture = BladeAtlasTexture {
+            id: AtlasTextureId {
+                index: index.unwrap_or(texture_list.textures.len()) as u32,
+                kind,
+            },
+            allocator: etagere::BucketedAtlasAllocator::new(size.into()),
+            format,
+            raw,
+            raw_view,
+            live_atlas_keys: 0,
+        };
+
+        self.initializations.push(atlas_texture.id);
+
+        if let Some(ix) = index {
+            texture_list.textures[ix] = Some(atlas_texture);
+            texture_list.textures.get_mut(ix).unwrap().as_mut().unwrap()
+        } else {
+            texture_list.textures.push(Some(atlas_texture));
+            texture_list.textures.last_mut().unwrap().as_mut().unwrap()
+        }
+    }
+
+    fn upload_texture(&mut self, id: AtlasTextureId, bounds: Bounds<DevicePixels>, bytes: &[u8]) {
+        let data = self.upload_belt.alloc_bytes(bytes, &self.gpu);
+        self.uploads.push(PendingUpload { id, bounds, data });
+    }
+
+    fn flush_initializations(&mut self, encoder: &mut gpu::CommandEncoder) {
+        for id in self.initializations.drain(..) {
+            let texture = &self.storage[id];
+            encoder.init_texture(texture.raw);
+        }
+    }
+
+    fn flush(&mut self, encoder: &mut gpu::CommandEncoder) {
+        self.flush_initializations(encoder);
+
+        let mut transfers = encoder.transfer("atlas");
+        for upload in self.uploads.drain(..) {
+            let texture = &self.storage[upload.id];
+            transfers.copy_buffer_to_texture(
+                upload.data,
+                upload.bounds.size.width.to_bytes(texture.bytes_per_pixel()),
+                gpu::TexturePiece {
+                    texture: texture.raw,
+                    mip_level: 0,
+                    array_layer: 0,
+                    origin: [
+                        upload.bounds.origin.x.into(),
+                        upload.bounds.origin.y.into(),
+                        0,
+                    ],
+                },
+                gpu::Extent {
+                    width: upload.bounds.size.width.into(),
+                    height: upload.bounds.size.height.into(),
+                    depth: 1,
+                },
+            );
+        }
+    }
+}
+
+#[derive(Default)]
+struct BladeAtlasStorage {
+    monochrome_textures: AtlasTextureList<BladeAtlasTexture>,
+    polychrome_textures: AtlasTextureList<BladeAtlasTexture>,
+}
+
+impl ops::Index<AtlasTextureKind> for BladeAtlasStorage {
+    type Output = AtlasTextureList<BladeAtlasTexture>;
+    fn index(&self, kind: AtlasTextureKind) -> &Self::Output {
+        match kind {
+            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
+            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
+        }
+    }
+}
+
+impl ops::IndexMut<AtlasTextureKind> for BladeAtlasStorage {
+    fn index_mut(&mut self, kind: AtlasTextureKind) -> &mut Self::Output {
+        match kind {
+            crate::AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
+            crate::AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+        }
+    }
+}
+
+impl ops::Index<AtlasTextureId> for BladeAtlasStorage {
+    type Output = BladeAtlasTexture;
+    fn index(&self, id: AtlasTextureId) -> &Self::Output {
+        let textures = match id.kind {
+            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
+            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
+        };
+        textures[id.index as usize].as_ref().unwrap()
+    }
+}
+
+impl BladeAtlasStorage {
+    fn destroy(&mut self, gpu: &gpu::Context) {
+        for mut texture in self.monochrome_textures.drain().flatten() {
+            texture.destroy(gpu);
+        }
+        for mut texture in self.polychrome_textures.drain().flatten() {
+            texture.destroy(gpu);
+        }
+    }
+}
+
+struct BladeAtlasTexture {
+    id: AtlasTextureId,
+    allocator: BucketedAtlasAllocator,
+    raw: gpu::Texture,
+    raw_view: gpu::TextureView,
+    format: gpu::TextureFormat,
+    live_atlas_keys: u32,
+}
+
+impl BladeAtlasTexture {
+    fn allocate(&mut self, size: Size<DevicePixels>) -> Option<AtlasTile> {
+        let allocation = self.allocator.allocate(size.into())?;
+        let tile = AtlasTile {
+            texture_id: self.id,
+            tile_id: allocation.id.into(),
+            padding: 0,
+            bounds: Bounds {
+                origin: allocation.rectangle.min.into(),
+                size,
+            },
+        };
+        self.live_atlas_keys += 1;
+        Some(tile)
+    }
+
+    fn destroy(&mut self, gpu: &gpu::Context) {
+        gpu.destroy_texture(self.raw);
+        gpu.destroy_texture_view(self.raw_view);
+    }
+
+    fn bytes_per_pixel(&self) -> u8 {
+        self.format.block_info().size
+    }
+
+    fn decrement_ref_count(&mut self) {
+        self.live_atlas_keys -= 1;
+    }
+
+    fn is_unreferenced(&mut self) -> bool {
+        self.live_atlas_keys == 0
+    }
+}
+
+impl From<Size<DevicePixels>> for etagere::Size {
+    fn from(size: Size<DevicePixels>) -> Self {
+        etagere::Size::new(size.width.into(), size.height.into())
+    }
+}
+
+impl From<etagere::Point> for Point<DevicePixels> {
+    fn from(value: etagere::Point) -> Self {
+        Point {
+            x: DevicePixels::from(value.x),
+            y: DevicePixels::from(value.y),
+        }
+    }
+}
+
+impl From<etagere::Size> for Size<DevicePixels> {
+    fn from(size: etagere::Size) -> Self {
+        Size {
+            width: DevicePixels::from(size.width),
+            height: DevicePixels::from(size.height),
+        }
+    }
+}
+
+impl From<etagere::Rectangle> for Bounds<DevicePixels> {
+    fn from(rectangle: etagere::Rectangle) -> Self {
+        Bounds {
+            origin: rectangle.min.into(),
+            size: rectangle.size().into(),
+        }
+    }
+}

third_party/gpui/src/platform/blade/blade_context.rs

@@ -0,0 +1,80 @@
+use anyhow::Context as _;
+use blade_graphics as gpu;
+use std::sync::Arc;
+use util::ResultExt;
+
+#[cfg_attr(target_os = "macos", derive(Clone))]
+pub struct BladeContext {
+    pub(super) gpu: Arc<gpu::Context>,
+}
+
+impl BladeContext {
+    pub fn new() -> anyhow::Result<Self> {
+        let device_id_forced = match std::env::var("ZED_DEVICE_ID") {
+            Ok(val) => parse_pci_id(&val)
+                .context("Failed to parse device ID from `ZED_DEVICE_ID` environment variable")
+                .log_err(),
+            Err(std::env::VarError::NotPresent) => None,
+            err => {
+                err.context("Failed to read value of `ZED_DEVICE_ID` environment variable")
+                    .log_err();
+                None
+            }
+        };
+        let gpu = Arc::new(
+            unsafe {
+                gpu::Context::init(gpu::ContextDesc {
+                    presentation: true,
+                    validation: false,
+                    device_id: device_id_forced.unwrap_or(0),
+                    ..Default::default()
+                })
+            }
+            .map_err(|e| anyhow::anyhow!("{e:?}"))?,
+        );
+        Ok(Self { gpu })
+    }
+}
+
+fn parse_pci_id(id: &str) -> anyhow::Result<u32> {
+    let mut id = id.trim();
+
+    if id.starts_with("0x") || id.starts_with("0X") {
+        id = &id[2..];
+    }
+    let is_hex_string = id.chars().all(|c| c.is_ascii_hexdigit());
+    let is_4_chars = id.len() == 4;
+    anyhow::ensure!(
+        is_4_chars && is_hex_string,
+        "Expected a 4 digit PCI ID in hexadecimal format"
+    );
+
+    u32::from_str_radix(id, 16).context("parsing PCI ID as hex")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_pci_id;
+
+    #[test]
+    fn test_parse_device_id() {
+        assert!(parse_pci_id("0xABCD").is_ok());
+        assert!(parse_pci_id("ABCD").is_ok());
+        assert!(parse_pci_id("abcd").is_ok());
+        assert!(parse_pci_id("1234").is_ok());
+        assert!(parse_pci_id("123").is_err());
+        assert_eq!(
+            parse_pci_id(&format!("{:x}", 0x1234)).unwrap(),
+            parse_pci_id(&format!("{:X}", 0x1234)).unwrap(),
+        );
+
+        assert_eq!(
+            parse_pci_id(&format!("{:#x}", 0x1234)).unwrap(),
+            parse_pci_id(&format!("{:#X}", 0x1234)).unwrap(),
+        );
+        assert_eq!(
+            parse_pci_id(&format!("{:#x}", 0x1234)).unwrap(),
+            parse_pci_id(&format!("{:#X}", 0x1234)).unwrap(),
+        );
+    }
+}

third_party/gpui/src/platform/keyboard.rs

@@ -0,0 +1,41 @@
+use collections::HashMap;
+
+use crate::{KeybindingKeystroke, Keystroke};
+
+/// A trait for platform-specific keyboard layouts
+pub trait PlatformKeyboardLayout {
+    /// Get the keyboard layout ID, which should be unique to the layout
+    fn id(&self) -> &str;
+    /// Get the keyboard layout display name
+    fn name(&self) -> &str;
+}
+
+/// A trait for platform-specific keyboard mappings
+pub trait PlatformKeyboardMapper {
+    /// Map a key equivalent to its platform-specific representation
+    fn map_key_equivalent(
+        &self,
+        keystroke: Keystroke,
+        use_key_equivalents: bool,
+    ) -> KeybindingKeystroke;
+    /// Get the key equivalents for the current keyboard layout,
+    /// only used on macOS
+    fn get_key_equivalents(&self) -> Option<&HashMap<char, char>>;
+}
+
+/// A dummy implementation of the platform keyboard mapper
+pub struct DummyKeyboardMapper;
+
+impl PlatformKeyboardMapper for DummyKeyboardMapper {
+    fn map_key_equivalent(
+        &self,
+        keystroke: Keystroke,
+        _use_key_equivalents: bool,
+    ) -> KeybindingKeystroke {
+        KeybindingKeystroke::from_keystroke(keystroke)
+    }
+
+    fn get_key_equivalents(&self) -> Option<&HashMap<char, char>> {
+        None
+    }
+}

third_party/gpui/src/platform/keystroke.rs

@@ -0,0 +1,767 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{
+    error::Error,
+    fmt::{Display, Write},
+};
+
+use crate::PlatformKeyboardMapper;
+
+/// This is a helper trait so that we can simplify the implementation of some functions
+pub trait AsKeystroke {
+    /// Returns the GPUI representation of the keystroke.
+    fn as_keystroke(&self) -> &Keystroke;
+}
+
+/// A keystroke and associated metadata generated by the platform
+#[derive(Clone, Debug, Eq, PartialEq, Default, Deserialize, Hash)]
+pub struct Keystroke {
+    /// the state of the modifier keys at the time the keystroke was generated
+    pub modifiers: Modifiers,
+
+    /// key is the character printed on the key that was pressed
+    /// e.g. for option-s, key is "s"
+    /// On layouts that do not have ascii keys (e.g. Thai)
+    /// this will be the ASCII-equivalent character (q instead of ๆ),
+    /// and the typed character will be present in key_char.
+    pub key: String,
+
+    /// key_char is the character that could have been typed when
+    /// this binding was pressed.
+    /// e.g. for s this is "s", for option-s "ß", and cmd-s None
+    pub key_char: Option<String>,
+}
+
+/// Represents a keystroke that can be used in keybindings and displayed to the user.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct KeybindingKeystroke {
+    /// The GPUI representation of the keystroke.
+    inner: Keystroke,
+    /// The modifiers to display.
+    #[cfg(target_os = "windows")]
+    display_modifiers: Modifiers,
+    /// The key to display.
+    #[cfg(target_os = "windows")]
+    display_key: String,
+}
+
+/// Error type for `Keystroke::parse`. This is used instead of `anyhow::Error` so that Zed can use
+/// markdown to display it.
+#[derive(Debug)]
+pub struct InvalidKeystrokeError {
+    /// The invalid keystroke.
+    pub keystroke: String,
+}
+
+impl Error for InvalidKeystrokeError {}
+
+impl Display for InvalidKeystrokeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Invalid keystroke \"{}\". {}",
+            self.keystroke, KEYSTROKE_PARSE_EXPECTED_MESSAGE
+        )
+    }
+}
+
+/// Sentence explaining what keystroke parser expects, starting with "Expected ..."
+pub const KEYSTROKE_PARSE_EXPECTED_MESSAGE: &str = "Expected a sequence of modifiers \
+    (`ctrl`, `alt`, `shift`, `fn`, `cmd`, `super`, or `win`) \
+    followed by a key, separated by `-`.";
+
+impl Keystroke {
+    /// When matching a key we cannot know whether the user intended to type
+    /// the key_char or the key itself. On some non-US keyboards keys we use in our
+    /// bindings are behind option (for example `$` is typed `alt-ç` on a Czech keyboard),
+    /// and on some keyboards the IME handler converts a sequence of keys into a
+    /// specific character (for example `"` is typed as `" space` on a brazilian keyboard).
+    ///
+    /// This method assumes that `self` was typed and `target' is in the keymap, and checks
+    /// both possibilities for self against the target.
+    pub fn should_match(&self, target: &KeybindingKeystroke) -> bool {
+        #[cfg(not(target_os = "windows"))]
+        if let Some(key_char) = self
+            .key_char
+            .as_ref()
+            .filter(|key_char| key_char != &&self.key)
+        {
+            let ime_modifiers = Modifiers {
+                control: self.modifiers.control,
+                platform: self.modifiers.platform,
+                ..Default::default()
+            };
+
+            if &target.inner.key == key_char && target.inner.modifiers == ime_modifiers {
+                return true;
+            }
+        }
+
+        #[cfg(target_os = "windows")]
+        if let Some(key_char) = self
+            .key_char
+            .as_ref()
+            .filter(|key_char| key_char != &&self.key)
+        {
+            // On Windows, if key_char is set, then the typed keystroke produced the key_char
+            if &target.inner.key == key_char && target.inner.modifiers == Modifiers::none() {
+                return true;
+            }
+        }
+
+        target.inner.modifiers == self.modifiers && target.inner.key == self.key
+    }
+
+    /// key syntax is:
+    /// [secondary-][ctrl-][alt-][shift-][cmd-][fn-]key[->key_char]
+    /// key_char syntax is only used for generating test events,
+    /// secondary means "cmd" on macOS and "ctrl" on other platforms
+    /// when matching a key with an key_char set will be matched without it.
+    pub fn parse(source: &str) -> std::result::Result<Self, InvalidKeystrokeError> {
+        let mut modifiers = Modifiers::none();
+        let mut key = None;
+        let mut key_char = None;
+
+        let mut components = source.split('-').peekable();
+        while let Some(component) = components.next() {
+            if component.eq_ignore_ascii_case("ctrl") {
+                modifiers.control = true;
+                continue;
+            }
+            if component.eq_ignore_ascii_case("alt") {
+                modifiers.alt = true;
+                continue;
+            }
+            if component.eq_ignore_ascii_case("shift") {
+                modifiers.shift = true;
+                continue;
+            }
+            if component.eq_ignore_ascii_case("fn") {
+                modifiers.function = true;
+                continue;
+            }
+            if component.eq_ignore_ascii_case("secondary") {
+                if cfg!(target_os = "macos") {
+                    modifiers.platform = true;
+                } else {
+                    modifiers.control = true;
+                };
+                continue;
+            }
+
+            let is_platform = component.eq_ignore_ascii_case("cmd")
+                || component.eq_ignore_ascii_case("super")
+                || component.eq_ignore_ascii_case("win");
+
+            if is_platform {
+                modifiers.platform = true;
+                continue;
+            }
+
+            let mut key_str = component.to_string();
+
+            if let Some(next) = components.peek() {
+                if next.is_empty() && source.ends_with('-') {
+                    key = Some(String::from("-"));
+                    break;
+                } else if next.len() > 1 && next.starts_with('>') {
+                    key = Some(key_str);
+                    key_char = Some(String::from(&next[1..]));
+                    components.next();
+                } else {
+                    return Err(InvalidKeystrokeError {
+                        keystroke: source.to_owned(),
+                    });
+                }
+                continue;
+            }
+
+            if component.len() == 1 && component.as_bytes()[0].is_ascii_uppercase() {
+                // Convert to shift + lowercase char
+                modifiers.shift = true;
+                key_str.make_ascii_lowercase();
+            } else {
+                // convert ascii chars to lowercase so that named keys like "tab" and "enter"
+                // are accepted case insensitively and stored how we expect so they are matched properly
+                key_str.make_ascii_lowercase()
+            }
+            key = Some(key_str);
+        }
+
+        // Allow for the user to specify a keystroke modifier as the key itself
+        // This sets the `key` to the modifier, and disables the modifier
+        key = key.or_else(|| {
+            use std::mem;
+            // std::mem::take clears bool incase its true
+            if mem::take(&mut modifiers.shift) {
+                Some("shift".to_string())
+            } else if mem::take(&mut modifiers.control) {
+                Some("control".to_string())
+            } else if mem::take(&mut modifiers.alt) {
+                Some("alt".to_string())
+            } else if mem::take(&mut modifiers.platform) {
+                Some("platform".to_string())
+            } else if mem::take(&mut modifiers.function) {
+                Some("function".to_string())
+            } else {
+                None
+            }
+        });
+
+        let key = key.ok_or_else(|| InvalidKeystrokeError {
+            keystroke: source.to_owned(),
+        })?;
+
+        Ok(Keystroke {
+            modifiers,
+            key,
+            key_char,
+        })
+    }
+
+    /// Produces a representation of this key that Parse can understand.
+    pub fn unparse(&self) -> String {
+        unparse(&self.modifiers, &self.key)
+    }
+
+    /// Returns true if this keystroke left
+    /// the ime system in an incomplete state.
+    pub fn is_ime_in_progress(&self) -> bool {
+        self.key_char.is_none()
+            && (is_printable_key(&self.key) || self.key.is_empty())
+            && !(self.modifiers.platform
+                || self.modifiers.control
+                || self.modifiers.function
+                || self.modifiers.alt)
+    }
+
+    /// Returns a new keystroke with the key_char filled.
+    /// This is used for dispatch_keystroke where we want users to
+    /// be able to simulate typing "space", etc.
+    pub fn with_simulated_ime(mut self) -> Self {
+        if self.key_char.is_none()
+            && !self.modifiers.platform
+            && !self.modifiers.control
+            && !self.modifiers.function
+            && !self.modifiers.alt
+        {
+            self.key_char = match self.key.as_str() {
+                "space" => Some(" ".into()),
+                "tab" => Some("\t".into()),
+                "enter" => Some("\n".into()),
+                key if !is_printable_key(key) || key.is_empty() => None,
+                key => {
+                    if self.modifiers.shift {
+                        Some(key.to_uppercase())
+                    } else {
+                        Some(key.into())
+                    }
+                }
+            }
+        }
+        self
+    }
+}
+
+impl KeybindingKeystroke {
+    #[cfg(target_os = "windows")]
+    pub(crate) fn new(inner: Keystroke, display_modifiers: Modifiers, display_key: String) -> Self {
+        KeybindingKeystroke {
+            inner,
+            display_modifiers,
+            display_key,
+        }
+    }
+
+    /// Create a new keybinding keystroke from the given keystroke using the given keyboard mapper.
+    pub fn new_with_mapper(
+        inner: Keystroke,
+        use_key_equivalents: bool,
+        keyboard_mapper: &dyn PlatformKeyboardMapper,
+    ) -> Self {
+        keyboard_mapper.map_key_equivalent(inner, use_key_equivalents)
+    }
+
+    /// Create a new keybinding keystroke from the given keystroke, without any platform-specific mapping.
+    pub fn from_keystroke(keystroke: Keystroke) -> Self {
+        #[cfg(target_os = "windows")]
+        {
+            let key = keystroke.key.clone();
+            let modifiers = keystroke.modifiers;
+            KeybindingKeystroke {
+                inner: keystroke,
+                display_modifiers: modifiers,
+                display_key: key,
+            }
+        }
+        #[cfg(not(target_os = "windows"))]
+        {
+            KeybindingKeystroke { inner: keystroke }
+        }
+    }
+
+    /// Returns the GPUI representation of the keystroke.
+    pub fn inner(&self) -> &Keystroke {
+        &self.inner
+    }
+
+    /// Returns the modifiers.
+    ///
+    /// Platform-specific behavior:
+    /// - On macOS and Linux, this modifiers is the same as `inner.modifiers`, which is the GPUI representation of the keystroke.
+    /// - On Windows, this modifiers is the display modifiers, for example, a `ctrl-@` keystroke will have `inner.modifiers` as
+    /// `Modifiers::control()` and `display_modifiers` as `Modifiers::control_shift()`.
+    pub fn modifiers(&self) -> &Modifiers {
+        #[cfg(target_os = "windows")]
+        {
+            &self.display_modifiers
+        }
+        #[cfg(not(target_os = "windows"))]
+        {
+            &self.inner.modifiers
+        }
+    }
+
+    /// Returns the key.
+    ///
+    /// Platform-specific behavior:
+    /// - On macOS and Linux, this key is the same as `inner.key`, which is the GPUI representation of the keystroke.
+    /// - On Windows, this key is the display key, for example, a `ctrl-@` keystroke will have `inner.key` as `@` and `display_key` as `2`.
+    pub fn key(&self) -> &str {
+        #[cfg(target_os = "windows")]
+        {
+            &self.display_key
+        }
+        #[cfg(not(target_os = "windows"))]
+        {
+            &self.inner.key
+        }
+    }
+
+    /// Sets the modifiers. On Windows this modifies both `inner.modifiers` and `display_modifiers`.
+    pub fn set_modifiers(&mut self, modifiers: Modifiers) {
+        self.inner.modifiers = modifiers;
+        #[cfg(target_os = "windows")]
+        {
+            self.display_modifiers = modifiers;
+        }
+    }
+
+    /// Sets the key. On Windows this modifies both `inner.key` and `display_key`.
+    pub fn set_key(&mut self, key: String) {
+        #[cfg(target_os = "windows")]
+        {
+            self.display_key = key.clone();
+        }
+        self.inner.key = key;
+    }
+
+    /// Produces a representation of this key that Parse can understand.
+    pub fn unparse(&self) -> String {
+        #[cfg(target_os = "windows")]
+        {
+            unparse(&self.display_modifiers, &self.display_key)
+        }
+        #[cfg(not(target_os = "windows"))]
+        {
+            unparse(&self.inner.modifiers, &self.inner.key)
+        }
+    }
+
+    /// Removes the key_char
+    pub fn remove_key_char(&mut self) {
+        self.inner.key_char = None;
+    }
+}
+
+fn is_printable_key(key: &str) -> bool {
+    !matches!(
+        key,
+        "f1" | "f2"
+            | "f3"
+            | "f4"
+            | "f5"
+            | "f6"
+            | "f7"
+            | "f8"
+            | "f9"
+            | "f10"
+            | "f11"
+            | "f12"
+            | "f13"
+            | "f14"
+            | "f15"
+            | "f16"
+            | "f17"
+            | "f18"
+            | "f19"
+            | "f20"
+            | "f21"
+            | "f22"
+            | "f23"
+            | "f24"
+            | "f25"
+            | "f26"
+            | "f27"
+            | "f28"
+            | "f29"
+            | "f30"
+            | "f31"
+            | "f32"
+            | "f33"
+            | "f34"
+            | "f35"
+            | "backspace"
+            | "delete"
+            | "left"
+            | "right"
+            | "up"
+            | "down"
+            | "pageup"
+            | "pagedown"
+            | "insert"
+            | "home"
+            | "end"
+            | "back"
+            | "forward"
+            | "escape"
+    )
+}
+
+impl std::fmt::Display for Keystroke {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        display_modifiers(&self.modifiers, f)?;
+        display_key(&self.key, f)
+    }
+}
+
+impl std::fmt::Display for KeybindingKeystroke {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        display_modifiers(self.modifiers(), f)?;
+        display_key(self.key(), f)
+    }
+}
+
+/// The state of the modifier keys at some point in time
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize, Hash, JsonSchema)]
+pub struct Modifiers {
+    /// The control key
+    #[serde(default)]
+    pub control: bool,
+
+    /// The alt key
+    /// Sometimes also known as the 'meta' key
+    #[serde(default)]
+    pub alt: bool,
+
+    /// The shift key
+    #[serde(default)]
+    pub shift: bool,
+
+    /// The command key, on macos
+    /// the windows key, on windows
+    /// the super key, on linux
+    #[serde(default)]
+    pub platform: bool,
+
+    /// The function key
+    #[serde(default)]
+    pub function: bool,
+}
+
+impl Modifiers {
+    /// Returns whether any modifier key is pressed.
+    pub fn modified(&self) -> bool {
+        self.control || self.alt || self.shift || self.platform || self.function
+    }
+
+    /// Whether the semantically 'secondary' modifier key is pressed.
+    ///
+    /// On macOS, this is the command key.
+    /// On Linux and Windows, this is the control key.
+    pub fn secondary(&self) -> bool {
+        #[cfg(target_os = "macos")]
+        {
+            self.platform
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        {
+            self.control
+        }
+    }
+
+    /// Returns how many modifier keys are pressed.
+    pub fn number_of_modifiers(&self) -> u8 {
+        self.control as u8
+            + self.alt as u8
+            + self.shift as u8
+            + self.platform as u8
+            + self.function as u8
+    }
+
+    /// Returns [`Modifiers`] with no modifiers.
+    pub fn none() -> Modifiers {
+        Default::default()
+    }
+
+    /// Returns [`Modifiers`] with just the command key.
+    pub fn command() -> Modifiers {
+        Modifiers {
+            platform: true,
+            ..Default::default()
+        }
+    }
+
+    /// A Returns [`Modifiers`] with just the secondary key pressed.
+    pub fn secondary_key() -> Modifiers {
+        #[cfg(target_os = "macos")]
+        {
+            Modifiers {
+                platform: true,
+                ..Default::default()
+            }
+        }
+
+        #[cfg(not(target_os = "macos"))]
+        {
+            Modifiers {
+                control: true,
+                ..Default::default()
+            }
+        }
+    }
+
+    /// Returns [`Modifiers`] with just the windows key.
+    pub fn windows() -> Modifiers {
+        Modifiers {
+            platform: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns [`Modifiers`] with just the super key.
+    pub fn super_key() -> Modifiers {
+        Modifiers {
+            platform: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns [`Modifiers`] with just control.
+    pub fn control() -> Modifiers {
+        Modifiers {
+            control: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns [`Modifiers`] with just alt.
+    pub fn alt() -> Modifiers {
+        Modifiers {
+            alt: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns [`Modifiers`] with just shift.
+    pub fn shift() -> Modifiers {
+        Modifiers {
+            shift: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns [`Modifiers`] with command + shift.
+    pub fn command_shift() -> Modifiers {
+        Modifiers {
+            shift: true,
+            platform: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns [`Modifiers`] with command + shift.
+    pub fn control_shift() -> Modifiers {
+        Modifiers {
+            shift: true,
+            control: true,
+            ..Default::default()
+        }
+    }
+
+    /// Checks if this [`Modifiers`] is a subset of another [`Modifiers`].
+    pub fn is_subset_of(&self, other: &Modifiers) -> bool {
+        (*other & *self) == *self
+    }
+}
+
+impl std::ops::BitOr for Modifiers {
+    type Output = Self;
+
+    fn bitor(mut self, other: Self) -> Self::Output {
+        self |= other;
+        self
+    }
+}
+
+impl std::ops::BitOrAssign for Modifiers {
+    fn bitor_assign(&mut self, other: Self) {
+        self.control |= other.control;
+        self.alt |= other.alt;
+        self.shift |= other.shift;
+        self.platform |= other.platform;
+        self.function |= other.function;
+    }
+}
+
+impl std::ops::BitXor for Modifiers {
+    type Output = Self;
+    fn bitxor(mut self, rhs: Self) -> Self::Output {
+        self ^= rhs;
+        self
+    }
+}
+
+impl std::ops::BitXorAssign for Modifiers {
+    fn bitxor_assign(&mut self, other: Self) {
+        self.control ^= other.control;
+        self.alt ^= other.alt;
+        self.shift ^= other.shift;
+        self.platform ^= other.platform;
+        self.function ^= other.function;
+    }
+}
+
+impl std::ops::BitAnd for Modifiers {
+    type Output = Self;
+    fn bitand(mut self, rhs: Self) -> Self::Output {
+        self &= rhs;
+        self
+    }
+}
+
+impl std::ops::BitAndAssign for Modifiers {
+    fn bitand_assign(&mut self, other: Self) {
+        self.control &= other.control;
+        self.alt &= other.alt;
+        self.shift &= other.shift;
+        self.platform &= other.platform;
+        self.function &= other.function;
+    }
+}
+
+/// The state of the capslock key at some point in time
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize, Hash, JsonSchema)]
+pub struct Capslock {
+    /// The capslock key is on
+    #[serde(default)]
+    pub on: bool,
+}
+
+impl AsKeystroke for Keystroke {
+    fn as_keystroke(&self) -> &Keystroke {
+        self
+    }
+}
+
+impl AsKeystroke for KeybindingKeystroke {
+    fn as_keystroke(&self) -> &Keystroke {
+        &self.inner
+    }
+}
+
+fn display_modifiers(modifiers: &Modifiers, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    if modifiers.control {
+        #[cfg(target_os = "macos")]
+        f.write_char('^')?;
+
+        #[cfg(not(target_os = "macos"))]
+        write!(f, "ctrl-")?;
+    }
+    if modifiers.alt {
+        #[cfg(target_os = "macos")]
+        f.write_char('⌥')?;
+
+        #[cfg(not(target_os = "macos"))]
+        write!(f, "alt-")?;
+    }
+    if modifiers.platform {
+        #[cfg(target_os = "macos")]
+        f.write_char('⌘')?;
+
+        #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+        f.write_char('❖')?;
+
+        #[cfg(target_os = "windows")]
+        f.write_char('⊞')?;
+    }
+    if modifiers.shift {
+        #[cfg(target_os = "macos")]
+        f.write_char('⇧')?;
+
+        #[cfg(not(target_os = "macos"))]
+        write!(f, "shift-")?;
+    }
+    Ok(())
+}
+
+fn display_key(key: &str, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    let key = match key {
+        #[cfg(target_os = "macos")]
+        "backspace" => '⌫',
+        #[cfg(target_os = "macos")]
+        "up" => '↑',
+        #[cfg(target_os = "macos")]
+        "down" => '↓',
+        #[cfg(target_os = "macos")]
+        "left" => '←',
+        #[cfg(target_os = "macos")]
+        "right" => '→',
+        #[cfg(target_os = "macos")]
+        "tab" => '⇥',
+        #[cfg(target_os = "macos")]
+        "escape" => '⎋',
+        #[cfg(target_os = "macos")]
+        "shift" => '⇧',
+        #[cfg(target_os = "macos")]
+        "control" => '⌃',
+        #[cfg(target_os = "macos")]
+        "alt" => '⌥',
+        #[cfg(target_os = "macos")]
+        "platform" => '⌘',
+
+        key if key.len() == 1 => key.chars().next().unwrap().to_ascii_uppercase(),
+        key => return f.write_str(key),
+    };
+    f.write_char(key)
+}
+
+#[inline]
+fn unparse(modifiers: &Modifiers, key: &str) -> String {
+    let mut result = String::new();
+    if modifiers.function {
+        result.push_str("fn-");
+    }
+    if modifiers.control {
+        result.push_str("ctrl-");
+    }
+    if modifiers.alt {
+        result.push_str("alt-");
+    }
+    if modifiers.platform {
+        #[cfg(target_os = "macos")]
+        result.push_str("cmd-");
+
+        #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+        result.push_str("super-");
+
+        #[cfg(target_os = "windows")]
+        result.push_str("win-");
+    }
+    if modifiers.shift {
+        result.push_str("shift-");
+    }
+    result.push_str(&key);
+    result
+}

third_party/gpui/src/platform/linux.rs

@@ -0,0 +1,29 @@
+mod dispatcher;
+mod headless;
+mod keyboard;
+mod platform;
+#[cfg(any(feature = "wayland", feature = "x11"))]
+mod text_system;
+#[cfg(feature = "wayland")]
+mod wayland;
+#[cfg(feature = "x11")]
+mod x11;
+
+#[cfg(any(feature = "wayland", feature = "x11"))]
+mod xdg_desktop_portal;
+
+pub(crate) use dispatcher::*;
+pub(crate) use headless::*;
+pub(crate) use keyboard::*;
+pub(crate) use platform::*;
+#[cfg(any(feature = "wayland", feature = "x11"))]
+pub(crate) use text_system::*;
+#[cfg(feature = "wayland")]
+pub(crate) use wayland::*;
+#[cfg(feature = "x11")]
+pub(crate) use x11::*;
+
+#[cfg(all(feature = "screen-capture", any(feature = "wayland", feature = "x11")))]
+pub(crate) type PlatformScreenCaptureFrame = scap::frame::Frame;
+#[cfg(not(all(feature = "screen-capture", any(feature = "wayland", feature = "x11"))))]
+pub(crate) type PlatformScreenCaptureFrame = ();

third_party/gpui/src/platform/linux/dispatcher.rs

@@ -0,0 +1,129 @@
+use crate::{PlatformDispatcher, TaskLabel};
+use async_task::Runnable;
+use calloop::{
+    EventLoop,
+    channel::{self, Sender},
+    timer::TimeoutAction,
+};
+use std::{
+    thread,
+    time::{Duration, Instant},
+};
+use util::ResultExt;
+
+struct TimerAfter {
+    duration: Duration,
+    runnable: Runnable,
+}
+
+pub(crate) struct LinuxDispatcher {
+    main_sender: Sender<Runnable>,
+    timer_sender: Sender<TimerAfter>,
+    background_sender: flume::Sender<Runnable>,
+    _background_threads: Vec<thread::JoinHandle<()>>,
+    main_thread_id: thread::ThreadId,
+}
+
+impl LinuxDispatcher {
+    pub fn new(main_sender: Sender<Runnable>) -> Self {
+        let (background_sender, background_receiver) = flume::unbounded::<Runnable>();
+        let thread_count = std::thread::available_parallelism()
+            .map(|i| i.get())
+            .unwrap_or(1);
+
+        let mut background_threads = (0..thread_count)
+            .map(|i| {
+                let receiver = background_receiver.clone();
+                std::thread::Builder::new()
+                    .name(format!("Worker-{i}"))
+                    .spawn(move || {
+                        for runnable in receiver {
+                            let start = Instant::now();
+
+                            runnable.run();
+
+                            log::trace!(
+                                "background thread {}: ran runnable. took: {:?}",
+                                i,
+                                start.elapsed()
+                            );
+                        }
+                    })
+                    .unwrap()
+            })
+            .collect::<Vec<_>>();
+
+        let (timer_sender, timer_channel) = calloop::channel::channel::<TimerAfter>();
+        let timer_thread = std::thread::Builder::new()
+            .name("Timer".to_owned())
+            .spawn(|| {
+                let mut event_loop: EventLoop<()> =
+                    EventLoop::try_new().expect("Failed to initialize timer loop!");
+
+                let handle = event_loop.handle();
+                let timer_handle = event_loop.handle();
+                handle
+                    .insert_source(timer_channel, move |e, _, _| {
+                        if let channel::Event::Msg(timer) = e {
+                            // This has to be in an option to satisfy the borrow checker. The callback below should only be scheduled once.
+                            let mut runnable = Some(timer.runnable);
+                            timer_handle
+                                .insert_source(
+                                    calloop::timer::Timer::from_duration(timer.duration),
+                                    move |_, _, _| {
+                                        if let Some(runnable) = runnable.take() {
+                                            runnable.run();
+                                        }
+                                        TimeoutAction::Drop
+                                    },
+                                )
+                                .expect("Failed to start timer");
+                        }
+                    })
+                    .expect("Failed to start timer thread");
+
+                event_loop.run(None, &mut (), |_| {}).log_err();
+            })
+            .unwrap();
+
+        background_threads.push(timer_thread);
+
+        Self {
+            main_sender,
+            timer_sender,
+            background_sender,
+            _background_threads: background_threads,
+            main_thread_id: thread::current().id(),
+        }
+    }
+}
+
+impl PlatformDispatcher for LinuxDispatcher {
+    fn is_main_thread(&self) -> bool {
+        thread::current().id() == self.main_thread_id
+    }
+
+    fn dispatch(&self, runnable: Runnable, _: Option<TaskLabel>) {
+        self.background_sender.send(runnable).unwrap();
+    }
+
+    fn dispatch_on_main_thread(&self, runnable: Runnable) {
+        self.main_sender.send(runnable).unwrap_or_else(|runnable| {
+            // NOTE: Runnable may wrap a Future that is !Send.
+            //
+            // This is usually safe because we only poll it on the main thread.
+            // However if the send fails, we know that:
+            // 1. main_receiver has been dropped (which implies the app is shutting down)
+            // 2. we are on a background thread.
+            // It is not safe to drop something !Send on the wrong thread, and
+            // the app will exit soon anyway, so we must forget the runnable.
+            std::mem::forget(runnable);
+        });
+    }
+
+    fn dispatch_after(&self, duration: Duration, runnable: Runnable) {
+        self.timer_sender
+            .send(TimerAfter { duration, runnable })
+            .ok();
+    }
+}

third_party/gpui/src/platform/linux/headless.rs

@@ -0,0 +1,3 @@
+mod client;
+
+pub(crate) use client::*;

third_party/gpui/src/platform/linux/headless/client.rs

@@ -0,0 +1,134 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use calloop::{EventLoop, LoopHandle};
+use util::ResultExt;
+
+use crate::platform::linux::LinuxClient;
+use crate::platform::{LinuxCommon, PlatformWindow};
+use crate::{
+    AnyWindowHandle, CursorStyle, DisplayId, LinuxKeyboardLayout, PlatformDisplay,
+    PlatformKeyboardLayout, WindowParams,
+};
+
+pub struct HeadlessClientState {
+    pub(crate) _loop_handle: LoopHandle<'static, HeadlessClient>,
+    pub(crate) event_loop: Option<calloop::EventLoop<'static, HeadlessClient>>,
+    pub(crate) common: LinuxCommon,
+}
+
+#[derive(Clone)]
+pub(crate) struct HeadlessClient(Rc<RefCell<HeadlessClientState>>);
+
+impl HeadlessClient {
+    pub(crate) fn new() -> Self {
+        let event_loop = EventLoop::try_new().unwrap();
+
+        let (common, main_receiver) = LinuxCommon::new(event_loop.get_signal());
+
+        let handle = event_loop.handle();
+
+        handle
+            .insert_source(main_receiver, |event, _, _: &mut HeadlessClient| {
+                if let calloop::channel::Event::Msg(runnable) = event {
+                    runnable.run();
+                }
+            })
+            .ok();
+
+        HeadlessClient(Rc::new(RefCell::new(HeadlessClientState {
+            event_loop: Some(event_loop),
+            _loop_handle: handle,
+            common,
+        })))
+    }
+}
+
+impl LinuxClient for HeadlessClient {
+    fn with_common<R>(&self, f: impl FnOnce(&mut LinuxCommon) -> R) -> R {
+        f(&mut self.0.borrow_mut().common)
+    }
+
+    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
+        Box::new(LinuxKeyboardLayout::new("unknown".into()))
+    }
+
+    fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {
+        vec![]
+    }
+
+    fn primary_display(&self) -> Option<Rc<dyn PlatformDisplay>> {
+        None
+    }
+
+    fn display(&self, _id: DisplayId) -> Option<Rc<dyn PlatformDisplay>> {
+        None
+    }
+
+    #[cfg(feature = "screen-capture")]
+    fn is_screen_capture_supported(&self) -> bool {
+        false
+    }
+
+    #[cfg(feature = "screen-capture")]
+    fn screen_capture_sources(
+        &self,
+    ) -> futures::channel::oneshot::Receiver<anyhow::Result<Vec<Rc<dyn crate::ScreenCaptureSource>>>>
+    {
+        let (mut tx, rx) = futures::channel::oneshot::channel();
+        tx.send(Err(anyhow::anyhow!(
+            "Headless mode does not support screen capture."
+        )))
+        .ok();
+        rx
+    }
+
+    fn active_window(&self) -> Option<AnyWindowHandle> {
+        None
+    }
+
+    fn window_stack(&self) -> Option<Vec<AnyWindowHandle>> {
+        None
+    }
+
+    fn open_window(
+        &self,
+        _handle: AnyWindowHandle,
+        _params: WindowParams,
+    ) -> anyhow::Result<Box<dyn PlatformWindow>> {
+        anyhow::bail!("neither DISPLAY nor WAYLAND_DISPLAY is set. You can run in headless mode");
+    }
+
+    fn compositor_name(&self) -> &'static str {
+        "headless"
+    }
+
+    fn set_cursor_style(&self, _style: CursorStyle) {}
+
+    fn open_uri(&self, _uri: &str) {}
+
+    fn reveal_path(&self, _path: std::path::PathBuf) {}
+
+    fn write_to_primary(&self, _item: crate::ClipboardItem) {}
+
+    fn write_to_clipboard(&self, _item: crate::ClipboardItem) {}
+
+    fn read_from_primary(&self) -> Option<crate::ClipboardItem> {
+        None
+    }
+
+    fn read_from_clipboard(&self) -> Option<crate::ClipboardItem> {
+        None
+    }
+
+    fn run(&self) {
+        let mut event_loop = self
+            .0
+            .borrow_mut()
+            .event_loop
+            .take()
+            .expect("App is already running");
+
+        event_loop.run(None, &mut self.clone(), |_| {}).log_err();
+    }
+}

third_party/gpui/src/platform/linux/keyboard.rs

@@ -0,0 +1,22 @@
+use crate::{PlatformKeyboardLayout, SharedString};
+
+#[derive(Clone)]
+pub(crate) struct LinuxKeyboardLayout {
+    name: SharedString,
+}
+
+impl PlatformKeyboardLayout for LinuxKeyboardLayout {
+    fn id(&self) -> &str {
+        &self.name
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl LinuxKeyboardLayout {
+    pub(crate) fn new(name: SharedString) -> Self {
+        Self { name }
+    }
+}

third_party/gpui/src/platform/linux/text_system.rs

@@ -0,0 +1,581 @@
+use crate::{
+    Bounds, DevicePixels, Font, FontFeatures, FontId, FontMetrics, FontRun, FontStyle, FontWeight,
+    GlyphId, LineLayout, Pixels, PlatformTextSystem, Point, RenderGlyphParams, SUBPIXEL_VARIANTS_X,
+    SUBPIXEL_VARIANTS_Y, ShapedGlyph, ShapedRun, SharedString, Size, point, size,
+};
+use anyhow::{Context as _, Ok, Result};
+use collections::HashMap;
+use cosmic_text::{
+    Attrs, AttrsList, CacheKey, Family, Font as CosmicTextFont, FontFeatures as CosmicFontFeatures,
+    FontSystem, ShapeBuffer, ShapeLine, SwashCache,
+};
+
+use itertools::Itertools;
+use parking_lot::RwLock;
+use pathfinder_geometry::{
+    rect::{RectF, RectI},
+    vector::{Vector2F, Vector2I},
+};
+use smallvec::SmallVec;
+use std::{borrow::Cow, sync::Arc};
+
+pub(crate) struct CosmicTextSystem(RwLock<CosmicTextSystemState>);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct FontKey {
+    family: SharedString,
+    features: FontFeatures,
+}
+
+impl FontKey {
+    fn new(family: SharedString, features: FontFeatures) -> Self {
+        Self { family, features }
+    }
+}
+
+struct CosmicTextSystemState {
+    swash_cache: SwashCache,
+    font_system: FontSystem,
+    scratch: ShapeBuffer,
+    /// Contains all already loaded fonts, including all faces. Indexed by `FontId`.
+    loaded_fonts: Vec<LoadedFont>,
+    /// Caches the `FontId`s associated with a specific family to avoid iterating the font database
+    /// for every font face in a family.
+    font_ids_by_family_cache: HashMap<FontKey, SmallVec<[FontId; 4]>>,
+}
+
+struct LoadedFont {
+    font: Arc<CosmicTextFont>,
+    features: CosmicFontFeatures,
+    is_known_emoji_font: bool,
+}
+
+impl CosmicTextSystem {
+    pub(crate) fn new() -> Self {
+        // todo(linux) make font loading non-blocking
+        let mut font_system = FontSystem::new();
+
+        Self(RwLock::new(CosmicTextSystemState {
+            font_system,
+            swash_cache: SwashCache::new(),
+            scratch: ShapeBuffer::default(),
+            loaded_fonts: Vec::new(),
+            font_ids_by_family_cache: HashMap::default(),
+        }))
+    }
+}
+
+impl Default for CosmicTextSystem {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PlatformTextSystem for CosmicTextSystem {
+    fn add_fonts(&self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
+        self.0.write().add_fonts(fonts)
+    }
+
+    fn all_font_names(&self) -> Vec<String> {
+        let mut result = self
+            .0
+            .read()
+            .font_system
+            .db()
+            .faces()
+            .filter_map(|face| face.families.first().map(|family| family.0.clone()))
+            .collect_vec();
+        result.sort();
+        result.dedup();
+        result
+    }
+
+    fn font_id(&self, font: &Font) -> Result<FontId> {
+        // todo(linux): Do we need to use CosmicText's Font APIs? Can we consolidate this to use font_kit?
+        let mut state = self.0.write();
+        let key = FontKey::new(font.family.clone(), font.features.clone());
+        let candidates = if let Some(font_ids) = state.font_ids_by_family_cache.get(&key) {
+            font_ids.as_slice()
+        } else {
+            let font_ids = state.load_family(&font.family, &font.features)?;
+            state.font_ids_by_family_cache.insert(key.clone(), font_ids);
+            state.font_ids_by_family_cache[&key].as_ref()
+        };
+
+        // todo(linux) ideally we would make fontdb's `find_best_match` pub instead of using font-kit here
+        let candidate_properties = candidates
+            .iter()
+            .map(|font_id| {
+                let database_id = state.loaded_font(*font_id).font.id();
+                let face_info = state.font_system.db().face(database_id).expect("");
+                face_info_into_properties(face_info)
+            })
+            .collect::<SmallVec<[_; 4]>>();
+
+        let ix =
+            font_kit::matching::find_best_match(&candidate_properties, &font_into_properties(font))
+                .context("requested font family contains no font matching the other parameters")?;
+
+        Ok(candidates[ix])
+    }
+
+    fn font_metrics(&self, font_id: FontId) -> FontMetrics {
+        let metrics = self
+            .0
+            .read()
+            .loaded_font(font_id)
+            .font
+            .as_swash()
+            .metrics(&[]);
+
+        FontMetrics {
+            units_per_em: metrics.units_per_em as u32,
+            ascent: metrics.ascent,
+            descent: -metrics.descent, // todo(linux) confirm this is correct
+            line_gap: metrics.leading,
+            underline_position: metrics.underline_offset,
+            underline_thickness: metrics.stroke_size,
+            cap_height: metrics.cap_height,
+            x_height: metrics.x_height,
+            // todo(linux): Compute this correctly
+            bounding_box: Bounds {
+                origin: point(0.0, 0.0),
+                size: size(metrics.max_width, metrics.ascent + metrics.descent),
+            },
+        }
+    }
+
+    fn typographic_bounds(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Bounds<f32>> {
+        let lock = self.0.read();
+        let glyph_metrics = lock.loaded_font(font_id).font.as_swash().glyph_metrics(&[]);
+        let glyph_id = glyph_id.0 as u16;
+        // todo(linux): Compute this correctly
+        // see https://github.com/servo/font-kit/blob/master/src/loaders/freetype.rs#L614-L620
+        Ok(Bounds {
+            origin: point(0.0, 0.0),
+            size: size(
+                glyph_metrics.advance_width(glyph_id),
+                glyph_metrics.advance_height(glyph_id),
+            ),
+        })
+    }
+
+    fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
+        self.0.read().advance(font_id, glyph_id)
+    }
+
+    fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
+        self.0.read().glyph_for_char(font_id, ch)
+    }
+
+    fn glyph_raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
+        self.0.write().raster_bounds(params)
+    }
+
+    fn rasterize_glyph(
+        &self,
+        params: &RenderGlyphParams,
+        raster_bounds: Bounds<DevicePixels>,
+    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
+        self.0.write().rasterize_glyph(params, raster_bounds)
+    }
+
+    fn layout_line(&self, text: &str, font_size: Pixels, runs: &[FontRun]) -> LineLayout {
+        self.0.write().layout_line(text, font_size, runs)
+    }
+}
+
+impl CosmicTextSystemState {
+    fn loaded_font(&self, font_id: FontId) -> &LoadedFont {
+        &self.loaded_fonts[font_id.0]
+    }
+
+    #[profiling::function]
+    fn add_fonts(&mut self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
+        let db = self.font_system.db_mut();
+        for bytes in fonts {
+            match bytes {
+                Cow::Borrowed(embedded_font) => {
+                    db.load_font_data(embedded_font.to_vec());
+                }
+                Cow::Owned(bytes) => {
+                    db.load_font_data(bytes);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    #[profiling::function]
+    fn load_family(
+        &mut self,
+        name: &str,
+        features: &FontFeatures,
+    ) -> Result<SmallVec<[FontId; 4]>> {
+        // TODO: Determine the proper system UI font.
+        let name = crate::text_system::font_name_with_fallbacks(name, "IBM Plex Sans");
+
+        let families = self
+            .font_system
+            .db()
+            .faces()
+            .filter(|face| face.families.iter().any(|family| *name == family.0))
+            .map(|face| (face.id, face.post_script_name.clone()))
+            .collect::<SmallVec<[_; 4]>>();
+
+        let mut loaded_font_ids = SmallVec::new();
+        for (font_id, postscript_name) in families {
+            let font = self
+                .font_system
+                .get_font(font_id)
+                .context("Could not load font")?;
+
+            // HACK: To let the storybook run and render Windows caption icons. We should actually do better font fallback.
+            let allowed_bad_font_names = [
+                "SegoeFluentIcons", // NOTE: Segoe fluent icons postscript name is inconsistent
+                "Segoe Fluent Icons",
+            ];
+
+            if font.as_swash().charmap().map('m') == 0
+                && !allowed_bad_font_names.contains(&postscript_name.as_str())
+            {
+                self.font_system.db_mut().remove_face(font.id());
+                continue;
+            };
+
+            let font_id = FontId(self.loaded_fonts.len());
+            loaded_font_ids.push(font_id);
+            self.loaded_fonts.push(LoadedFont {
+                font,
+                features: features.try_into()?,
+                is_known_emoji_font: check_is_known_emoji_font(&postscript_name),
+            });
+        }
+
+        Ok(loaded_font_ids)
+    }
+
+    fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
+        let glyph_metrics = self.loaded_font(font_id).font.as_swash().glyph_metrics(&[]);
+        Ok(Size {
+            width: glyph_metrics.advance_width(glyph_id.0 as u16),
+            height: glyph_metrics.advance_height(glyph_id.0 as u16),
+        })
+    }
+
+    fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
+        let glyph_id = self.loaded_font(font_id).font.as_swash().charmap().map(ch);
+        if glyph_id == 0 {
+            None
+        } else {
+            Some(GlyphId(glyph_id.into()))
+        }
+    }
+
+    fn raster_bounds(&mut self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
+        let font = &self.loaded_fonts[params.font_id.0].font;
+        let subpixel_shift = point(
+            params.subpixel_variant.x as f32 / SUBPIXEL_VARIANTS_X as f32 / params.scale_factor,
+            params.subpixel_variant.y as f32 / SUBPIXEL_VARIANTS_Y as f32 / params.scale_factor,
+        );
+        let image = self
+            .swash_cache
+            .get_image(
+                &mut self.font_system,
+                CacheKey::new(
+                    font.id(),
+                    params.glyph_id.0 as u16,
+                    (params.font_size * params.scale_factor).into(),
+                    (subpixel_shift.x, subpixel_shift.y.trunc()),
+                    cosmic_text::CacheKeyFlags::empty(),
+                )
+                .0,
+            )
+            .clone()
+            .with_context(|| format!("no image for {params:?} in font {font:?}"))?;
+        Ok(Bounds {
+            origin: point(image.placement.left.into(), (-image.placement.top).into()),
+            size: size(image.placement.width.into(), image.placement.height.into()),
+        })
+    }
+
+    #[profiling::function]
+    fn rasterize_glyph(
+        &mut self,
+        params: &RenderGlyphParams,
+        glyph_bounds: Bounds<DevicePixels>,
+    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
+        if glyph_bounds.size.width.0 == 0 || glyph_bounds.size.height.0 == 0 {
+            anyhow::bail!("glyph bounds are empty");
+        } else {
+            let bitmap_size = glyph_bounds.size;
+            let font = &self.loaded_fonts[params.font_id.0].font;
+            let subpixel_shift = point(
+                params.subpixel_variant.x as f32 / SUBPIXEL_VARIANTS_X as f32 / params.scale_factor,
+                params.subpixel_variant.y as f32 / SUBPIXEL_VARIANTS_Y as f32 / params.scale_factor,
+            );
+            let mut image = self
+                .swash_cache
+                .get_image(
+                    &mut self.font_system,
+                    CacheKey::new(
+                        font.id(),
+                        params.glyph_id.0 as u16,
+                        (params.font_size * params.scale_factor).into(),
+                        (subpixel_shift.x, subpixel_shift.y.trunc()),
+                        cosmic_text::CacheKeyFlags::empty(),
+                    )
+                    .0,
+                )
+                .clone()
+                .with_context(|| format!("no image for {params:?} in font {font:?}"))?;
+
+            if params.is_emoji {
+                // Convert from RGBA to BGRA.
+                for pixel in image.data.chunks_exact_mut(4) {
+                    pixel.swap(0, 2);
+                }
+            }
+
+            Ok((bitmap_size, image.data))
+        }
+    }
+
+    /// This is used when cosmic_text has chosen a fallback font instead of using the requested
+    /// font, typically to handle some unicode characters. When this happens, `loaded_fonts` may not
+    /// yet have an entry for this fallback font, and so one is added.
+    ///
+    /// Note that callers shouldn't use this `FontId` somewhere that will retrieve the corresponding
+    /// `LoadedFont.features`, as it will have an arbitrarily chosen or empty value. The only
+    /// current use of this field is for the *input* of `layout_line`, and so it's fine to use
+    /// `font_id_for_cosmic_id` when computing the *output* of `layout_line`.
+    fn font_id_for_cosmic_id(&mut self, id: cosmic_text::fontdb::ID) -> FontId {
+        if let Some(ix) = self
+            .loaded_fonts
+            .iter()
+            .position(|loaded_font| loaded_font.font.id() == id)
+        {
+            FontId(ix)
+        } else {
+            let font = self.font_system.get_font(id).unwrap();
+            let face = self.font_system.db().face(id).unwrap();
+
+            let font_id = FontId(self.loaded_fonts.len());
+            self.loaded_fonts.push(LoadedFont {
+                font,
+                features: CosmicFontFeatures::new(),
+                is_known_emoji_font: check_is_known_emoji_font(&face.post_script_name),
+            });
+
+            font_id
+        }
+    }
+
+    #[profiling::function]
+    fn layout_line(&mut self, text: &str, font_size: Pixels, font_runs: &[FontRun]) -> LineLayout {
+        let mut attrs_list = AttrsList::new(&Attrs::new());
+        let mut offs = 0;
+        for run in font_runs {
+            let loaded_font = self.loaded_font(run.font_id);
+            let font = self.font_system.db().face(loaded_font.font.id()).unwrap();
+
+            attrs_list.add_span(
+                offs..(offs + run.len),
+                &Attrs::new()
+                    .metadata(run.font_id.0)
+                    .family(Family::Name(&font.families.first().unwrap().0))
+                    .stretch(font.stretch)
+                    .style(font.style)
+                    .weight(font.weight)
+                    .font_features(loaded_font.features.clone()),
+            );
+            offs += run.len;
+        }
+
+        let line = ShapeLine::new(
+            &mut self.font_system,
+            text,
+            &attrs_list,
+            cosmic_text::Shaping::Advanced,
+            4,
+        );
+        let mut layout_lines = Vec::with_capacity(1);
+        line.layout_to_buffer(
+            &mut self.scratch,
+            font_size.0,
+            None, // We do our own wrapping
+            cosmic_text::Wrap::None,
+            None,
+            &mut layout_lines,
+            None,
+        );
+        let layout = layout_lines.first().unwrap();
+
+        let mut runs: Vec<ShapedRun> = Vec::new();
+        for glyph in &layout.glyphs {
+            let mut font_id = FontId(glyph.metadata);
+            let mut loaded_font = self.loaded_font(font_id);
+            if loaded_font.font.id() != glyph.font_id {
+                font_id = self.font_id_for_cosmic_id(glyph.font_id);
+                loaded_font = self.loaded_font(font_id);
+            }
+            let is_emoji = loaded_font.is_known_emoji_font;
+
+            // HACK: Prevent crash caused by variation selectors.
+            if glyph.glyph_id == 3 && is_emoji {
+                continue;
+            }
+
+            let shaped_glyph = ShapedGlyph {
+                id: GlyphId(glyph.glyph_id as u32),
+                position: point(glyph.x.into(), glyph.y.into()),
+                index: glyph.start,
+                is_emoji,
+            };
+
+            if let Some(last_run) = runs
+                .last_mut()
+                .filter(|last_run| last_run.font_id == font_id)
+            {
+                last_run.glyphs.push(shaped_glyph);
+            } else {
+                runs.push(ShapedRun {
+                    font_id,
+                    glyphs: vec![shaped_glyph],
+                });
+            }
+        }
+
+        LineLayout {
+            font_size,
+            width: layout.w.into(),
+            ascent: layout.max_ascent.into(),
+            descent: layout.max_descent.into(),
+            runs,
+            len: text.len(),
+        }
+    }
+}
+
+impl TryFrom<&FontFeatures> for CosmicFontFeatures {
+    type Error = anyhow::Error;
+
+    fn try_from(features: &FontFeatures) -> Result<Self> {
+        let mut result = CosmicFontFeatures::new();
+        for feature in features.0.iter() {
+            let name_bytes: [u8; 4] = feature
+                .0
+                .as_bytes()
+                .try_into()
+                .context("Incorrect feature flag format")?;
+
+            let tag = cosmic_text::FeatureTag::new(&name_bytes);
+
+            result.set(tag, feature.1);
+        }
+        Ok(result)
+    }
+}
+
+impl From<RectF> for Bounds<f32> {
+    fn from(rect: RectF) -> Self {
+        Bounds {
+            origin: point(rect.origin_x(), rect.origin_y()),
+            size: size(rect.width(), rect.height()),
+        }
+    }
+}
+
+impl From<RectI> for Bounds<DevicePixels> {
+    fn from(rect: RectI) -> Self {
+        Bounds {
+            origin: point(DevicePixels(rect.origin_x()), DevicePixels(rect.origin_y())),
+            size: size(DevicePixels(rect.width()), DevicePixels(rect.height())),
+        }
+    }
+}
+
+impl From<Vector2I> for Size<DevicePixels> {
+    fn from(value: Vector2I) -> Self {
+        size(value.x().into(), value.y().into())
+    }
+}
+
+impl From<RectI> for Bounds<i32> {
+    fn from(rect: RectI) -> Self {
+        Bounds {
+            origin: point(rect.origin_x(), rect.origin_y()),
+            size: size(rect.width(), rect.height()),
+        }
+    }
+}
+
+impl From<Point<u32>> for Vector2I {
+    fn from(size: Point<u32>) -> Self {
+        Vector2I::new(size.x as i32, size.y as i32)
+    }
+}
+
+impl From<Vector2F> for Size<f32> {
+    fn from(vec: Vector2F) -> Self {
+        size(vec.x(), vec.y())
+    }
+}
+
+impl From<FontWeight> for cosmic_text::Weight {
+    fn from(value: FontWeight) -> Self {
+        cosmic_text::Weight(value.0 as u16)
+    }
+}
+
+impl From<FontStyle> for cosmic_text::Style {
+    fn from(style: FontStyle) -> Self {
+        match style {
+            FontStyle::Normal => cosmic_text::Style::Normal,
+            FontStyle::Italic => cosmic_text::Style::Italic,
+            FontStyle::Oblique => cosmic_text::Style::Oblique,
+        }
+    }
+}
+
+fn font_into_properties(font: &crate::Font) -> font_kit::properties::Properties {
+    font_kit::properties::Properties {
+        style: match font.style {
+            crate::FontStyle::Normal => font_kit::properties::Style::Normal,
+            crate::FontStyle::Italic => font_kit::properties::Style::Italic,
+            crate::FontStyle::Oblique => font_kit::properties::Style::Oblique,
+        },
+        weight: font_kit::properties::Weight(font.weight.0),
+        stretch: Default::default(),
+    }
+}
+
+fn face_info_into_properties(
+    face_info: &cosmic_text::fontdb::FaceInfo,
+) -> font_kit::properties::Properties {
+    font_kit::properties::Properties {
+        style: match face_info.style {
+            cosmic_text::Style::Normal => font_kit::properties::Style::Normal,
+            cosmic_text::Style::Italic => font_kit::properties::Style::Italic,
+            cosmic_text::Style::Oblique => font_kit::properties::Style::Oblique,
+        },
+        // both libs use the same values for weight
+        weight: font_kit::properties::Weight(face_info.weight.0.into()),
+        stretch: match face_info.stretch {
+            cosmic_text::Stretch::Condensed => font_kit::properties::Stretch::CONDENSED,
+            cosmic_text::Stretch::Expanded => font_kit::properties::Stretch::EXPANDED,
+            cosmic_text::Stretch::ExtraCondensed => font_kit::properties::Stretch::EXTRA_CONDENSED,
+            cosmic_text::Stretch::ExtraExpanded => font_kit::properties::Stretch::EXTRA_EXPANDED,
+            cosmic_text::Stretch::Normal => font_kit::properties::Stretch::NORMAL,
+            cosmic_text::Stretch::SemiCondensed => font_kit::properties::Stretch::SEMI_CONDENSED,
+            cosmic_text::Stretch::SemiExpanded => font_kit::properties::Stretch::SEMI_EXPANDED,
+            cosmic_text::Stretch::UltraCondensed => font_kit::properties::Stretch::ULTRA_CONDENSED,
+            cosmic_text::Stretch::UltraExpanded => font_kit::properties::Stretch::ULTRA_EXPANDED,
+        },
+    }
+}
+
+fn check_is_known_emoji_font(postscript_name: &str) -> bool {
+    // TODO: Include other common emoji fonts
+    postscript_name == "NotoColorEmoji"
+}

third_party/gpui/src/platform/linux/wayland.rs

@@ -0,0 +1,46 @@
+mod client;
+mod clipboard;
+mod cursor;
+mod display;
+mod serial;
+mod window;
+
+pub(crate) use client::*;
+
+use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::Shape;
+
+use crate::CursorStyle;
+
+impl CursorStyle {
+    pub(super) fn to_shape(self) -> Shape {
+        match self {
+            CursorStyle::Arrow => Shape::Default,
+            CursorStyle::IBeam => Shape::Text,
+            CursorStyle::Crosshair => Shape::Crosshair,
+            CursorStyle::ClosedHand => Shape::Grabbing,
+            CursorStyle::OpenHand => Shape::Grab,
+            CursorStyle::PointingHand => Shape::Pointer,
+            CursorStyle::ResizeLeft => Shape::WResize,
+            CursorStyle::ResizeRight => Shape::EResize,
+            CursorStyle::ResizeLeftRight => Shape::EwResize,
+            CursorStyle::ResizeUp => Shape::NResize,
+            CursorStyle::ResizeDown => Shape::SResize,
+            CursorStyle::ResizeUpDown => Shape::NsResize,
+            CursorStyle::ResizeUpLeftDownRight => Shape::NwseResize,
+            CursorStyle::ResizeUpRightDownLeft => Shape::NeswResize,
+            CursorStyle::ResizeColumn => Shape::ColResize,
+            CursorStyle::ResizeRow => Shape::RowResize,
+            CursorStyle::IBeamCursorForVerticalLayout => Shape::VerticalText,
+            CursorStyle::OperationNotAllowed => Shape::NotAllowed,
+            CursorStyle::DragLink => Shape::Alias,
+            CursorStyle::DragCopy => Shape::Copy,
+            CursorStyle::ContextualMenu => Shape::ContextMenu,
+            CursorStyle::None => {
+                #[cfg(debug_assertions)]
+                panic!("CursorStyle::None should be handled separately in the client");
+                #[cfg(not(debug_assertions))]
+                Shape::Default
+            }
+        }
+    }
+}

third_party/gpui/src/platform/linux/wayland/clipboard.rs

@@ -0,0 +1,262 @@
+use std::{
+    fs::File,
+    io::{ErrorKind, Write},
+    os::fd::{AsRawFd, BorrowedFd, OwnedFd},
+};
+
+use calloop::{LoopHandle, PostAction};
+use filedescriptor::Pipe;
+use strum::IntoEnumIterator;
+use wayland_client::{Connection, protocol::wl_data_offer::WlDataOffer};
+use wayland_protocols::wp::primary_selection::zv1::client::zwp_primary_selection_offer_v1::ZwpPrimarySelectionOfferV1;
+
+use crate::{
+    ClipboardEntry, ClipboardItem, Image, ImageFormat, WaylandClientStatePtr, hash,
+    platform::linux::platform::read_fd,
+};
+
+/// Text mime types that we'll offer to other programs.
+pub(crate) const TEXT_MIME_TYPES: [&str; 3] =
+    ["text/plain;charset=utf-8", "UTF8_STRING", "text/plain"];
+pub(crate) const FILE_LIST_MIME_TYPE: &str = "text/uri-list";
+
+/// Text mime types that we'll accept from other programs.
+pub(crate) const ALLOWED_TEXT_MIME_TYPES: [&str; 2] = ["text/plain;charset=utf-8", "UTF8_STRING"];
+
+pub(crate) struct Clipboard {
+    connection: Connection,
+    loop_handle: LoopHandle<'static, WaylandClientStatePtr>,
+    self_mime: String,
+
+    // Internal clipboard
+    contents: Option<ClipboardItem>,
+    primary_contents: Option<ClipboardItem>,
+
+    // External clipboard
+    cached_read: Option<ClipboardItem>,
+    current_offer: Option<DataOffer<WlDataOffer>>,
+    cached_primary_read: Option<ClipboardItem>,
+    current_primary_offer: Option<DataOffer<ZwpPrimarySelectionOfferV1>>,
+}
+
+pub(crate) trait ReceiveData {
+    fn receive_data(&self, mime_type: String, fd: BorrowedFd<'_>);
+}
+
+impl ReceiveData for WlDataOffer {
+    fn receive_data(&self, mime_type: String, fd: BorrowedFd<'_>) {
+        self.receive(mime_type, fd);
+    }
+}
+
+impl ReceiveData for ZwpPrimarySelectionOfferV1 {
+    fn receive_data(&self, mime_type: String, fd: BorrowedFd<'_>) {
+        self.receive(mime_type, fd);
+    }
+}
+
+#[derive(Clone, Debug)]
+/// Wrapper for `WlDataOffer` and `ZwpPrimarySelectionOfferV1`, used to help track mime types.
+pub(crate) struct DataOffer<T: ReceiveData> {
+    pub inner: T,
+    mime_types: Vec<String>,
+}
+
+impl<T: ReceiveData> DataOffer<T> {
+    pub fn new(offer: T) -> Self {
+        Self {
+            inner: offer,
+            mime_types: Vec::new(),
+        }
+    }
+
+    pub fn add_mime_type(&mut self, mime_type: String) {
+        self.mime_types.push(mime_type)
+    }
+
+    fn has_mime_type(&self, mime_type: &str) -> bool {
+        self.mime_types.iter().any(|t| t == mime_type)
+    }
+
+    fn read_bytes(&self, connection: &Connection, mime_type: &str) -> Option<Vec<u8>> {
+        let pipe = Pipe::new().unwrap();
+        self.inner.receive_data(mime_type.to_string(), unsafe {
+            BorrowedFd::borrow_raw(pipe.write.as_raw_fd())
+        });
+        let fd = pipe.read;
+        drop(pipe.write);
+
+        connection.flush().unwrap();
+
+        match unsafe { read_fd(fd) } {
+            Ok(bytes) => Some(bytes),
+            Err(err) => {
+                log::error!("error reading clipboard pipe: {err:?}");
+                None
+            }
+        }
+    }
+
+    fn read_text(&self, connection: &Connection) -> Option<ClipboardItem> {
+        let mime_type = self.mime_types.iter().find(|&mime_type| {
+            ALLOWED_TEXT_MIME_TYPES
+                .iter()
+                .any(|&allowed| allowed == mime_type)
+        })?;
+        let bytes = self.read_bytes(connection, mime_type)?;
+        let text_content = match String::from_utf8(bytes) {
+            Ok(content) => content,
+            Err(e) => {
+                log::error!("Failed to convert clipboard content to UTF-8: {}", e);
+                return None;
+            }
+        };
+
+        // Normalize the text to unix line endings, otherwise
+        // copying from eg: firefox inserts a lot of blank
+        // lines, and that is super annoying.
+        let result = text_content.replace("\r\n", "\n");
+        Some(ClipboardItem::new_string(result))
+    }
+
+    fn read_image(&self, connection: &Connection) -> Option<ClipboardItem> {
+        for format in ImageFormat::iter() {
+            let mime_type = format.mime_type();
+            if !self.has_mime_type(mime_type) {
+                continue;
+            }
+
+            if let Some(bytes) = self.read_bytes(connection, mime_type) {
+                let id = hash(&bytes);
+                return Some(ClipboardItem {
+                    entries: vec![ClipboardEntry::Image(Image { format, bytes, id })],
+                });
+            }
+        }
+        None
+    }
+}
+
+impl Clipboard {
+    pub fn new(
+        connection: Connection,
+        loop_handle: LoopHandle<'static, WaylandClientStatePtr>,
+    ) -> Self {
+        Self {
+            connection,
+            loop_handle,
+            self_mime: format!("pid/{}", std::process::id()),
+
+            contents: None,
+            primary_contents: None,
+
+            cached_read: None,
+            current_offer: None,
+            cached_primary_read: None,
+            current_primary_offer: None,
+        }
+    }
+
+    pub fn set(&mut self, item: ClipboardItem) {
+        self.contents = Some(item);
+    }
+
+    pub fn set_primary(&mut self, item: ClipboardItem) {
+        self.primary_contents = Some(item);
+    }
+
+    pub fn set_offer(&mut self, data_offer: Option<DataOffer<WlDataOffer>>) {
+        self.cached_read = None;
+        self.current_offer = data_offer;
+    }
+
+    pub fn set_primary_offer(&mut self, data_offer: Option<DataOffer<ZwpPrimarySelectionOfferV1>>) {
+        self.cached_primary_read = None;
+        self.current_primary_offer = data_offer;
+    }
+
+    pub fn self_mime(&self) -> String {
+        self.self_mime.clone()
+    }
+
+    pub fn send(&self, _mime_type: String, fd: OwnedFd) {
+        if let Some(text) = self.contents.as_ref().and_then(|contents| contents.text()) {
+            self.send_internal(fd, text.as_bytes().to_owned());
+        }
+    }
+
+    pub fn send_primary(&self, _mime_type: String, fd: OwnedFd) {
+        if let Some(text) = self
+            .primary_contents
+            .as_ref()
+            .and_then(|contents| contents.text())
+        {
+            self.send_internal(fd, text.as_bytes().to_owned());
+        }
+    }
+
+    pub fn read(&mut self) -> Option<ClipboardItem> {
+        let offer = self.current_offer.as_ref()?;
+        if let Some(cached) = self.cached_read.clone() {
+            return Some(cached);
+        }
+
+        if offer.has_mime_type(&self.self_mime) {
+            return self.contents.clone();
+        }
+
+        let item = offer
+            .read_text(&self.connection)
+            .or_else(|| offer.read_image(&self.connection))?;
+
+        self.cached_read = Some(item.clone());
+        Some(item)
+    }
+
+    pub fn read_primary(&mut self) -> Option<ClipboardItem> {
+        let offer = self.current_primary_offer.as_ref()?;
+        if let Some(cached) = self.cached_primary_read.clone() {
+            return Some(cached);
+        }
+
+        if offer.has_mime_type(&self.self_mime) {
+            return self.primary_contents.clone();
+        }
+
+        let item = offer
+            .read_text(&self.connection)
+            .or_else(|| offer.read_image(&self.connection))?;
+
+        self.cached_primary_read = Some(item.clone());
+        Some(item)
+    }
+
+    fn send_internal(&self, fd: OwnedFd, bytes: Vec<u8>) {
+        let mut written = 0;
+        self.loop_handle
+            .insert_source(
+                calloop::generic::Generic::new(
+                    File::from(fd),
+                    calloop::Interest::WRITE,
+                    calloop::Mode::Level,
+                ),
+                move |_, file, _| {
+                    let mut file = unsafe { file.get_mut() };
+                    loop {
+                        match file.write(&bytes[written..]) {
+                            Ok(n) if written + n == bytes.len() => {
+                                written += n;
+                                break Ok(PostAction::Remove);
+                            }
+                            Ok(n) => written += n,
+                            Err(err) if err.kind() == ErrorKind::WouldBlock => {
+                                break Ok(PostAction::Continue);
+                            }
+                            Err(_) => break Ok(PostAction::Remove),
+                        }
+                    }
+                },
+            )
+            .unwrap();
+    }
+}

third_party/gpui/src/platform/linux/wayland/cursor.rs

@@ -0,0 +1,152 @@
+use crate::Globals;
+use crate::platform::linux::{DEFAULT_CURSOR_ICON_NAME, log_cursor_icon_warning};
+use anyhow::{Context as _, anyhow};
+use util::ResultExt;
+
+use wayland_client::Connection;
+use wayland_client::protocol::wl_surface::WlSurface;
+use wayland_client::protocol::{wl_pointer::WlPointer, wl_shm::WlShm};
+use wayland_cursor::{CursorImageBuffer, CursorTheme};
+
+pub(crate) struct Cursor {
+    loaded_theme: Option<LoadedTheme>,
+    size: u32,
+    scaled_size: u32,
+    surface: WlSurface,
+    shm: WlShm,
+    connection: Connection,
+}
+
+pub(crate) struct LoadedTheme {
+    theme: CursorTheme,
+    name: Option<String>,
+    scaled_size: u32,
+}
+
+impl Drop for Cursor {
+    fn drop(&mut self) {
+        self.loaded_theme.take();
+        self.surface.destroy();
+    }
+}
+
+impl Cursor {
+    pub fn new(connection: &Connection, globals: &Globals, size: u32) -> Self {
+        let mut this = Self {
+            loaded_theme: None,
+            size,
+            scaled_size: size,
+            surface: globals.compositor.create_surface(&globals.qh, ()),
+            shm: globals.shm.clone(),
+            connection: connection.clone(),
+        };
+        this.set_theme_internal(None);
+        this
+    }
+
+    fn set_theme_internal(&mut self, theme_name: Option<String>) {
+        if let Some(loaded_theme) = self.loaded_theme.as_ref()
+            && loaded_theme.name == theme_name
+            && loaded_theme.scaled_size == self.scaled_size
+        {
+            return;
+        }
+        let result = if let Some(theme_name) = theme_name.as_ref() {
+            CursorTheme::load_from_name(
+                &self.connection,
+                self.shm.clone(),
+                theme_name,
+                self.scaled_size,
+            )
+        } else {
+            CursorTheme::load(&self.connection, self.shm.clone(), self.scaled_size)
+        };
+        if let Some(theme) = result
+            .context("Wayland: Failed to load cursor theme")
+            .log_err()
+        {
+            self.loaded_theme = Some(LoadedTheme {
+                theme,
+                name: theme_name,
+                scaled_size: self.scaled_size,
+            });
+        }
+    }
+
+    pub fn set_theme(&mut self, theme_name: String) {
+        self.set_theme_internal(Some(theme_name));
+    }
+
+    fn set_scaled_size(&mut self, scaled_size: u32) {
+        self.scaled_size = scaled_size;
+        let theme_name = self
+            .loaded_theme
+            .as_ref()
+            .and_then(|loaded_theme| loaded_theme.name.clone());
+        self.set_theme_internal(theme_name);
+    }
+
+    pub fn set_size(&mut self, size: u32) {
+        self.size = size;
+        self.set_scaled_size(size);
+    }
+
+    pub fn set_icon(
+        &mut self,
+        wl_pointer: &WlPointer,
+        serial_id: u32,
+        mut cursor_icon_names: &[&str],
+        scale: i32,
+    ) {
+        self.set_scaled_size(self.size * scale as u32);
+
+        let Some(loaded_theme) = &mut self.loaded_theme else {
+            log::warn!("Wayland: Unable to load cursor themes");
+            return;
+        };
+        let mut theme = &mut loaded_theme.theme;
+
+        let mut buffer: &CursorImageBuffer;
+        'outer: {
+            for cursor_icon_name in cursor_icon_names {
+                if let Some(cursor) = theme.get_cursor(cursor_icon_name) {
+                    buffer = &cursor[0];
+                    break 'outer;
+                }
+            }
+
+            if let Some(cursor) = theme.get_cursor(DEFAULT_CURSOR_ICON_NAME) {
+                buffer = &cursor[0];
+                log_cursor_icon_warning(anyhow!(
+                    "wayland: Unable to get cursor icon {:?}. \
+                    Using default cursor icon: '{}'",
+                    cursor_icon_names,
+                    DEFAULT_CURSOR_ICON_NAME
+                ));
+            } else {
+                log_cursor_icon_warning(anyhow!(
+                    "wayland: Unable to fallback on default cursor icon '{}' for theme '{}'",
+                    DEFAULT_CURSOR_ICON_NAME,
+                    loaded_theme.name.as_deref().unwrap_or("default")
+                ));
+                return;
+            }
+        }
+
+        let (width, height) = buffer.dimensions();
+        let (hot_x, hot_y) = buffer.hotspot();
+
+        self.surface.set_buffer_scale(scale);
+
+        wl_pointer.set_cursor(
+            serial_id,
+            Some(&self.surface),
+            hot_x as i32 / scale,
+            hot_y as i32 / scale,
+        );
+
+        self.surface.attach(Some(buffer), 0, 0);
+        self.surface.damage(0, 0, width as i32, height as i32);
+        self.surface.commit();
+    }
+}

third_party/gpui/src/platform/linux/wayland/display.rs

@@ -0,0 +1,42 @@
+use std::{
+    fmt::Debug,
+    hash::{Hash, Hasher},
+};
+
+use anyhow::Context as _;
+use uuid::Uuid;
+use wayland_backend::client::ObjectId;
+
+use crate::{Bounds, DisplayId, Pixels, PlatformDisplay};
+
+#[derive(Debug, Clone)]
+pub(crate) struct WaylandDisplay {
+    /// The ID of the wl_output object
+    pub id: ObjectId,
+    pub name: Option<String>,
+    pub bounds: Bounds<Pixels>,
+}
+
+impl Hash for WaylandDisplay {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+    }
+}
+
+impl PlatformDisplay for WaylandDisplay {
+    fn id(&self) -> DisplayId {
+        DisplayId(self.id.protocol_id())
+    }
+
+    fn uuid(&self) -> anyhow::Result<Uuid> {
+        let name = self
+            .name
+            .as_ref()
+            .context("Wayland display does not have a name")?;
+        Ok(Uuid::new_v5(&Uuid::NAMESPACE_DNS, name.as_bytes()))
+    }
+
+    fn bounds(&self) -> Bounds<Pixels> {
+        self.bounds
+    }
+}

third_party/gpui/src/platform/linux/wayland/serial.rs

@@ -0,0 +1,49 @@
+use collections::HashMap;
+
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub(crate) enum SerialKind {
+    DataDevice,
+    InputMethod,
+    MouseEnter,
+    MousePress,
+    KeyPress,
+}
+
+#[derive(Debug)]
+struct SerialData {
+    serial: u32,
+}
+
+impl SerialData {
+    fn new(value: u32) -> Self {
+        Self { serial: value }
+    }
+}
+
+#[derive(Debug)]
+/// Helper for tracking of different serial kinds.
+pub(crate) struct SerialTracker {
+    serials: HashMap<SerialKind, SerialData>,
+}
+
+impl SerialTracker {
+    pub fn new() -> Self {
+        Self {
+            serials: HashMap::default(),
+        }
+    }
+
+    pub fn update(&mut self, kind: SerialKind, value: u32) {
+        self.serials.insert(kind, SerialData::new(value));
+    }
+
+    /// Returns the latest tracked serial of the provided [`SerialKind`]
+    ///
+    /// Will return 0 if not tracked.
+    pub fn get(&self, kind: SerialKind) -> u32 {
+        self.serials
+            .get(&kind)
+            .map(|serial_data| serial_data.serial)
+            .unwrap_or(0)
+    }
+}

third_party/gpui/src/platform/linux/x11.rs

@@ -0,0 +1,12 @@
+mod client;
+mod clipboard;
+mod display;
+mod event;
+mod window;
+mod xim_handler;
+
+pub(crate) use client::*;
+pub(crate) use display::*;
+pub(crate) use event::*;
+pub(crate) use window::*;
+pub(crate) use xim_handler::*;

third_party/gpui/src/platform/linux/x11/display.rs

@@ -0,0 +1,51 @@
+use anyhow::Context as _;
+use uuid::Uuid;
+use x11rb::{connection::Connection as _, xcb_ffi::XCBConnection};
+
+use crate::{Bounds, DisplayId, Pixels, PlatformDisplay, Size, px};
+
+#[derive(Debug)]
+pub(crate) struct X11Display {
+    x_screen_index: usize,
+    bounds: Bounds<Pixels>,
+    uuid: Uuid,
+}
+
+impl X11Display {
+    pub(crate) fn new(
+        xcb: &XCBConnection,
+        scale_factor: f32,
+        x_screen_index: usize,
+    ) -> anyhow::Result<Self> {
+        let screen = xcb
+            .setup()
+            .roots
+            .get(x_screen_index)
+            .with_context(|| format!("No screen found with index {x_screen_index}"))?;
+        Ok(Self {
+            x_screen_index,
+            bounds: Bounds {
+                origin: Default::default(),
+                size: Size {
+                    width: px(screen.width_in_pixels as f32 / scale_factor),
+                    height: px(screen.height_in_pixels as f32 / scale_factor),
+                },
+            },
+            uuid: Uuid::from_bytes([0; 16]),
+        })
+    }
+}
+
+impl PlatformDisplay for X11Display {
+    fn id(&self) -> DisplayId {
+        DisplayId(self.x_screen_index as u32)
+    }
+
+    fn uuid(&self) -> anyhow::Result<Uuid> {
+        Ok(self.uuid)
+    }
+
+    fn bounds(&self) -> Bounds<Pixels> {
+        self.bounds
+    }
+}

third_party/gpui/src/platform/linux/x11/event.rs

@@ -0,0 +1,154 @@
+use x11rb::protocol::{
+    xinput,
+    xproto::{self, ModMask},
+};
+
+use crate::{Modifiers, MouseButton, NavigationDirection};
+
+pub(crate) enum ButtonOrScroll {
+    Button(MouseButton),
+    Scroll(ScrollDirection),
+}
+
+pub(crate) enum ScrollDirection {
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+pub(crate) fn button_or_scroll_from_event_detail(detail: u32) -> Option<ButtonOrScroll> {
+    Some(match detail {
+        1 => ButtonOrScroll::Button(MouseButton::Left),
+        2 => ButtonOrScroll::Button(MouseButton::Middle),
+        3 => ButtonOrScroll::Button(MouseButton::Right),
+        4 => ButtonOrScroll::Scroll(ScrollDirection::Up),
+        5 => ButtonOrScroll::Scroll(ScrollDirection::Down),
+        6 => ButtonOrScroll::Scroll(ScrollDirection::Left),
+        7 => ButtonOrScroll::Scroll(ScrollDirection::Right),
+        8 => ButtonOrScroll::Button(MouseButton::Navigate(NavigationDirection::Back)),
+        9 => ButtonOrScroll::Button(MouseButton::Navigate(NavigationDirection::Forward)),
+        _ => return None,
+    })
+}
+
+pub(crate) fn modifiers_from_state(state: xproto::KeyButMask) -> Modifiers {
+    Modifiers {
+        control: state.contains(xproto::KeyButMask::CONTROL),
+        alt: state.contains(xproto::KeyButMask::MOD1),
+        shift: state.contains(xproto::KeyButMask::SHIFT),
+        platform: state.contains(xproto::KeyButMask::MOD4),
+        function: false,
+    }
+}
+
+pub(crate) fn modifiers_from_xinput_info(modifier_info: xinput::ModifierInfo) -> Modifiers {
+    Modifiers {
+        control: modifier_info.effective as u16 & ModMask::CONTROL.bits()
+            == ModMask::CONTROL.bits(),
+        alt: modifier_info.effective as u16 & ModMask::M1.bits() == ModMask::M1.bits(),
+        shift: modifier_info.effective as u16 & ModMask::SHIFT.bits() == ModMask::SHIFT.bits(),
+        platform: modifier_info.effective as u16 & ModMask::M4.bits() == ModMask::M4.bits(),
+        function: false,
+    }
+}
+
+pub(crate) fn pressed_button_from_mask(button_mask: u32) -> Option<MouseButton> {
+    Some(if button_mask & 2 == 2 {
+        MouseButton::Left
+    } else if button_mask & 4 == 4 {
+        MouseButton::Middle
+    } else if button_mask & 8 == 8 {
+        MouseButton::Right
+    } else {
+        return None;
+    })
+}
+
+pub(crate) fn get_valuator_axis_index(
+    valuator_mask: &Vec<u32>,
+    valuator_number: u16,
+) -> Option<usize> {
+    // XInput valuator masks have a 1 at the bit indexes corresponding to each
+    // valuator present in this event's axisvalues. Axisvalues is ordered from
+    // lowest valuator number to highest, so counting bits before the 1 bit for
+    // this valuator yields the index in axisvalues.
+    if bit_is_set_in_vec(valuator_mask, valuator_number) {
+        Some(popcount_upto_bit_index(valuator_mask, valuator_number) as usize)
+    } else {
+        None
+    }
+}
+
+/// Returns the number of 1 bits in `bit_vec` for all bits where `i < bit_index`.
+fn popcount_upto_bit_index(bit_vec: &Vec<u32>, bit_index: u16) -> u32 {
+    let array_index = bit_index as usize / 32;
+    let popcount: u32 = bit_vec
+        .get(array_index)
+        .map_or(0, |bits| keep_bits_upto(*bits, bit_index % 32).count_ones());
+    if array_index == 0 {
+        popcount
+    } else {
+        // Valuator numbers over 32 probably never occur for scroll position, but may as well
+        // support it.
+        let leading_popcount: u32 = bit_vec
+            .iter()
+            .take(array_index)
+            .map(|bits| bits.count_ones())
+            .sum();
+        popcount + leading_popcount
+    }
+}
+
+fn bit_is_set_in_vec(bit_vec: &Vec<u32>, bit_index: u16) -> bool {
+    let array_index = bit_index as usize / 32;
+    bit_vec
+        .get(array_index)
+        .is_some_and(|bits| bit_is_set(*bits, bit_index % 32))
+}
+
+fn bit_is_set(bits: u32, bit_index: u16) -> bool {
+    bits & (1 << bit_index) != 0
+}
+
+/// Sets every bit with `i >= bit_index` to 0.
+fn keep_bits_upto(bits: u32, bit_index: u16) -> u32 {
+    if bit_index == 0 {
+        0
+    } else if bit_index >= 32 {
+        u32::MAX
+    } else {
+        bits & ((1 << bit_index) - 1)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_valuator_axis_index() {
+        assert!(get_valuator_axis_index(&vec![0b11], 0) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b11], 1) == Some(1));
+        assert!(get_valuator_axis_index(&vec![0b11], 2) == None);
+
+        assert!(get_valuator_axis_index(&vec![0b100], 0) == None);
+        assert!(get_valuator_axis_index(&vec![0b100], 1) == None);
+        assert!(get_valuator_axis_index(&vec![0b100], 2) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b100], 3) == None);
+
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 0) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 1) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 2) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0], 3) == Some(1));
+
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 0) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 1) == Some(0));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 2) == None);
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 3) == Some(1));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 32) == Some(2));
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b1], 33) == None);
+
+        assert!(get_valuator_axis_index(&vec![0b1010, 0b101], 34) == Some(3));
+    }
+}

third_party/gpui/src/platform/linux/x11/xim_handler.rs

@@ -0,0 +1,133 @@
+use std::default::Default;
+
+use x11rb::protocol::{Event, xproto};
+use xim::{AHashMap, AttributeName, Client, ClientError, ClientHandler, InputStyle};
+
+pub enum XimCallbackEvent {
+    XimXEvent(x11rb::protocol::Event),
+    XimPreeditEvent(xproto::Window, String),
+    XimCommitEvent(xproto::Window, String),
+}
+
+pub struct XimHandler {
+    pub im_id: u16,
+    pub ic_id: u16,
+    pub connected: bool,
+    pub window: xproto::Window,
+    pub last_callback_event: Option<XimCallbackEvent>,
+}
+
+impl XimHandler {
+    pub fn new() -> Self {
+        Self {
+            im_id: Default::default(),
+            ic_id: Default::default(),
+            connected: false,
+            window: Default::default(),
+            last_callback_event: None,
+        }
+    }
+}
+
+impl<C: Client<XEvent = xproto::KeyPressEvent>> ClientHandler<C> for XimHandler {
+    fn handle_connect(&mut self, client: &mut C) -> Result<(), ClientError> {
+        client.open("C")
+    }
+
+    fn handle_open(&mut self, client: &mut C, input_method_id: u16) -> Result<(), ClientError> {
+        self.im_id = input_method_id;
+
+        client.get_im_values(input_method_id, &[AttributeName::QueryInputStyle])
+    }
+
+    fn handle_get_im_values(
+        &mut self,
+        client: &mut C,
+        input_method_id: u16,
+        _attributes: AHashMap<AttributeName, Vec<u8>>,
+    ) -> Result<(), ClientError> {
+        let ic_attributes = client
+            .build_ic_attributes()
+            .push(AttributeName::InputStyle, InputStyle::PREEDIT_CALLBACKS)
+            .push(AttributeName::ClientWindow, self.window)
+            .push(AttributeName::FocusWindow, self.window)
+            .build();
+        client.create_ic(input_method_id, ic_attributes)
+    }
+
+    fn handle_create_ic(
+        &mut self,
+        _client: &mut C,
+        _input_method_id: u16,
+        input_context_id: u16,
+    ) -> Result<(), ClientError> {
+        self.connected = true;
+        self.ic_id = input_context_id;
+        Ok(())
+    }
+
+    fn handle_commit(
+        &mut self,
+        _client: &mut C,
+        _input_method_id: u16,
+        _input_context_id: u16,
+        text: &str,
+    ) -> Result<(), ClientError> {
+        self.last_callback_event = Some(XimCallbackEvent::XimCommitEvent(
+            self.window,
+            String::from(text),
+        ));
+        Ok(())
+    }
+
+    fn handle_forward_event(
+        &mut self,
+        _client: &mut C,
+        _input_method_id: u16,
+        _input_context_id: u16,
+        _flag: xim::ForwardEventFlag,
+        xev: C::XEvent,
+    ) -> Result<(), ClientError> {
+        match xev.response_type {
+            x11rb::protocol::xproto::KEY_PRESS_EVENT => {
+                self.last_callback_event = Some(XimCallbackEvent::XimXEvent(Event::KeyPress(xev)));
+            }
+            x11rb::protocol::xproto::KEY_RELEASE_EVENT => {
+                self.last_callback_event =
+                    Some(XimCallbackEvent::XimXEvent(Event::KeyRelease(xev)));
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn handle_close(&mut self, client: &mut C, _input_method_id: u16) -> Result<(), ClientError> {
+        client.disconnect()
+    }
+
+    fn handle_preedit_draw(
+        &mut self,
+        _client: &mut C,
+        _input_method_id: u16,
+        _input_context_id: u16,
+        _caret: i32,
+        _chg_first: i32,
+        _chg_len: i32,
+        _status: xim::PreeditDrawStatus,
+        preedit_string: &str,
+        _feedbacks: Vec<xim::Feedback>,
+    ) -> Result<(), ClientError> {
+        // XIMReverse: 1, XIMPrimary: 8, XIMTertiary: 32: selected text
+        // XIMUnderline: 2, XIMSecondary: 16: underlined text
+        // XIMHighlight: 4: normal text
+        // XIMVisibleToForward: 64, XIMVisibleToBackward: 128, XIMVisibleCenter: 256: text align position
+        // XIMPrimary, XIMHighlight, XIMSecondary, XIMTertiary are not specified,
+        // but interchangeable as above
+        // Currently there's no way to support these.
+        self.last_callback_event = Some(XimCallbackEvent::XimPreeditEvent(
+            self.window,
+            String::from(preedit_string),
+        ));
+        Ok(())
+    }
+}

third_party/gpui/src/platform/linux/xdg_desktop_portal.rs

@@ -0,0 +1,171 @@
+//! Provides a [calloop] event source from [XDG Desktop Portal] events
+//!
+//! This module uses the [ashpd] crate
+
+use ashpd::desktop::settings::{ColorScheme, Settings};
+use calloop::channel::Channel;
+use calloop::{EventSource, Poll, PostAction, Readiness, Token, TokenFactory};
+use smol::stream::StreamExt;
+
+use crate::{BackgroundExecutor, WindowAppearance};
+
+pub enum Event {
+    WindowAppearance(WindowAppearance),
+    #[cfg_attr(feature = "x11", allow(dead_code))]
+    CursorTheme(String),
+    #[cfg_attr(feature = "x11", allow(dead_code))]
+    CursorSize(u32),
+}
+
+pub struct XDPEventSource {
+    channel: Channel<Event>,
+}
+
+impl XDPEventSource {
+    pub fn new(executor: &BackgroundExecutor) -> Self {
+        let (sender, channel) = calloop::channel::channel();
+
+        let background = executor.clone();
+
+        executor
+            .spawn(async move {
+                let settings = Settings::new().await?;
+
+                if let Ok(initial_appearance) = settings.color_scheme().await {
+                    sender.send(Event::WindowAppearance(WindowAppearance::from_native(
+                        initial_appearance,
+                    )))?;
+                }
+                if let Ok(initial_theme) = settings
+                    .read::<String>("org.gnome.desktop.interface", "cursor-theme")
+                    .await
+                {
+                    sender.send(Event::CursorTheme(initial_theme))?;
+                }
+
+                // If u32 is used here, it throws invalid type error
+                if let Ok(initial_size) = settings
+                    .read::<i32>("org.gnome.desktop.interface", "cursor-size")
+                    .await
+                {
+                    sender.send(Event::CursorSize(initial_size as u32))?;
+                }
+
+                if let Ok(mut cursor_theme_changed) = settings
+                    .receive_setting_changed_with_args(
+                        "org.gnome.desktop.interface",
+                        "cursor-theme",
+                    )
+                    .await
+                {
+                    let sender = sender.clone();
+                    background
+                        .spawn(async move {
+                            while let Some(theme) = cursor_theme_changed.next().await {
+                                let theme = theme?;
+                                sender.send(Event::CursorTheme(theme))?;
+                            }
+                            anyhow::Ok(())
+                        })
+                        .detach();
+                }
+
+                if let Ok(mut cursor_size_changed) = settings
+                    .receive_setting_changed_with_args::<i32>(
+                        "org.gnome.desktop.interface",
+                        "cursor-size",
+                    )
+                    .await
+                {
+                    let sender = sender.clone();
+                    background
+                        .spawn(async move {
+                            while let Some(size) = cursor_size_changed.next().await {
+                                let size = size?;
+                                sender.send(Event::CursorSize(size as u32))?;
+                            }
+                            anyhow::Ok(())
+                        })
+                        .detach();
+                }
+
+                let mut appearance_changed = settings.receive_color_scheme_changed().await?;
+                while let Some(scheme) = appearance_changed.next().await {
+                    sender.send(Event::WindowAppearance(WindowAppearance::from_native(
+                        scheme,
+                    )))?;
+                }
+
+                anyhow::Ok(())
+            })
+            .detach();
+
+        Self { channel }
+    }
+}
+
+impl EventSource for XDPEventSource {
+    type Event = Event;
+    type Metadata = ();
+    type Ret = ();
+    type Error = anyhow::Error;
+
+    fn process_events<F>(
+        &mut self,
+        readiness: Readiness,
+        token: Token,
+        mut callback: F,
+    ) -> Result<PostAction, Self::Error>
+    where
+        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
+    {
+        self.channel.process_events(readiness, token, |evt, _| {
+            if let calloop::channel::Event::Msg(msg) = evt {
+                (callback)(msg, &mut ())
+            }
+        })?;
+
+        Ok(PostAction::Continue)
+    }
+
+    fn register(
+        &mut self,
+        poll: &mut Poll,
+        token_factory: &mut TokenFactory,
+    ) -> calloop::Result<()> {
+        self.channel.register(poll, token_factory)?;
+
+        Ok(())
+    }
+
+    fn reregister(
+        &mut self,
+        poll: &mut Poll,
+        token_factory: &mut TokenFactory,
+    ) -> calloop::Result<()> {
+        self.channel.reregister(poll, token_factory)?;
+
+        Ok(())
+    }
+
+    fn unregister(&mut self, poll: &mut Poll) -> calloop::Result<()> {
+        self.channel.unregister(poll)?;
+
+        Ok(())
+    }
+}
+
+impl WindowAppearance {
+    fn from_native(cs: ColorScheme) -> WindowAppearance {
+        match cs {
+            ColorScheme::PreferDark => WindowAppearance::Dark,
+            ColorScheme::PreferLight => WindowAppearance::Light,
+            ColorScheme::NoPreference => WindowAppearance::Light,
+        }
+    }
+
+    #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
+    fn set_native(&mut self, cs: ColorScheme) {
+        *self = Self::from_native(cs);
+    }
+}

third_party/gpui/src/platform/mac.rs

@@ -0,0 +1,163 @@
+//! Macos screen have a y axis that goings up from the bottom of the screen and
+//! an origin at the bottom left of the main display.
+mod dispatcher;
+mod display;
+mod display_link;
+mod events;
+mod keyboard;
+
+#[cfg(feature = "screen-capture")]
+mod screen_capture;
+
+#[cfg(not(feature = "macos-blade"))]
+mod metal_atlas;
+#[cfg(not(feature = "macos-blade"))]
+pub mod metal_renderer;
+
+use core_video::image_buffer::CVImageBuffer;
+#[cfg(not(feature = "macos-blade"))]
+use metal_renderer as renderer;
+
+#[cfg(feature = "macos-blade")]
+use crate::platform::blade as renderer;
+
+mod attributed_string;
+
+#[cfg(feature = "font-kit")]
+mod open_type;
+
+#[cfg(feature = "font-kit")]
+mod text_system;
+
+mod platform;
+mod window;
+mod window_appearance;
+
+use crate::{DevicePixels, Pixels, Size, px, size};
+use cocoa::{
+    base::{id, nil},
+    foundation::{NSAutoreleasePool, NSNotFound, NSRect, NSSize, NSString, NSUInteger},
+};
+
+use objc::runtime::{BOOL, NO, YES};
+use std::{
+    ffi::{CStr, c_char},
+    ops::Range,
+};
+
+pub(crate) use dispatcher::*;
+pub(crate) use display::*;
+pub(crate) use display_link::*;
+pub(crate) use keyboard::*;
+pub(crate) use platform::*;
+pub(crate) use window::*;
+
+#[cfg(feature = "font-kit")]
+pub(crate) use text_system::*;
+
+/// A frame of video captured from a screen.
+pub(crate) type PlatformScreenCaptureFrame = CVImageBuffer;
+
+trait BoolExt {
+    fn to_objc(self) -> BOOL;
+}
+
+impl BoolExt for bool {
+    fn to_objc(self) -> BOOL {
+        if self { YES } else { NO }
+    }
+}
+
+trait NSStringExt {
+    unsafe fn to_str(&self) -> &str;
+}
+
+impl NSStringExt for id {
+    unsafe fn to_str(&self) -> &str {
+        unsafe {
+            let cstr = self.UTF8String();
+            if cstr.is_null() {
+                ""
+            } else {
+                CStr::from_ptr(cstr as *mut c_char).to_str().unwrap()
+            }
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+struct NSRange {
+    pub location: NSUInteger,
+    pub length: NSUInteger,
+}
+
+impl NSRange {
+    fn invalid() -> Self {
+        Self {
+            location: NSNotFound as NSUInteger,
+            length: 0,
+        }
+    }
+
+    fn is_valid(&self) -> bool {
+        self.location != NSNotFound as NSUInteger
+    }
+
+    fn to_range(self) -> Option<Range<usize>> {
+        if self.is_valid() {
+            let start = self.location as usize;
+            let end = start + self.length as usize;
+            Some(start..end)
+        } else {
+            None
+        }
+    }
+}
+
+impl From<Range<usize>> for NSRange {
+    fn from(range: Range<usize>) -> Self {
+        NSRange {
+            location: range.start as NSUInteger,
+            length: range.len() as NSUInteger,
+        }
+    }
+}
+
+unsafe impl objc::Encode for NSRange {
+    fn encode() -> objc::Encoding {
+        let encoding = format!(
+            "{{NSRange={}{}}}",
+            NSUInteger::encode().as_str(),
+            NSUInteger::encode().as_str()
+        );
+        unsafe { objc::Encoding::from_str(&encoding) }
+    }
+}
+
+unsafe fn ns_string(string: &str) -> id {
+    unsafe { NSString::alloc(nil).init_str(string).autorelease() }
+}
+
+impl From<NSSize> for Size<Pixels> {
+    fn from(value: NSSize) -> Self {
+        Size {
+            width: px(value.width as f32),
+            height: px(value.height as f32),
+        }
+    }
+}
+
+impl From<NSRect> for Size<Pixels> {
+    fn from(rect: NSRect) -> Self {
+        let NSSize { width, height } = rect.size;
+        size(width.into(), height.into())
+    }
+}
+
+impl From<NSRect> for Size<DevicePixels> {
+    fn from(rect: NSRect) -> Self {
+        let NSSize { width, height } = rect.size;
+        size(DevicePixels(width as i32), DevicePixels(height as i32))
+    }
+}

third_party/gpui/src/platform/mac/attributed_string.rs

@@ -0,0 +1,119 @@
+use cocoa::base::id;
+use cocoa::foundation::NSRange;
+use objc::{class, msg_send, sel, sel_impl};
+
+/// The `cocoa` crate does not define NSAttributedString (and related Cocoa classes),
+/// which are needed for copying rich text (that is, text intermingled with images)
+/// to the clipboard. This adds access to those APIs.
+#[allow(non_snake_case)]
+pub trait NSAttributedString: Sized {
+    unsafe fn alloc(_: Self) -> id {
+        msg_send![class!(NSAttributedString), alloc]
+    }
+
+    unsafe fn init_attributed_string(self, string: id) -> id;
+    unsafe fn appendAttributedString_(self, attr_string: id);
+    unsafe fn RTFDFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id;
+    unsafe fn RTFFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id;
+    unsafe fn string(self) -> id;
+}
+
+impl NSAttributedString for id {
+    unsafe fn init_attributed_string(self, string: id) -> id {
+        msg_send![self, initWithString: string]
+    }
+
+    unsafe fn appendAttributedString_(self, attr_string: id) {
+        let _: () = msg_send![self, appendAttributedString: attr_string];
+    }
+
+    unsafe fn RTFDFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id {
+        msg_send![self, RTFDFromRange: range documentAttributes: attrs]
+    }
+
+    unsafe fn RTFFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id {
+        msg_send![self, RTFFromRange: range documentAttributes: attrs]
+    }
+
+    unsafe fn string(self) -> id {
+        msg_send![self, string]
+    }
+}
+
+pub trait NSMutableAttributedString: NSAttributedString {
+    unsafe fn alloc(_: Self) -> id {
+        msg_send![class!(NSMutableAttributedString), alloc]
+    }
+}
+
+impl NSMutableAttributedString for id {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use cocoa::appkit::NSImage;
+    use cocoa::base::nil;
+    use cocoa::foundation::NSString;
+    #[test]
+    #[ignore] // This was SIGSEGV-ing on CI but not locally; need to investigate https://github.com/zed-industries/zed/actions/runs/10362363230/job/28684225486?pr=15782#step:4:1348
+    fn test_nsattributed_string() {
+        // TODO move these to parent module once it's actually ready to be used
+        #[allow(non_snake_case)]
+        pub trait NSTextAttachment: Sized {
+            unsafe fn alloc(_: Self) -> id {
+                msg_send![class!(NSTextAttachment), alloc]
+            }
+        }
+
+        impl NSTextAttachment for id {}
+
+        unsafe {
+            let image: id = msg_send![class!(NSImage), alloc];
+            image.initWithContentsOfFile_(NSString::alloc(nil).init_str("test.jpeg"));
+            let _size = image.size();
+
+            let string = NSString::alloc(nil).init_str("Test String");
+            let attr_string = NSMutableAttributedString::alloc(nil).init_attributed_string(string);
+            let hello_string = NSString::alloc(nil).init_str("Hello World");
+            let hello_attr_string =
+                NSAttributedString::alloc(nil).init_attributed_string(hello_string);
+            attr_string.appendAttributedString_(hello_attr_string);
+
+            let attachment = NSTextAttachment::alloc(nil);
+            let _: () = msg_send![attachment, setImage: image];
+            let image_attr_string =
+                msg_send![class!(NSAttributedString), attributedStringWithAttachment: attachment];
+            attr_string.appendAttributedString_(image_attr_string);
+
+            let another_string = NSString::alloc(nil).init_str("Another String");
+            let another_attr_string =
+                NSAttributedString::alloc(nil).init_attributed_string(another_string);
+            attr_string.appendAttributedString_(another_attr_string);
+
+            let _len: cocoa::foundation::NSUInteger = msg_send![attr_string, length];
+
+            ///////////////////////////////////////////////////
+            // pasteboard.clearContents();
+
+            let rtfd_data = attr_string.RTFDFromRange_documentAttributes_(
+                NSRange::new(0, msg_send![attr_string, length]),
+                nil,
+            );
+            assert_ne!(rtfd_data, nil);
+            // if rtfd_data != nil {
+            //     pasteboard.setData_forType(rtfd_data, NSPasteboardTypeRTFD);
+            // }
+
+            // let rtf_data = attributed_string.RTFFromRange_documentAttributes_(
+            //     NSRange::new(0, attributed_string.length()),
+            //     nil,
+            // );
+            // if rtf_data != nil {
+            //     pasteboard.setData_forType(rtf_data, NSPasteboardTypeRTF);
+            // }
+
+            // let plain_text = attributed_string.string();
+            // pasteboard.setString_forType(plain_text, NSPasteboardTypeString);
+        }
+    }
+}

third_party/gpui/src/platform/mac/dispatch.h

@@ -0,0 +1,2 @@
+#include <dispatch/dispatch.h>
+#include <dispatch/source.h>

third_party/gpui/src/platform/mac/dispatcher.rs

@@ -0,0 +1,75 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+use crate::{PlatformDispatcher, TaskLabel};
+use async_task::Runnable;
+use objc::{
+    class, msg_send,
+    runtime::{BOOL, YES},
+    sel, sel_impl,
+};
+use std::{
+    ffi::c_void,
+    ptr::{NonNull, addr_of},
+    time::Duration,
+};
+
+/// All items in the generated file are marked as pub, so we're gonna wrap it in a separate mod to prevent
+/// these pub items from leaking into public API.
+pub(crate) mod dispatch_sys {
+    include!(concat!(env!("OUT_DIR"), "/dispatch_sys.rs"));
+}
+
+use dispatch_sys::*;
+pub(crate) fn dispatch_get_main_queue() -> dispatch_queue_t {
+    addr_of!(_dispatch_main_q) as *const _ as dispatch_queue_t
+}
+
+pub(crate) struct MacDispatcher;
+
+impl PlatformDispatcher for MacDispatcher {
+    fn is_main_thread(&self) -> bool {
+        let is_main_thread: BOOL = unsafe { msg_send![class!(NSThread), isMainThread] };
+        is_main_thread == YES
+    }
+
+    fn dispatch(&self, runnable: Runnable, _: Option<TaskLabel>) {
+        unsafe {
+            dispatch_async_f(
+                dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH.try_into().unwrap(), 0),
+                runnable.into_raw().as_ptr() as *mut c_void,
+                Some(trampoline),
+            );
+        }
+    }
+
+    fn dispatch_on_main_thread(&self, runnable: Runnable) {
+        unsafe {
+            dispatch_async_f(
+                dispatch_get_main_queue(),
+                runnable.into_raw().as_ptr() as *mut c_void,
+                Some(trampoline),
+            );
+        }
+    }
+
+    fn dispatch_after(&self, duration: Duration, runnable: Runnable) {
+        unsafe {
+            let queue =
+                dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH.try_into().unwrap(), 0);
+            let when = dispatch_time(DISPATCH_TIME_NOW as u64, duration.as_nanos() as i64);
+            dispatch_after_f(
+                when,
+                queue,
+                runnable.into_raw().as_ptr() as *mut c_void,
+                Some(trampoline),
+            );
+        }
+    }
+}
+
+extern "C" fn trampoline(runnable: *mut c_void) {
+    let task = unsafe { Runnable::<()>::from_raw(NonNull::new_unchecked(runnable as *mut ())) };
+    task.run();
+}

third_party/gpui/src/platform/mac/display.rs

@@ -0,0 +1,117 @@
+use crate::{Bounds, DisplayId, Pixels, PlatformDisplay, px, size};
+use anyhow::Result;
+use cocoa::{
+    appkit::NSScreen,
+    base::{id, nil},
+    foundation::{NSDictionary, NSString},
+};
+use core_foundation::uuid::{CFUUIDGetUUIDBytes, CFUUIDRef};
+use core_graphics::display::{CGDirectDisplayID, CGDisplayBounds, CGGetActiveDisplayList};
+use objc::{msg_send, sel, sel_impl};
+use uuid::Uuid;
+
+#[derive(Debug)]
+pub(crate) struct MacDisplay(pub(crate) CGDirectDisplayID);
+
+unsafe impl Send for MacDisplay {}
+
+impl MacDisplay {
+    /// Get the screen with the given [`DisplayId`].
+    pub fn find_by_id(id: DisplayId) -> Option<Self> {
+        Self::all().find(|screen| screen.id() == id)
+    }
+
+    /// Get the primary screen - the one with the menu bar, and whose bottom left
+    /// corner is at the origin of the AppKit coordinate system.
+    pub fn primary() -> Self {
+        // Instead of iterating through all active systems displays via `all()` we use the first
+        // NSScreen and gets its CGDirectDisplayID, because we can't be sure that `CGGetActiveDisplayList`
+        // will always return a list of active displays (machine might be sleeping).
+        //
+        // The following is what Chromium does too:
+        //
+        // https://chromium.googlesource.com/chromium/src/+/66.0.3359.158/ui/display/mac/screen_mac.mm#56
+        unsafe {
+            let screens = NSScreen::screens(nil);
+            let screen = cocoa::foundation::NSArray::objectAtIndex(screens, 0);
+            let device_description = NSScreen::deviceDescription(screen);
+            let screen_number_key: id = NSString::alloc(nil).init_str("NSScreenNumber");
+            let screen_number = device_description.objectForKey_(screen_number_key);
+            let screen_number: CGDirectDisplayID = msg_send![screen_number, unsignedIntegerValue];
+            Self(screen_number)
+        }
+    }
+
+    /// Obtains an iterator over all currently active system displays.
+    pub fn all() -> impl Iterator<Item = Self> {
+        unsafe {
+            // We're assuming there aren't more than 32 displays connected to the system.
+            let mut displays = Vec::with_capacity(32);
+            let mut display_count = 0;
+            let result = CGGetActiveDisplayList(
+                displays.capacity() as u32,
+                displays.as_mut_ptr(),
+                &mut display_count,
+            );
+
+            if result == 0 {
+                displays.set_len(display_count as usize);
+                displays.into_iter().map(MacDisplay)
+            } else {
+                panic!("Failed to get active display list. Result: {result}");
+            }
+        }
+    }
+}
+
+#[link(name = "ApplicationServices", kind = "framework")]
+unsafe extern "C" {
+    fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> CFUUIDRef;
+}
+
+impl PlatformDisplay for MacDisplay {
+    fn id(&self) -> DisplayId {
+        DisplayId(self.0)
+    }
+
+    fn uuid(&self) -> Result<Uuid> {
+        let cfuuid = unsafe { CGDisplayCreateUUIDFromDisplayID(self.0 as CGDirectDisplayID) };
+        anyhow::ensure!(
+            !cfuuid.is_null(),
+            "AppKit returned a null from CGDisplayCreateUUIDFromDisplayID"
+        );
+
+        let bytes = unsafe { CFUUIDGetUUIDBytes(cfuuid) };
+        Ok(Uuid::from_bytes([
+            bytes.byte0,
+            bytes.byte1,
+            bytes.byte2,
+            bytes.byte3,
+            bytes.byte4,
+            bytes.byte5,
+            bytes.byte6,
+            bytes.byte7,
+            bytes.byte8,
+            bytes.byte9,
+            bytes.byte10,
+            bytes.byte11,
+            bytes.byte12,
+            bytes.byte13,
+            bytes.byte14,
+            bytes.byte15,
+        ]))
+    }
+
+    fn bounds(&self) -> Bounds<Pixels> {
+        unsafe {
+            // CGDisplayBounds is in "global display" coordinates, where 0 is
+            // the top left of the primary display.
+            let bounds = CGDisplayBounds(self.0);
+
+            Bounds {
+                origin: Default::default(),
+                size: size(px(bounds.size.width as f32), px(bounds.size.height as f32)),
+            }
+        }
+    }
+}

third_party/gpui/src/platform/mac/display_link.rs

@@ -0,0 +1,283 @@
+use crate::{
+    dispatch_get_main_queue,
+    dispatch_sys::{
+        _dispatch_source_type_data_add, dispatch_resume, dispatch_set_context,
+        dispatch_source_cancel, dispatch_source_create, dispatch_source_merge_data,
+        dispatch_source_set_event_handler_f, dispatch_source_t, dispatch_suspend,
+    },
+};
+use anyhow::Result;
+use core_graphics::display::CGDirectDisplayID;
+use std::ffi::c_void;
+use util::ResultExt;
+
+pub struct DisplayLink {
+    display_link: Option<sys::DisplayLink>,
+    frame_requests: dispatch_source_t,
+}
+
+impl DisplayLink {
+    pub fn new(
+        display_id: CGDirectDisplayID,
+        data: *mut c_void,
+        callback: unsafe extern "C" fn(*mut c_void),
+    ) -> Result<DisplayLink> {
+        unsafe extern "C" fn display_link_callback(
+            _display_link_out: *mut sys::CVDisplayLink,
+            _current_time: *const sys::CVTimeStamp,
+            _output_time: *const sys::CVTimeStamp,
+            _flags_in: i64,
+            _flags_out: *mut i64,
+            frame_requests: *mut c_void,
+        ) -> i32 {
+            unsafe {
+                let frame_requests = frame_requests as dispatch_source_t;
+                dispatch_source_merge_data(frame_requests, 1);
+                0
+            }
+        }
+
+        unsafe {
+            let frame_requests = dispatch_source_create(
+                &_dispatch_source_type_data_add,
+                0,
+                0,
+                dispatch_get_main_queue(),
+            );
+            dispatch_set_context(
+                crate::dispatch_sys::dispatch_object_t {
+                    _ds: frame_requests,
+                },
+                data,
+            );
+            dispatch_source_set_event_handler_f(frame_requests, Some(callback));
+
+            let display_link = sys::DisplayLink::new(
+                display_id,
+                display_link_callback,
+                frame_requests as *mut c_void,
+            )?;
+
+            Ok(Self {
+                display_link: Some(display_link),
+                frame_requests,
+            })
+        }
+    }
+
+    pub fn start(&mut self) -> Result<()> {
+        unsafe {
+            dispatch_resume(crate::dispatch_sys::dispatch_object_t {
+                _ds: self.frame_requests,
+            });
+            self.display_link.as_mut().unwrap().start()?;
+        }
+        Ok(())
+    }
+
+    pub fn stop(&mut self) -> Result<()> {
+        unsafe {
+            dispatch_suspend(crate::dispatch_sys::dispatch_object_t {
+                _ds: self.frame_requests,
+            });
+            self.display_link.as_mut().unwrap().stop()?;
+        }
+        Ok(())
+    }
+}
+
+impl Drop for DisplayLink {
+    fn drop(&mut self) {
+        self.stop().log_err();
+        // We see occasional segfaults on the CVDisplayLink thread.
+        //
+        // It seems possible that this happens because CVDisplayLinkRelease releases the CVDisplayLink
+        // on the main thread immediately, but the background thread that CVDisplayLink uses for timers
+        // is still accessing it.
+        //
+        // We might also want to upgrade to CADisplayLink, but that requires dropping old macOS support.
+        std::mem::forget(self.display_link.take());
+        unsafe {
+            dispatch_source_cancel(self.frame_requests);
+        }
+    }
+}
+
+mod sys {
+    //! Derived from display-link crate under the following license:
+    //! <https://github.com/BrainiumLLC/display-link/blob/master/LICENSE-MIT>
+    //! Apple docs: [CVDisplayLink](https://developer.apple.com/documentation/corevideo/cvdisplaylinkoutputcallback?language=objc)
+    #![allow(dead_code, non_upper_case_globals)]
+
+    use anyhow::Result;
+    use core_graphics::display::CGDirectDisplayID;
+    use foreign_types::{ForeignType, foreign_type};
+    use std::{
+        ffi::c_void,
+        fmt::{self, Debug, Formatter},
+    };
+
+    #[derive(Debug)]
+    pub enum CVDisplayLink {}
+
+    foreign_type! {
+        pub unsafe type DisplayLink {
+            type CType = CVDisplayLink;
+            fn drop = CVDisplayLinkRelease;
+            fn clone = CVDisplayLinkRetain;
+        }
+    }
+
+    impl Debug for DisplayLink {
+        fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
+            formatter
+                .debug_tuple("DisplayLink")
+                .field(&self.as_ptr())
+                .finish()
+        }
+    }
+
+    #[repr(C)]
+    #[derive(Clone, Copy)]
+    pub(crate) struct CVTimeStamp {
+        pub version: u32,
+        pub video_time_scale: i32,
+        pub video_time: i64,
+        pub host_time: u64,
+        pub rate_scalar: f64,
+        pub video_refresh_period: i64,
+        pub smpte_time: CVSMPTETime,
+        pub flags: u64,
+        pub reserved: u64,
+    }
+
+    pub type CVTimeStampFlags = u64;
+
+    pub const kCVTimeStampVideoTimeValid: CVTimeStampFlags = 1 << 0;
+    pub const kCVTimeStampHostTimeValid: CVTimeStampFlags = 1 << 1;
+    pub const kCVTimeStampSMPTETimeValid: CVTimeStampFlags = 1 << 2;
+    pub const kCVTimeStampVideoRefreshPeriodValid: CVTimeStampFlags = 1 << 3;
+    pub const kCVTimeStampRateScalarValid: CVTimeStampFlags = 1 << 4;
+    pub const kCVTimeStampTopField: CVTimeStampFlags = 1 << 16;
+    pub const kCVTimeStampBottomField: CVTimeStampFlags = 1 << 17;
+    pub const kCVTimeStampVideoHostTimeValid: CVTimeStampFlags =
+        kCVTimeStampVideoTimeValid | kCVTimeStampHostTimeValid;
+    pub const kCVTimeStampIsInterlaced: CVTimeStampFlags =
+        kCVTimeStampTopField | kCVTimeStampBottomField;
+
+    #[repr(C)]
+    #[derive(Clone, Copy, Default)]
+    pub(crate) struct CVSMPTETime {
+        pub subframes: i16,
+        pub subframe_divisor: i16,
+        pub counter: u32,
+        pub time_type: u32,
+        pub flags: u32,
+        pub hours: i16,
+        pub minutes: i16,
+        pub seconds: i16,
+        pub frames: i16,
+    }
+
+    pub type CVSMPTETimeType = u32;
+
+    pub const kCVSMPTETimeType24: CVSMPTETimeType = 0;
+    pub const kCVSMPTETimeType25: CVSMPTETimeType = 1;
+    pub const kCVSMPTETimeType30Drop: CVSMPTETimeType = 2;
+    pub const kCVSMPTETimeType30: CVSMPTETimeType = 3;
+    pub const kCVSMPTETimeType2997: CVSMPTETimeType = 4;
+    pub const kCVSMPTETimeType2997Drop: CVSMPTETimeType = 5;
+    pub const kCVSMPTETimeType60: CVSMPTETimeType = 6;
+    pub const kCVSMPTETimeType5994: CVSMPTETimeType = 7;
+
+    pub type CVSMPTETimeFlags = u32;
+
+    pub const kCVSMPTETimeValid: CVSMPTETimeFlags = 1 << 0;
+    pub const kCVSMPTETimeRunning: CVSMPTETimeFlags = 1 << 1;
+
+    pub type CVDisplayLinkOutputCallback = unsafe extern "C" fn(
+        display_link_out: *mut CVDisplayLink,
+        // A pointer to the current timestamp. This represents the timestamp when the callback is called.
+        current_time: *const CVTimeStamp,
+        // A pointer to the output timestamp. This represents the timestamp for when the frame will be displayed.
+        output_time: *const CVTimeStamp,
+        // Unused
+        flags_in: i64,
+        // Unused
+        flags_out: *mut i64,
+        // A pointer to app-defined data.
+        display_link_context: *mut c_void,
+    ) -> i32;
+
+    #[link(name = "CoreFoundation", kind = "framework")]
+    #[link(name = "CoreVideo", kind = "framework")]
+    #[allow(improper_ctypes, unknown_lints, clippy::duplicated_attributes)]
+    unsafe extern "C" {
+        pub fn CVDisplayLinkCreateWithActiveCGDisplays(
+            display_link_out: *mut *mut CVDisplayLink,
+        ) -> i32;
+        pub fn CVDisplayLinkSetCurrentCGDisplay(
+            display_link: &mut DisplayLinkRef,
+            display_id: u32,
+        ) -> i32;
+        pub fn CVDisplayLinkSetOutputCallback(
+            display_link: &mut DisplayLinkRef,
+            callback: CVDisplayLinkOutputCallback,
+            user_info: *mut c_void,
+        ) -> i32;
+        pub fn CVDisplayLinkStart(display_link: &mut DisplayLinkRef) -> i32;
+        pub fn CVDisplayLinkStop(display_link: &mut DisplayLinkRef) -> i32;
+        pub fn CVDisplayLinkRelease(display_link: *mut CVDisplayLink);
+        pub fn CVDisplayLinkRetain(display_link: *mut CVDisplayLink) -> *mut CVDisplayLink;
+    }
+
+    impl DisplayLink {
+        /// Apple docs: [CVDisplayLinkCreateWithCGDisplay](https://developer.apple.com/documentation/corevideo/1456981-cvdisplaylinkcreatewithcgdisplay?language=objc)
+        pub unsafe fn new(
+            display_id: CGDirectDisplayID,
+            callback: CVDisplayLinkOutputCallback,
+            user_info: *mut c_void,
+        ) -> Result<Self> {
+            unsafe {
+                let mut display_link: *mut CVDisplayLink = 0 as _;
+
+                let code = CVDisplayLinkCreateWithActiveCGDisplays(&mut display_link);
+                anyhow::ensure!(code == 0, "could not create display link, code: {}", code);
+
+                let mut display_link = DisplayLink::from_ptr(display_link);
+
+                let code = CVDisplayLinkSetOutputCallback(&mut display_link, callback, user_info);
+                anyhow::ensure!(code == 0, "could not set output callback, code: {}", code);
+
+                let code = CVDisplayLinkSetCurrentCGDisplay(&mut display_link, display_id);
+                anyhow::ensure!(
+                    code == 0,
+                    "could not assign display to display link, code: {}",
+                    code
+                );
+
+                Ok(display_link)
+            }
+        }
+    }
+
+    impl DisplayLinkRef {
+        /// Apple docs: [CVDisplayLinkStart](https://developer.apple.com/documentation/corevideo/1457193-cvdisplaylinkstart?language=objc)
+        pub unsafe fn start(&mut self) -> Result<()> {
+            unsafe {
+                let code = CVDisplayLinkStart(self);
+                anyhow::ensure!(code == 0, "could not start display link, code: {}", code);
+                Ok(())
+            }
+        }
+
+        /// Apple docs: [CVDisplayLinkStop](https://developer.apple.com/documentation/corevideo/1457281-cvdisplaylinkstop?language=objc)
+        pub unsafe fn stop(&mut self) -> Result<()> {
+            unsafe {
+                let code = CVDisplayLinkStop(self);
+                anyhow::ensure!(code == 0, "could not stop display link, code: {}", code);
+                Ok(())
+            }
+        }
+    }
+}

third_party/gpui/src/platform/mac/events.rs

@@ -0,0 +1,533 @@
+use crate::{
+    Capslock, KeyDownEvent, KeyUpEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
+    MouseDownEvent, MouseExitEvent, MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels,
+    PlatformInput, ScrollDelta, ScrollWheelEvent, TouchPhase,
+    platform::mac::{
+        LMGetKbdType, NSStringExt, TISCopyCurrentKeyboardLayoutInputSource,
+        TISGetInputSourceProperty, UCKeyTranslate, kTISPropertyUnicodeKeyLayoutData,
+    },
+    point, px,
+};
+use cocoa::{
+    appkit::{NSEvent, NSEventModifierFlags, NSEventPhase, NSEventType},
+    base::{YES, id},
+};
+use core_foundation::data::{CFDataGetBytePtr, CFDataRef};
+use core_graphics::event::CGKeyCode;
+use objc::{msg_send, sel, sel_impl};
+use std::{borrow::Cow, ffi::c_void};
+
+const BACKSPACE_KEY: u16 = 0x7f;
+const SPACE_KEY: u16 = b' ' as u16;
+const ENTER_KEY: u16 = 0x0d;
+const NUMPAD_ENTER_KEY: u16 = 0x03;
+pub(crate) const ESCAPE_KEY: u16 = 0x1b;
+const TAB_KEY: u16 = 0x09;
+const SHIFT_TAB_KEY: u16 = 0x19;
+
+pub fn key_to_native(key: &str) -> Cow<'_, str> {
+    use cocoa::appkit::*;
+    let code = match key {
+        "space" => SPACE_KEY,
+        "backspace" => BACKSPACE_KEY,
+        "escape" => ESCAPE_KEY,
+        "up" => NSUpArrowFunctionKey,
+        "down" => NSDownArrowFunctionKey,
+        "left" => NSLeftArrowFunctionKey,
+        "right" => NSRightArrowFunctionKey,
+        "pageup" => NSPageUpFunctionKey,
+        "pagedown" => NSPageDownFunctionKey,
+        "home" => NSHomeFunctionKey,
+        "end" => NSEndFunctionKey,
+        "delete" => NSDeleteFunctionKey,
+        "insert" => NSHelpFunctionKey,
+        "f1" => NSF1FunctionKey,
+        "f2" => NSF2FunctionKey,
+        "f3" => NSF3FunctionKey,
+        "f4" => NSF4FunctionKey,
+        "f5" => NSF5FunctionKey,
+        "f6" => NSF6FunctionKey,
+        "f7" => NSF7FunctionKey,
+        "f8" => NSF8FunctionKey,
+        "f9" => NSF9FunctionKey,
+        "f10" => NSF10FunctionKey,
+        "f11" => NSF11FunctionKey,
+        "f12" => NSF12FunctionKey,
+        "f13" => NSF13FunctionKey,
+        "f14" => NSF14FunctionKey,
+        "f15" => NSF15FunctionKey,
+        "f16" => NSF16FunctionKey,
+        "f17" => NSF17FunctionKey,
+        "f18" => NSF18FunctionKey,
+        "f19" => NSF19FunctionKey,
+        "f20" => NSF20FunctionKey,
+        "f21" => NSF21FunctionKey,
+        "f22" => NSF22FunctionKey,
+        "f23" => NSF23FunctionKey,
+        "f24" => NSF24FunctionKey,
+        "f25" => NSF25FunctionKey,
+        "f26" => NSF26FunctionKey,
+        "f27" => NSF27FunctionKey,
+        "f28" => NSF28FunctionKey,
+        "f29" => NSF29FunctionKey,
+        "f30" => NSF30FunctionKey,
+        "f31" => NSF31FunctionKey,
+        "f32" => NSF32FunctionKey,
+        "f33" => NSF33FunctionKey,
+        "f34" => NSF34FunctionKey,
+        "f35" => NSF35FunctionKey,
+        _ => return Cow::Borrowed(key),
+    };
+    Cow::Owned(String::from_utf16(&[code]).unwrap())
+}
+
+unsafe fn read_modifiers(native_event: id) -> Modifiers {
+    unsafe {
+        let modifiers = native_event.modifierFlags();
+        let control = modifiers.contains(NSEventModifierFlags::NSControlKeyMask);
+        let alt = modifiers.contains(NSEventModifierFlags::NSAlternateKeyMask);
+        let shift = modifiers.contains(NSEventModifierFlags::NSShiftKeyMask);
+        let command = modifiers.contains(NSEventModifierFlags::NSCommandKeyMask);
+        let function = modifiers.contains(NSEventModifierFlags::NSFunctionKeyMask);
+
+        Modifiers {
+            control,
+            alt,
+            shift,
+            platform: command,
+            function,
+        }
+    }
+}
+
+impl PlatformInput {
+    pub(crate) unsafe fn from_native(
+        native_event: id,
+        window_height: Option<Pixels>,
+    ) -> Option<Self> {
+        unsafe {
+            let event_type = native_event.eventType();
+
+            // Filter out event types that aren't in the NSEventType enum.
+            // See https://github.com/servo/cocoa-rs/issues/155#issuecomment-323482792 for details.
+            match event_type as u64 {
+                0 | 21 | 32 | 33 | 35 | 36 | 37 => {
+                    return None;
+                }
+                _ => {}
+            }
+
+            match event_type {
+                NSEventType::NSFlagsChanged => {
+                    Some(Self::ModifiersChanged(ModifiersChangedEvent {
+                        modifiers: read_modifiers(native_event),
+                        capslock: Capslock {
+                            on: native_event
+                                .modifierFlags()
+                                .contains(NSEventModifierFlags::NSAlphaShiftKeyMask),
+                        },
+                    }))
+                }
+                NSEventType::NSKeyDown => Some(Self::KeyDown(KeyDownEvent {
+                    keystroke: parse_keystroke(native_event),
+                    is_held: native_event.isARepeat() == YES,
+                })),
+                NSEventType::NSKeyUp => Some(Self::KeyUp(KeyUpEvent {
+                    keystroke: parse_keystroke(native_event),
+                })),
+                NSEventType::NSLeftMouseDown
+                | NSEventType::NSRightMouseDown
+                | NSEventType::NSOtherMouseDown => {
+                    let button = match native_event.buttonNumber() {
+                        0 => MouseButton::Left,
+                        1 => MouseButton::Right,
+                        2 => MouseButton::Middle,
+                        3 => MouseButton::Navigate(NavigationDirection::Back),
+                        4 => MouseButton::Navigate(NavigationDirection::Forward),
+                        // Other mouse buttons aren't tracked currently
+                        _ => return None,
+                    };
+                    window_height.map(|window_height| {
+                        Self::MouseDown(MouseDownEvent {
+                            button,
+                            position: point(
+                                px(native_event.locationInWindow().x as f32),
+                                // MacOS screen coordinates are relative to bottom left
+                                window_height - px(native_event.locationInWindow().y as f32),
+                            ),
+                            modifiers: read_modifiers(native_event),
+                            click_count: native_event.clickCount() as usize,
+                            first_mouse: false,
+                        })
+                    })
+                }
+                NSEventType::NSLeftMouseUp
+                | NSEventType::NSRightMouseUp
+                | NSEventType::NSOtherMouseUp => {
+                    let button = match native_event.buttonNumber() {
+                        0 => MouseButton::Left,
+                        1 => MouseButton::Right,
+                        2 => MouseButton::Middle,
+                        3 => MouseButton::Navigate(NavigationDirection::Back),
+                        4 => MouseButton::Navigate(NavigationDirection::Forward),
+                        // Other mouse buttons aren't tracked currently
+                        _ => return None,
+                    };
+
+                    window_height.map(|window_height| {
+                        Self::MouseUp(MouseUpEvent {
+                            button,
+                            position: point(
+                                px(native_event.locationInWindow().x as f32),
+                                window_height - px(native_event.locationInWindow().y as f32),
+                            ),
+                            modifiers: read_modifiers(native_event),
+                            click_count: native_event.clickCount() as usize,
+                        })
+                    })
+                }
+                // Some mice (like Logitech MX Master) send navigation buttons as swipe events
+                NSEventType::NSEventTypeSwipe => {
+                    let navigation_direction = match native_event.phase() {
+                        NSEventPhase::NSEventPhaseEnded => match native_event.deltaX() {
+                            x if x > 0.0 => Some(NavigationDirection::Back),
+                            x if x < 0.0 => Some(NavigationDirection::Forward),
+                            _ => return None,
+                        },
+                        _ => return None,
+                    };
+
+                    match navigation_direction {
+                        Some(direction) => window_height.map(|window_height| {
+                            Self::MouseDown(MouseDownEvent {
+                                button: MouseButton::Navigate(direction),
+                                position: point(
+                                    px(native_event.locationInWindow().x as f32),
+                                    window_height - px(native_event.locationInWindow().y as f32),
+                                ),
+                                modifiers: read_modifiers(native_event),
+                                click_count: 1,
+                                first_mouse: false,
+                            })
+                        }),
+                        _ => None,
+                    }
+                }
+                NSEventType::NSScrollWheel => window_height.map(|window_height| {
+                    let phase = match native_event.phase() {
+                        NSEventPhase::NSEventPhaseMayBegin | NSEventPhase::NSEventPhaseBegan => {
+                            TouchPhase::Started
+                        }
+                        NSEventPhase::NSEventPhaseEnded => TouchPhase::Ended,
+                        _ => TouchPhase::Moved,
+                    };
+
+                    let raw_data = point(
+                        native_event.scrollingDeltaX() as f32,
+                        native_event.scrollingDeltaY() as f32,
+                    );
+
+                    let delta = if native_event.hasPreciseScrollingDeltas() == YES {
+                        ScrollDelta::Pixels(raw_data.map(px))
+                    } else {
+                        ScrollDelta::Lines(raw_data)
+                    };
+
+                    Self::ScrollWheel(ScrollWheelEvent {
+                        position: point(
+                            px(native_event.locationInWindow().x as f32),
+                            window_height - px(native_event.locationInWindow().y as f32),
+                        ),
+                        delta,
+                        touch_phase: phase,
+                        modifiers: read_modifiers(native_event),
+                    })
+                }),
+                NSEventType::NSLeftMouseDragged
+                | NSEventType::NSRightMouseDragged
+                | NSEventType::NSOtherMouseDragged => {
+                    let pressed_button = match native_event.buttonNumber() {
+                        0 => MouseButton::Left,
+                        1 => MouseButton::Right,
+                        2 => MouseButton::Middle,
+                        3 => MouseButton::Navigate(NavigationDirection::Back),
+                        4 => MouseButton::Navigate(NavigationDirection::Forward),
+                        // Other mouse buttons aren't tracked currently
+                        _ => return None,
+                    };
+
+                    window_height.map(|window_height| {
+                        Self::MouseMove(MouseMoveEvent {
+                            pressed_button: Some(pressed_button),
+                            position: point(
+                                px(native_event.locationInWindow().x as f32),
+                                window_height - px(native_event.locationInWindow().y as f32),
+                            ),
+                            modifiers: read_modifiers(native_event),
+                        })
+                    })
+                }
+                NSEventType::NSMouseMoved => window_height.map(|window_height| {
+                    Self::MouseMove(MouseMoveEvent {
+                        position: point(
+                            px(native_event.locationInWindow().x as f32),
+                            window_height - px(native_event.locationInWindow().y as f32),
+                        ),
+                        pressed_button: None,
+                        modifiers: read_modifiers(native_event),
+                    })
+                }),
+                NSEventType::NSMouseExited => window_height.map(|window_height| {
+                    Self::MouseExited(MouseExitEvent {
+                        position: point(
+                            px(native_event.locationInWindow().x as f32),
+                            window_height - px(native_event.locationInWindow().y as f32),
+                        ),
+
+                        pressed_button: None,
+                        modifiers: read_modifiers(native_event),
+                    })
+                }),
+                _ => None,
+            }
+        }
+    }
+}
+
+unsafe fn parse_keystroke(native_event: id) -> Keystroke {
+    unsafe {
+        use cocoa::appkit::*;
+
+        let mut characters = native_event
+            .charactersIgnoringModifiers()
+            .to_str()
+            .to_string();
+        let mut key_char = None;
+        let first_char = characters.chars().next().map(|ch| ch as u16);
+        let modifiers = native_event.modifierFlags();
+
+        let control = modifiers.contains(NSEventModifierFlags::NSControlKeyMask);
+        let alt = modifiers.contains(NSEventModifierFlags::NSAlternateKeyMask);
+        let mut shift = modifiers.contains(NSEventModifierFlags::NSShiftKeyMask);
+        let command = modifiers.contains(NSEventModifierFlags::NSCommandKeyMask);
+        let function = modifiers.contains(NSEventModifierFlags::NSFunctionKeyMask)
+            && first_char
+                .is_none_or(|ch| !(NSUpArrowFunctionKey..=NSModeSwitchFunctionKey).contains(&ch));
+
+        #[allow(non_upper_case_globals)]
+        let key = match first_char {
+            Some(SPACE_KEY) => {
+                key_char = Some(" ".to_string());
+                "space".to_string()
+            }
+            Some(TAB_KEY) => {
+                key_char = Some("\t".to_string());
+                "tab".to_string()
+            }
+            Some(ENTER_KEY) | Some(NUMPAD_ENTER_KEY) => {
+                key_char = Some("\n".to_string());
+                "enter".to_string()
+            }
+            Some(BACKSPACE_KEY) => "backspace".to_string(),
+            Some(ESCAPE_KEY) => "escape".to_string(),
+            Some(SHIFT_TAB_KEY) => "tab".to_string(),
+            Some(NSUpArrowFunctionKey) => "up".to_string(),
+            Some(NSDownArrowFunctionKey) => "down".to_string(),
+            Some(NSLeftArrowFunctionKey) => "left".to_string(),
+            Some(NSRightArrowFunctionKey) => "right".to_string(),
+            Some(NSPageUpFunctionKey) => "pageup".to_string(),
+            Some(NSPageDownFunctionKey) => "pagedown".to_string(),
+            Some(NSHomeFunctionKey) => "home".to_string(),
+            Some(NSEndFunctionKey) => "end".to_string(),
+            Some(NSDeleteFunctionKey) => "delete".to_string(),
+            // Observed Insert==NSHelpFunctionKey not NSInsertFunctionKey.
+            Some(NSHelpFunctionKey) => "insert".to_string(),
+            Some(NSF1FunctionKey) => "f1".to_string(),
+            Some(NSF2FunctionKey) => "f2".to_string(),
+            Some(NSF3FunctionKey) => "f3".to_string(),
+            Some(NSF4FunctionKey) => "f4".to_string(),
+            Some(NSF5FunctionKey) => "f5".to_string(),
+            Some(NSF6FunctionKey) => "f6".to_string(),
+            Some(NSF7FunctionKey) => "f7".to_string(),
+            Some(NSF8FunctionKey) => "f8".to_string(),
+            Some(NSF9FunctionKey) => "f9".to_string(),
+            Some(NSF10FunctionKey) => "f10".to_string(),
+            Some(NSF11FunctionKey) => "f11".to_string(),
+            Some(NSF12FunctionKey) => "f12".to_string(),
+            Some(NSF13FunctionKey) => "f13".to_string(),
+            Some(NSF14FunctionKey) => "f14".to_string(),
+            Some(NSF15FunctionKey) => "f15".to_string(),
+            Some(NSF16FunctionKey) => "f16".to_string(),
+            Some(NSF17FunctionKey) => "f17".to_string(),
+            Some(NSF18FunctionKey) => "f18".to_string(),
+            Some(NSF19FunctionKey) => "f19".to_string(),
+            Some(NSF20FunctionKey) => "f20".to_string(),
+            Some(NSF21FunctionKey) => "f21".to_string(),
+            Some(NSF22FunctionKey) => "f22".to_string(),
+            Some(NSF23FunctionKey) => "f23".to_string(),
+            Some(NSF24FunctionKey) => "f24".to_string(),
+            Some(NSF25FunctionKey) => "f25".to_string(),
+            Some(NSF26FunctionKey) => "f26".to_string(),
+            Some(NSF27FunctionKey) => "f27".to_string(),
+            Some(NSF28FunctionKey) => "f28".to_string(),
+            Some(NSF29FunctionKey) => "f29".to_string(),
+            Some(NSF30FunctionKey) => "f30".to_string(),
+            Some(NSF31FunctionKey) => "f31".to_string(),
+            Some(NSF32FunctionKey) => "f32".to_string(),
+            Some(NSF33FunctionKey) => "f33".to_string(),
+            Some(NSF34FunctionKey) => "f34".to_string(),
+            Some(NSF35FunctionKey) => "f35".to_string(),
+            _ => {
+                // Cases to test when modifying this:
+                //
+                //           qwerty key | none | cmd   | cmd-shift
+                // * Armenian         s | ս    | cmd-s | cmd-shift-s  (layout is non-ASCII, so we use cmd layout)
+                // * Dvorak+QWERTY    s | o    | cmd-s | cmd-shift-s  (layout switches on cmd)
+                // * Ukrainian+QWERTY s | с    | cmd-s | cmd-shift-s  (macOS reports cmd-s instead of cmd-S)
+                // * Czech            7 | ý    | cmd-ý | cmd-7        (layout has shifted numbers)
+                // * Norwegian        7 | 7    | cmd-7 | cmd-/        (macOS reports cmd-shift-7 instead of cmd-/)
+                // * Russian          7 | 7    | cmd-7 | cmd-&        (shift-7 is . but when cmd is down, should use cmd layout)
+                // * German QWERTZ    ; | ö    | cmd-ö | cmd-Ö        (Zed's shift special case only applies to a-z)
+                //
+                let mut chars_ignoring_modifiers =
+                    chars_for_modified_key(native_event.keyCode(), NO_MOD);
+                let mut chars_with_shift =
+                    chars_for_modified_key(native_event.keyCode(), SHIFT_MOD);
+                let always_use_cmd_layout = always_use_command_layout();
+
+                // Handle Dvorak+QWERTY / Russian / Armenian
+                if command || always_use_cmd_layout {
+                    let chars_with_cmd = chars_for_modified_key(native_event.keyCode(), CMD_MOD);
+                    let chars_with_both =
+                        chars_for_modified_key(native_event.keyCode(), CMD_MOD | SHIFT_MOD);
+
+                    // We don't do this in the case that the shifted command key generates
+                    // the same character as the unshifted command key (Norwegian, e.g.)
+                    if chars_with_both != chars_with_cmd {
+                        chars_with_shift = chars_with_both;
+
+                    // Handle edge-case where cmd-shift-s reports cmd-s instead of
+                    // cmd-shift-s (Ukrainian, etc.)
+                    } else if chars_with_cmd.to_ascii_uppercase() != chars_with_cmd {
+                        chars_with_shift = chars_with_cmd.to_ascii_uppercase();
+                    }
+                    chars_ignoring_modifiers = chars_with_cmd;
+                }
+
+                if !control && !command && !function {
+                    let mut mods = NO_MOD;
+                    if shift {
+                        mods |= SHIFT_MOD;
+                    }
+                    if alt {
+                        mods |= OPTION_MOD;
+                    }
+
+                    key_char = Some(chars_for_modified_key(native_event.keyCode(), mods));
+                }
+
+                if shift
+                    && chars_ignoring_modifiers
+                        .chars()
+                        .all(|c| c.is_ascii_lowercase())
+                {
+                    chars_ignoring_modifiers
+                } else if shift {
+                    shift = false;
+                    chars_with_shift
+                } else {
+                    chars_ignoring_modifiers
+                }
+            }
+        };
+
+        Keystroke {
+            modifiers: Modifiers {
+                control,
+                alt,
+                shift,
+                platform: command,
+                function,
+            },
+            key,
+            key_char,
+        }
+    }
+}
+
+fn always_use_command_layout() -> bool {
+    if chars_for_modified_key(0, NO_MOD).is_ascii() {
+        return false;
+    }
+
+    chars_for_modified_key(0, CMD_MOD).is_ascii()
+}
+
+const NO_MOD: u32 = 0;
+const CMD_MOD: u32 = 1;
+const SHIFT_MOD: u32 = 2;
+const OPTION_MOD: u32 = 8;
+
+fn chars_for_modified_key(code: CGKeyCode, modifiers: u32) -> String {
+    // Values from: https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h#L126
+    // shifted >> 8 for UCKeyTranslate
+    const CG_SPACE_KEY: u16 = 49;
+    // https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/CarbonCore.framework/Versions/A/Headers/UnicodeUtilities.h#L278
+    #[allow(non_upper_case_globals)]
+    const kUCKeyActionDown: u16 = 0;
+    #[allow(non_upper_case_globals)]
+    const kUCKeyTranslateNoDeadKeysMask: u32 = 0;
+
+    let keyboard_type = unsafe { LMGetKbdType() as u32 };
+    const BUFFER_SIZE: usize = 4;
+    let mut dead_key_state = 0;
+    let mut buffer: [u16; BUFFER_SIZE] = [0; BUFFER_SIZE];
+    let mut buffer_size: usize = 0;
+
+    let keyboard = unsafe { TISCopyCurrentKeyboardLayoutInputSource() };
+    if keyboard.is_null() {
+        return "".to_string();
+    }
+    let layout_data = unsafe {
+        TISGetInputSourceProperty(keyboard, kTISPropertyUnicodeKeyLayoutData as *const c_void)
+            as CFDataRef
+    };
+    if layout_data.is_null() {
+        unsafe {
+            let _: () = msg_send![keyboard, release];
+        }
+        return "".to_string();
+    }
+    let keyboard_layout = unsafe { CFDataGetBytePtr(layout_data) };
+
+    unsafe {
+        UCKeyTranslate(
+            keyboard_layout as *const c_void,
+            code,
+            kUCKeyActionDown,
+            modifiers,
+            keyboard_type,
+            kUCKeyTranslateNoDeadKeysMask,
+            &mut dead_key_state,
+            BUFFER_SIZE,
+            &mut buffer_size as *mut usize,
+            &mut buffer as *mut u16,
+        );
+        if dead_key_state != 0 {
+            UCKeyTranslate(
+                keyboard_layout as *const c_void,
+                CG_SPACE_KEY,
+                kUCKeyActionDown,
+                modifiers,
+                keyboard_type,
+                kUCKeyTranslateNoDeadKeysMask,
+                &mut dead_key_state,
+                BUFFER_SIZE,
+                &mut buffer_size as *mut usize,
+                &mut buffer as *mut u16,
+            );
+        }
+        let _: () = msg_send![keyboard, release];
+    }
+    String::from_utf16(&buffer[..buffer_size]).unwrap_or_default()
+}

third_party/gpui/src/platform/mac/metal_atlas.rs

@@ -0,0 +1,281 @@
+use crate::{
+    AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTile, Bounds, DevicePixels, PlatformAtlas,
+    Point, Size, platform::AtlasTextureList,
+};
+use anyhow::{Context as _, Result};
+use collections::FxHashMap;
+use derive_more::{Deref, DerefMut};
+use etagere::BucketedAtlasAllocator;
+use metal::Device;
+use parking_lot::Mutex;
+use std::borrow::Cow;
+
+pub(crate) struct MetalAtlas(Mutex<MetalAtlasState>);
+
+impl MetalAtlas {
+    pub(crate) fn new(device: Device) -> Self {
+        MetalAtlas(Mutex::new(MetalAtlasState {
+            device: AssertSend(device),
+            monochrome_textures: Default::default(),
+            polychrome_textures: Default::default(),
+            tiles_by_key: Default::default(),
+        }))
+    }
+
+    pub(crate) fn metal_texture(&self, id: AtlasTextureId) -> metal::Texture {
+        self.0.lock().texture(id).metal_texture.clone()
+    }
+}
+
+struct MetalAtlasState {
+    device: AssertSend<Device>,
+    monochrome_textures: AtlasTextureList<MetalAtlasTexture>,
+    polychrome_textures: AtlasTextureList<MetalAtlasTexture>,
+    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
+}
+
+impl PlatformAtlas for MetalAtlas {
+    fn get_or_insert_with<'a>(
+        &self,
+        key: &AtlasKey,
+        build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,
+    ) -> Result<Option<AtlasTile>> {
+        let mut lock = self.0.lock();
+        if let Some(tile) = lock.tiles_by_key.get(key) {
+            Ok(Some(tile.clone()))
+        } else {
+            let Some((size, bytes)) = build()? else {
+                return Ok(None);
+            };
+            let tile = lock
+                .allocate(size, key.texture_kind())
+                .context("failed to allocate")?;
+            let texture = lock.texture(tile.texture_id);
+            texture.upload(tile.bounds, &bytes);
+            lock.tiles_by_key.insert(key.clone(), tile.clone());
+            Ok(Some(tile))
+        }
+    }
+
+    fn remove(&self, key: &AtlasKey) {
+        let mut lock = self.0.lock();
+        let Some(id) = lock.tiles_by_key.get(key).map(|v| v.texture_id) else {
+            return;
+        };
+
+        let textures = match id.kind {
+            AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,
+            AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,
+        };
+
+        let Some(texture_slot) = textures
+            .textures
+            .iter_mut()
+            .find(|texture| texture.as_ref().is_some_and(|v| v.id == id))
+        else {
+            return;
+        };
+
+        if let Some(mut texture) = texture_slot.take() {
+            texture.decrement_ref_count();
+
+            if texture.is_unreferenced() {
+                textures.free_list.push(id.index as usize);
+                lock.tiles_by_key.remove(key);
+            } else {
+                *texture_slot = Some(texture);
+            }
+        }
+    }
+}
+
+impl MetalAtlasState {
+    fn allocate(
+        &mut self,
+        size: Size<DevicePixels>,
+        texture_kind: AtlasTextureKind,
+    ) -> Option<AtlasTile> {
+        {
+            let textures = match texture_kind {
+                AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
+                AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+            };
+
+            if let Some(tile) = textures
+                .iter_mut()
+                .rev()
+                .find_map(|texture| texture.allocate(size))
+            {
+                return Some(tile);
+            }
+        }
+
+        let texture = self.push_texture(size, texture_kind);
+        texture.allocate(size)
+    }
+
+    fn push_texture(
+        &mut self,
+        min_size: Size<DevicePixels>,
+        kind: AtlasTextureKind,
+    ) -> &mut MetalAtlasTexture {
+        const DEFAULT_ATLAS_SIZE: Size<DevicePixels> = Size {
+            width: DevicePixels(1024),
+            height: DevicePixels(1024),
+        };
+        // Max texture size on all modern Apple GPUs. Anything bigger than that crashes in validateWithDevice.
+        const MAX_ATLAS_SIZE: Size<DevicePixels> = Size {
+            width: DevicePixels(16384),
+            height: DevicePixels(16384),
+        };
+        let size = min_size.min(&MAX_ATLAS_SIZE).max(&DEFAULT_ATLAS_SIZE);
+        let texture_descriptor = metal::TextureDescriptor::new();
+        texture_descriptor.set_width(size.width.into());
+        texture_descriptor.set_height(size.height.into());
+        let pixel_format;
+        let usage;
+        match kind {
+            AtlasTextureKind::Monochrome => {
+                pixel_format = metal::MTLPixelFormat::A8Unorm;
+                usage = metal::MTLTextureUsage::ShaderRead;
+            }
+            AtlasTextureKind::Polychrome => {
+                pixel_format = metal::MTLPixelFormat::BGRA8Unorm;
+                usage = metal::MTLTextureUsage::ShaderRead;
+            }
+        }
+        texture_descriptor.set_pixel_format(pixel_format);
+        texture_descriptor.set_usage(usage);
+        let metal_texture = self.device.new_texture(&texture_descriptor);
+
+        let texture_list = match kind {
+            AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
+            AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+        };
+
+        let index = texture_list.free_list.pop();
+
+        let atlas_texture = MetalAtlasTexture {
+            id: AtlasTextureId {
+                index: index.unwrap_or(texture_list.textures.len()) as u32,
+                kind,
+            },
+            allocator: etagere::BucketedAtlasAllocator::new(size.into()),
+            metal_texture: AssertSend(metal_texture),
+            live_atlas_keys: 0,
+        };
+
+        if let Some(ix) = index {
+            texture_list.textures[ix] = Some(atlas_texture);
+            texture_list.textures.get_mut(ix)
+        } else {
+            texture_list.textures.push(Some(atlas_texture));
+            texture_list.textures.last_mut()
+        }
+        .unwrap()
+        .as_mut()
+        .unwrap()
+    }
+
+    fn texture(&self, id: AtlasTextureId) -> &MetalAtlasTexture {
+        let textures = match id.kind {
+            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
+            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
+        };
+        textures[id.index as usize].as_ref().unwrap()
+    }
+}
+
+struct MetalAtlasTexture {
+    id: AtlasTextureId,
+    allocator: BucketedAtlasAllocator,
+    metal_texture: AssertSend<metal::Texture>,
+    live_atlas_keys: u32,
+}
+
+impl MetalAtlasTexture {
+    fn allocate(&mut self, size: Size<DevicePixels>) -> Option<AtlasTile> {
+        let allocation = self.allocator.allocate(size.into())?;
+        let tile = AtlasTile {
+            texture_id: self.id,
+            tile_id: allocation.id.into(),
+            bounds: Bounds {
+                origin: allocation.rectangle.min.into(),
+                size,
+            },
+            padding: 0,
+        };
+        self.live_atlas_keys += 1;
+        Some(tile)
+    }
+
+    fn upload(&self, bounds: Bounds<DevicePixels>, bytes: &[u8]) {
+        let region = metal::MTLRegion::new_2d(
+            bounds.origin.x.into(),
+            bounds.origin.y.into(),
+            bounds.size.width.into(),
+            bounds.size.height.into(),
+        );
+        self.metal_texture.replace_region(
+            region,
+            0,
+            bytes.as_ptr() as *const _,
+            bounds.size.width.to_bytes(self.bytes_per_pixel()) as u64,
+        );
+    }
+
+    fn bytes_per_pixel(&self) -> u8 {
+        use metal::MTLPixelFormat::*;
+        match self.metal_texture.pixel_format() {
+            A8Unorm | R8Unorm => 1,
+            RGBA8Unorm | BGRA8Unorm => 4,
+            _ => unimplemented!(),
+        }
+    }
+
+    fn decrement_ref_count(&mut self) {
+        self.live_atlas_keys -= 1;
+    }
+
+    fn is_unreferenced(&mut self) -> bool {
+        self.live_atlas_keys == 0
+    }
+}
+
+impl From<Size<DevicePixels>> for etagere::Size {
+    fn from(size: Size<DevicePixels>) -> Self {
+        etagere::Size::new(size.width.into(), size.height.into())
+    }
+}
+
+impl From<etagere::Point> for Point<DevicePixels> {
+    fn from(value: etagere::Point) -> Self {
+        Point {
+            x: DevicePixels::from(value.x),
+            y: DevicePixels::from(value.y),
+        }
+    }
+}
+
+impl From<etagere::Size> for Size<DevicePixels> {
+    fn from(size: etagere::Size) -> Self {
+        Size {
+            width: DevicePixels::from(size.width),
+            height: DevicePixels::from(size.height),
+        }
+    }
+}
+
+impl From<etagere::Rectangle> for Bounds<DevicePixels> {
+    fn from(rectangle: etagere::Rectangle) -> Self {
+        Bounds {
+            origin: rectangle.min.into(),
+            size: rectangle.size().into(),
+        }
+    }
+}
+
+#[derive(Deref, DerefMut)]
+struct AssertSend<T>(T);
+
+unsafe impl<T> Send for AssertSend<T> {}

third_party/gpui/src/platform/mac/open_type.rs

@@ -0,0 +1,147 @@
+#![allow(unused, non_upper_case_globals)]
+
+use crate::{FontFallbacks, FontFeatures};
+use cocoa::appkit::CGFloat;
+use core_foundation::{
+    array::{
+        CFArray, CFArrayAppendArray, CFArrayAppendValue, CFArrayCreateMutable, CFArrayGetCount,
+        CFArrayGetValueAtIndex, CFArrayRef, CFMutableArrayRef, kCFTypeArrayCallBacks,
+    },
+    base::{CFRelease, TCFType, kCFAllocatorDefault},
+    dictionary::{
+        CFDictionaryCreate, kCFTypeDictionaryKeyCallBacks, kCFTypeDictionaryValueCallBacks,
+    },
+    number::CFNumber,
+    string::{CFString, CFStringRef},
+};
+use core_foundation_sys::locale::CFLocaleCopyPreferredLanguages;
+use core_graphics::{display::CFDictionary, geometry::CGAffineTransform};
+use core_text::{
+    font::{CTFont, CTFontRef, cascade_list_for_languages},
+    font_descriptor::{
+        CTFontDescriptor, CTFontDescriptorCopyAttributes, CTFontDescriptorCreateCopyWithFeature,
+        CTFontDescriptorCreateWithAttributes, CTFontDescriptorCreateWithNameAndSize,
+        CTFontDescriptorRef, kCTFontCascadeListAttribute, kCTFontFeatureSettingsAttribute,
+    },
+};
+use font_kit::font::Font as FontKitFont;
+use std::ptr;
+
+pub fn apply_features_and_fallbacks(
+    font: &mut FontKitFont,
+    features: &FontFeatures,
+    fallbacks: Option<&FontFallbacks>,
+) -> anyhow::Result<()> {
+    unsafe {
+        let mut keys = vec![kCTFontFeatureSettingsAttribute];
+        let mut values = vec![generate_feature_array(features)];
+        if let Some(fallbacks) = fallbacks
+            && !fallbacks.fallback_list().is_empty()
+        {
+            keys.push(kCTFontCascadeListAttribute);
+            values.push(generate_fallback_array(
+                fallbacks,
+                font.native_font().as_concrete_TypeRef(),
+            ));
+        }
+        let attrs = CFDictionaryCreate(
+            kCFAllocatorDefault,
+            keys.as_ptr() as _,
+            values.as_ptr() as _,
+            keys.len() as isize,
+            &kCFTypeDictionaryKeyCallBacks,
+            &kCFTypeDictionaryValueCallBacks,
+        );
+        let new_descriptor = CTFontDescriptorCreateWithAttributes(attrs);
+        CFRelease(attrs as _);
+        let new_descriptor = CTFontDescriptor::wrap_under_create_rule(new_descriptor);
+        let new_font = CTFontCreateCopyWithAttributes(
+            font.native_font().as_concrete_TypeRef(),
+            0.0,
+            std::ptr::null(),
+            new_descriptor.as_concrete_TypeRef(),
+        );
+        let new_font = CTFont::wrap_under_create_rule(new_font);
+        *font = font_kit::font::Font::from_native_font(&new_font);
+
+        Ok(())
+    }
+}
+
+fn generate_feature_array(features: &FontFeatures) -> CFMutableArrayRef {
+    unsafe {
+        let feature_array = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
+        for (tag, value) in features.tag_value_list() {
+            let keys = [kCTFontOpenTypeFeatureTag, kCTFontOpenTypeFeatureValue];
+            let values = [
+                CFString::new(tag).as_CFTypeRef(),
+                CFNumber::from(*value as i32).as_CFTypeRef(),
+            ];
+            let dict = CFDictionaryCreate(
+                kCFAllocatorDefault,
+                &keys as *const _ as _,
+                &values as *const _ as _,
+                2,
+                &kCFTypeDictionaryKeyCallBacks,
+                &kCFTypeDictionaryValueCallBacks,
+            );
+            values.into_iter().for_each(|value| CFRelease(value));
+            CFArrayAppendValue(feature_array, dict as _);
+            CFRelease(dict as _);
+        }
+        feature_array
+    }
+}
+
+fn generate_fallback_array(fallbacks: &FontFallbacks, font_ref: CTFontRef) -> CFMutableArrayRef {
+    unsafe {
+        let fallback_array = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
+        for user_fallback in fallbacks.fallback_list() {
+            let name = CFString::from(user_fallback.as_str());
+            let fallback_desc =
+                CTFontDescriptorCreateWithNameAndSize(name.as_concrete_TypeRef(), 0.0);
+            CFArrayAppendValue(fallback_array, fallback_desc as _);
+            CFRelease(fallback_desc as _);
+        }
+        append_system_fallbacks(fallback_array, font_ref);
+        fallback_array
+    }
+}
+
+fn append_system_fallbacks(fallback_array: CFMutableArrayRef, font_ref: CTFontRef) {
+    unsafe {
+        let preferred_languages: CFArray<CFString> =
+            CFArray::wrap_under_create_rule(CFLocaleCopyPreferredLanguages());
+
+        let default_fallbacks = CTFontCopyDefaultCascadeListForLanguages(
+            font_ref,
+            preferred_languages.as_concrete_TypeRef(),
+        );
+        let default_fallbacks: CFArray<CTFontDescriptor> =
+            CFArray::wrap_under_create_rule(default_fallbacks);
+
+        default_fallbacks
+            .iter()
+            .filter(|desc| desc.font_path().is_some())
+            .map(|desc| {
+                CFArrayAppendValue(fallback_array, desc.as_concrete_TypeRef() as _);
+            });
+    }
+}
+
+#[link(name = "CoreText", kind = "framework")]
+unsafe extern "C" {
+    static kCTFontOpenTypeFeatureTag: CFStringRef;
+    static kCTFontOpenTypeFeatureValue: CFStringRef;
+
+    fn CTFontCreateCopyWithAttributes(
+        font: CTFontRef,
+        size: CGFloat,
+        matrix: *const CGAffineTransform,
+        attributes: CTFontDescriptorRef,
+    ) -> CTFontRef;
+    fn CTFontCopyDefaultCascadeListForLanguages(
+        font: CTFontRef,
+        languagePrefList: CFArrayRef,
+    ) -> CFArrayRef;
+}

third_party/gpui/src/platform/mac/screen_capture.rs

@@ -0,0 +1,334 @@
+use crate::{
+    DevicePixels, ForegroundExecutor, SharedString, SourceMetadata,
+    platform::{ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream},
+    size,
+};
+use anyhow::{Result, anyhow};
+use block::ConcreteBlock;
+use cocoa::{
+    base::{YES, id, nil},
+    foundation::{NSArray, NSString},
+};
+use collections::HashMap;
+use core_foundation::base::TCFType;
+use core_graphics::display::{
+    CGDirectDisplayID, CGDisplayCopyDisplayMode, CGDisplayModeGetPixelHeight,
+    CGDisplayModeGetPixelWidth, CGDisplayModeRelease,
+};
+use ctor::ctor;
+use futures::channel::oneshot;
+use media::core_media::{CMSampleBuffer, CMSampleBufferRef};
+use metal::NSInteger;
+use objc::{
+    class,
+    declare::ClassDecl,
+    msg_send,
+    runtime::{Class, Object, Sel},
+    sel, sel_impl,
+};
+use std::{cell::RefCell, ffi::c_void, mem, ptr, rc::Rc};
+
+use super::NSStringExt;
+
+#[derive(Clone)]
+pub struct MacScreenCaptureSource {
+    sc_display: id,
+    meta: Option<ScreenMeta>,
+}
+
+pub struct MacScreenCaptureStream {
+    sc_stream: id,
+    sc_stream_output: id,
+    meta: SourceMetadata,
+}
+
+static mut DELEGATE_CLASS: *const Class = ptr::null();
+static mut OUTPUT_CLASS: *const Class = ptr::null();
+const FRAME_CALLBACK_IVAR: &str = "frame_callback";
+
+#[allow(non_upper_case_globals)]
+const SCStreamOutputTypeScreen: NSInteger = 0;
+
+impl ScreenCaptureSource for MacScreenCaptureSource {
+    fn metadata(&self) -> Result<SourceMetadata> {
+        let (display_id, size) = unsafe {
+            let display_id: CGDirectDisplayID = msg_send![self.sc_display, displayID];
+            let display_mode_ref = CGDisplayCopyDisplayMode(display_id);
+            let width = CGDisplayModeGetPixelWidth(display_mode_ref);
+            let height = CGDisplayModeGetPixelHeight(display_mode_ref);
+            CGDisplayModeRelease(display_mode_ref);
+
+            (
+                display_id,
+                size(DevicePixels(width as i32), DevicePixels(height as i32)),
+            )
+        };
+        let (label, is_main) = self
+            .meta
+            .clone()
+            .map(|meta| (meta.label, meta.is_main))
+            .unzip();
+
+        Ok(SourceMetadata {
+            id: display_id as u64,
+            label,
+            is_main,
+            resolution: size,
+        })
+    }
+
+    fn stream(
+        &self,
+        _foreground_executor: &ForegroundExecutor,
+        frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,
+    ) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>> {
+        unsafe {
+            let stream: id = msg_send![class!(SCStream), alloc];
+            let filter: id = msg_send![class!(SCContentFilter), alloc];
+            let configuration: id = msg_send![class!(SCStreamConfiguration), alloc];
+            let delegate: id = msg_send![DELEGATE_CLASS, alloc];
+            let output: id = msg_send![OUTPUT_CLASS, alloc];
+
+            let excluded_windows = NSArray::array(nil);
+            let filter: id = msg_send![filter, initWithDisplay:self.sc_display excludingWindows:excluded_windows];
+            let configuration: id = msg_send![configuration, init];
+            let _: id = msg_send![configuration, setScalesToFit: true];
+            let _: id = msg_send![configuration, setPixelFormat: 0x42475241];
+            // let _: id = msg_send![configuration, setShowsCursor: false];
+            // let _: id = msg_send![configuration, setCaptureResolution: 3];
+            let delegate: id = msg_send![delegate, init];
+            let output: id = msg_send![output, init];
+
+            output.as_mut().unwrap().set_ivar(
+                FRAME_CALLBACK_IVAR,
+                Box::into_raw(Box::new(frame_callback)) as *mut c_void,
+            );
+
+            let meta = self.metadata().unwrap();
+            let _: id = msg_send![configuration, setWidth: meta.resolution.width.0 as i64];
+            let _: id = msg_send![configuration, setHeight: meta.resolution.height.0 as i64];
+            let stream: id = msg_send![stream, initWithFilter:filter configuration:configuration delegate:delegate];
+
+            let (mut tx, rx) = oneshot::channel();
+
+            let mut error: id = nil;
+            let _: () = msg_send![stream, addStreamOutput:output type:SCStreamOutputTypeScreen sampleHandlerQueue:0 error:&mut error as *mut id];
+            if error != nil {
+                let message: id = msg_send![error, localizedDescription];
+                tx.send(Err(anyhow!("failed to add stream  output {message:?}")))
+                    .ok();
+                return rx;
+            }
+
+            let tx = Rc::new(RefCell::new(Some(tx)));
+            let handler = ConcreteBlock::new({
+                move |error: id| {
+                    let result = if error == nil {
+                        let stream = MacScreenCaptureStream {
+                            meta: meta.clone(),
+                            sc_stream: stream,
+                            sc_stream_output: output,
+                        };
+                        Ok(Box::new(stream) as Box<dyn ScreenCaptureStream>)
+                    } else {
+                        let message: id = msg_send![error, localizedDescription];
+                        Err(anyhow!("failed to stop screen capture stream {message:?}"))
+                    };
+                    if let Some(tx) = tx.borrow_mut().take() {
+                        tx.send(result).ok();
+                    }
+                }
+            });
+            let handler = handler.copy();
+            let _: () = msg_send![stream, startCaptureWithCompletionHandler:handler];
+            rx
+        }
+    }
+}
+
+impl Drop for MacScreenCaptureSource {
+    fn drop(&mut self) {
+        unsafe {
+            let _: () = msg_send![self.sc_display, release];
+        }
+    }
+}
+
+impl ScreenCaptureStream for MacScreenCaptureStream {
+    fn metadata(&self) -> Result<SourceMetadata> {
+        Ok(self.meta.clone())
+    }
+}
+
+impl Drop for MacScreenCaptureStream {
+    fn drop(&mut self) {
+        unsafe {
+            let mut error: id = nil;
+            let _: () = msg_send![self.sc_stream, removeStreamOutput:self.sc_stream_output type:SCStreamOutputTypeScreen error:&mut error as *mut _];
+            if error != nil {
+                let message: id = msg_send![error, localizedDescription];
+                log::error!("failed to add stream  output {message:?}");
+            }
+
+            let handler = ConcreteBlock::new(move |error: id| {
+                if error != nil {
+                    let message: id = msg_send![error, localizedDescription];
+                    log::error!("failed to stop screen capture stream {message:?}");
+                }
+            });
+            let block = handler.copy();
+            let _: () = msg_send![self.sc_stream, stopCaptureWithCompletionHandler:block];
+            let _: () = msg_send![self.sc_stream, release];
+            let _: () = msg_send![self.sc_stream_output, release];
+        }
+    }
+}
+
+#[derive(Clone)]
+struct ScreenMeta {
+    label: SharedString,
+    // Is this the screen with menu bar?
+    is_main: bool,
+}
+
+unsafe fn screen_id_to_human_label() -> HashMap<CGDirectDisplayID, ScreenMeta> {
+    let screens: id = msg_send![class!(NSScreen), screens];
+    let count: usize = msg_send![screens, count];
+    let mut map = HashMap::default();
+    let screen_number_key = unsafe { NSString::alloc(nil).init_str("NSScreenNumber") };
+    for i in 0..count {
+        let screen: id = msg_send![screens, objectAtIndex: i];
+        let device_desc: id = msg_send![screen, deviceDescription];
+        if device_desc == nil {
+            continue;
+        }
+
+        let nsnumber: id = msg_send![device_desc, objectForKey: screen_number_key];
+        if nsnumber == nil {
+            continue;
+        }
+
+        let screen_id: u32 = msg_send![nsnumber, unsignedIntValue];
+
+        let name: id = msg_send![screen, localizedName];
+        if name != nil {
+            let cstr: *const std::os::raw::c_char = msg_send![name, UTF8String];
+            let rust_str = unsafe {
+                std::ffi::CStr::from_ptr(cstr)
+                    .to_string_lossy()
+                    .into_owned()
+            };
+            map.insert(
+                screen_id,
+                ScreenMeta {
+                    label: rust_str.into(),
+                    is_main: i == 0,
+                },
+            );
+        }
+    }
+    map
+}
+
+pub(crate) fn get_sources() -> oneshot::Receiver<Result<Vec<Rc<dyn ScreenCaptureSource>>>> {
+    unsafe {
+        let (mut tx, rx) = oneshot::channel();
+        let tx = Rc::new(RefCell::new(Some(tx)));
+        let screen_id_to_label = screen_id_to_human_label();
+        let block = ConcreteBlock::new(move |shareable_content: id, error: id| {
+            let Some(mut tx) = tx.borrow_mut().take() else {
+                return;
+            };
+
+            let result = if error == nil {
+                let displays: id = msg_send![shareable_content, displays];
+                let mut result = Vec::new();
+                for i in 0..displays.count() {
+                    let display = displays.objectAtIndex(i);
+                    let id: CGDirectDisplayID = msg_send![display, displayID];
+                    let meta = screen_id_to_label.get(&id).cloned();
+                    let source = MacScreenCaptureSource {
+                        sc_display: msg_send![display, retain],
+                        meta,
+                    };
+                    result.push(Rc::new(source) as Rc<dyn ScreenCaptureSource>);
+                }
+                Ok(result)
+            } else {
+                let msg: id = msg_send![error, localizedDescription];
+                Err(anyhow!(
+                    "Screen share failed: {:?}",
+                    NSStringExt::to_str(&msg)
+                ))
+            };
+            tx.send(result).ok();
+        });
+        let block = block.copy();
+
+        let _: () = msg_send![
+            class!(SCShareableContent),
+            getShareableContentExcludingDesktopWindows:YES
+                                   onScreenWindowsOnly:YES
+                                     completionHandler:block];
+        rx
+    }
+}
+
+#[ctor]
+unsafe fn build_classes() {
+    let mut decl = ClassDecl::new("GPUIStreamDelegate", class!(NSObject)).unwrap();
+    unsafe {
+        decl.add_method(
+            sel!(outputVideoEffectDidStartForStream:),
+            output_video_effect_did_start_for_stream as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(outputVideoEffectDidStopForStream:),
+            output_video_effect_did_stop_for_stream as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(stream:didStopWithError:),
+            stream_did_stop_with_error as extern "C" fn(&Object, Sel, id, id),
+        );
+        DELEGATE_CLASS = decl.register();
+
+        let mut decl = ClassDecl::new("GPUIStreamOutput", class!(NSObject)).unwrap();
+        decl.add_method(
+            sel!(stream:didOutputSampleBuffer:ofType:),
+            stream_did_output_sample_buffer_of_type
+                as extern "C" fn(&Object, Sel, id, id, NSInteger),
+        );
+        decl.add_ivar::<*mut c_void>(FRAME_CALLBACK_IVAR);
+
+        OUTPUT_CLASS = decl.register();
+    }
+}
+
+extern "C" fn output_video_effect_did_start_for_stream(_this: &Object, _: Sel, _stream: id) {}
+
+extern "C" fn output_video_effect_did_stop_for_stream(_this: &Object, _: Sel, _stream: id) {}
+
+extern "C" fn stream_did_stop_with_error(_this: &Object, _: Sel, _stream: id, _error: id) {}
+
+extern "C" fn stream_did_output_sample_buffer_of_type(
+    this: &Object,
+    _: Sel,
+    _stream: id,
+    sample_buffer: id,
+    buffer_type: NSInteger,
+) {
+    if buffer_type != SCStreamOutputTypeScreen {
+        return;
+    }
+
+    unsafe {
+        let sample_buffer = sample_buffer as CMSampleBufferRef;
+        let sample_buffer = CMSampleBuffer::wrap_under_get_rule(sample_buffer);
+        if let Some(buffer) = sample_buffer.image_buffer() {
+            let callback: Box<Box<dyn Fn(ScreenCaptureFrame)>> =
+                Box::from_raw(*this.get_ivar::<*mut c_void>(FRAME_CALLBACK_IVAR) as *mut _);
+            callback(ScreenCaptureFrame(buffer));
+            mem::forget(callback);
+        }
+    }
+}

third_party/gpui/src/platform/mac/status_item.rs

@@ -0,0 +1,388 @@
+use crate::{
+    geometry::{
+        rect::RectF,
+        vector::{vec2f, Vector2F},
+    },
+    platform::{
+        self,
+        mac::{platform::NSViewLayerContentsRedrawDuringViewResize, renderer::Renderer},
+        Event, FontSystem, WindowBounds,
+    },
+    Scene,
+};
+use cocoa::{
+    appkit::{NSScreen, NSSquareStatusItemLength, NSStatusBar, NSStatusItem, NSView, NSWindow},
+    base::{id, nil, YES},
+    foundation::{NSPoint, NSRect, NSSize},
+};
+use ctor::ctor;
+use foreign_types::ForeignTypeRef;
+use objc::{
+    class,
+    declare::ClassDecl,
+    msg_send,
+    rc::StrongPtr,
+    runtime::{Class, Object, Protocol, Sel},
+    sel, sel_impl,
+};
+use std::{
+    cell::RefCell,
+    ffi::c_void,
+    ptr,
+    rc::{Rc, Weak},
+    sync::Arc,
+};
+
+use super::screen::Screen;
+
+static mut VIEW_CLASS: *const Class = ptr::null();
+const STATE_IVAR: &str = "state";
+
+#[ctor]
+unsafe fn build_classes() {
+    VIEW_CLASS = {
+        let mut decl = ClassDecl::new("GPUIStatusItemView", class!(NSView)).unwrap();
+        decl.add_ivar::<*mut c_void>(STATE_IVAR);
+
+        decl.add_method(sel!(dealloc), dealloc_view as extern "C" fn(&Object, Sel));
+
+        decl.add_method(
+            sel!(mouseDown:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(mouseUp:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(rightMouseDown:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(rightMouseUp:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(otherMouseDown:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(otherMouseUp:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(mouseMoved:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(mouseDragged:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(scrollWheel:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(flagsChanged:),
+            handle_view_event as extern "C" fn(&Object, Sel, id),
+        );
+        decl.add_method(
+            sel!(makeBackingLayer),
+            make_backing_layer as extern "C" fn(&Object, Sel) -> id,
+        );
+        decl.add_method(
+            sel!(viewDidChangeEffectiveAppearance),
+            view_did_change_effective_appearance as extern "C" fn(&Object, Sel),
+        );
+
+        decl.add_protocol(Protocol::get("CALayerDelegate").unwrap());
+        decl.add_method(
+            sel!(displayLayer:),
+            display_layer as extern "C" fn(&Object, Sel, id),
+        );
+
+        decl.register()
+    };
+}
+
+pub struct StatusItem(Rc<RefCell<StatusItemState>>);
+
+struct StatusItemState {
+    native_item: StrongPtr,
+    native_view: StrongPtr,
+    renderer: Renderer,
+    scene: Option<Scene>,
+    event_callback: Option<Box<dyn FnMut(Event) -> bool>>,
+    appearance_changed_callback: Option<Box<dyn FnMut()>>,
+}
+
+impl StatusItem {
+    pub fn add(fonts: Arc<dyn FontSystem>) -> Self {
+        unsafe {
+            let renderer = Renderer::new(false, fonts);
+            let status_bar = NSStatusBar::systemStatusBar(nil);
+            let native_item =
+                StrongPtr::retain(status_bar.statusItemWithLength_(NSSquareStatusItemLength));
+
+            let button = native_item.button();
+            let _: () = msg_send![button, setHidden: YES];
+
+            let native_view = msg_send![VIEW_CLASS, alloc];
+            let state = Rc::new(RefCell::new(StatusItemState {
+                native_item,
+                native_view: StrongPtr::new(native_view),
+                renderer,
+                scene: None,
+                event_callback: None,
+                appearance_changed_callback: None,
+            }));
+
+            let parent_view = button.superview().superview();
+            NSView::initWithFrame_(
+                native_view,
+                NSRect::new(NSPoint::new(0., 0.), NSView::frame(parent_view).size),
+            );
+            (*native_view).set_ivar(
+                STATE_IVAR,
+                Weak::into_raw(Rc::downgrade(&state)) as *const c_void,
+            );
+            native_view.setWantsBestResolutionOpenGLSurface_(YES);
+            native_view.setWantsLayer(YES);
+            let _: () = msg_send![
+                native_view,
+                setLayerContentsRedrawPolicy: NSViewLayerContentsRedrawDuringViewResize
+            ];
+
+            parent_view.addSubview_(native_view);
+
+            {
+                let state = state.borrow();
+                let layer = state.renderer.layer();
+                let scale_factor = state.scale_factor();
+                let size = state.content_size() * scale_factor;
+                layer.set_contents_scale(scale_factor.into());
+                layer.set_drawable_size(metal::CGSize::new(size.x().into(), size.y().into()));
+            }
+
+            Self(state)
+        }
+    }
+}
+
+impl platform::Window for StatusItem {
+    fn bounds(&self) -> WindowBounds {
+        self.0.borrow().bounds()
+    }
+
+    fn content_size(&self) -> Vector2F {
+        self.0.borrow().content_size()
+    }
+
+    fn scale_factor(&self) -> f32 {
+        self.0.borrow().scale_factor()
+    }
+
+    fn appearance(&self) -> platform::Appearance {
+        unsafe {
+            let appearance: id =
+                msg_send![self.0.borrow().native_item.button(), effectiveAppearance];
+            platform::Appearance::from_native(appearance)
+        }
+    }
+
+    fn screen(&self) -> Rc<dyn platform::Screen> {
+        unsafe {
+            Rc::new(Screen {
+                native_screen: self.0.borrow().native_window().screen(),
+            })
+        }
+    }
+
+    fn mouse_position(&self) -> Vector2F {
+        unimplemented!()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+
+    fn set_input_handler(&mut self, _: Box<dyn platform::InputHandler>) {}
+
+    fn prompt(
+        &self,
+        _: crate::platform::PromptLevel,
+        _: &str,
+        _: &[&str],
+    ) -> postage::oneshot::Receiver<usize> {
+        unimplemented!()
+    }
+
+    fn activate(&self) {
+        unimplemented!()
+    }
+
+    fn set_title(&mut self, _: &str) {
+        unimplemented!()
+    }
+
+    fn set_edited(&mut self, _: bool) {
+        unimplemented!()
+    }
+
+    fn show_character_palette(&self) {
+        unimplemented!()
+    }
+
+    fn minimize(&self) {
+        unimplemented!()
+    }
+
+    fn zoom(&self) {
+        unimplemented!()
+    }
+
+    fn present_scene(&mut self, scene: Scene) {
+        self.0.borrow_mut().scene = Some(scene);
+        unsafe {
+            let _: () = msg_send![*self.0.borrow().native_view, setNeedsDisplay: YES];
+        }
+    }
+
+    fn toggle_fullscreen(&self) {
+        unimplemented!()
+    }
+
+    fn on_event(&mut self, callback: Box<dyn FnMut(platform::Event) -> bool>) {
+        self.0.borrow_mut().event_callback = Some(callback);
+    }
+
+    fn on_active_status_change(&mut self, _: Box<dyn FnMut(bool)>) {}
+
+    fn on_resize(&mut self, _: Box<dyn FnMut()>) {}
+
+    fn on_fullscreen(&mut self, _: Box<dyn FnMut(bool)>) {}
+
+    fn on_moved(&mut self, _: Box<dyn FnMut()>) {}
+
+    fn on_should_close(&mut self, _: Box<dyn FnMut() -> bool>) {}
+
+    fn on_close(&mut self, _: Box<dyn FnOnce()>) {}
+
+    fn on_appearance_changed(&mut self, callback: Box<dyn FnMut()>) {
+        self.0.borrow_mut().appearance_changed_callback = Some(callback);
+    }
+
+    fn is_topmost_for_position(&self, _: Vector2F) -> bool {
+        true
+    }
+}
+
+impl StatusItemState {
+    fn bounds(&self) -> WindowBounds {
+        unsafe {
+            let window: id = self.native_window();
+            let screen_frame = window.screen().visibleFrame();
+            let window_frame = NSWindow::frame(window);
+            let origin = vec2f(
+                window_frame.origin.x as f32,
+                (window_frame.origin.y - screen_frame.size.height - window_frame.size.height)
+                    as f32,
+            );
+            let size = vec2f(
+                window_frame.size.width as f32,
+                window_frame.size.height as f32,
+            );
+            WindowBounds::Fixed(RectF::new(origin, size))
+        }
+    }
+
+    fn content_size(&self) -> Vector2F {
+        unsafe {
+            let NSSize { width, height, .. } =
+                NSView::frame(self.native_item.button().superview().superview()).size;
+            vec2f(width as f32, height as f32)
+        }
+    }
+
+    fn scale_factor(&self) -> f32 {
+        unsafe {
+            let window: id = msg_send![self.native_item.button(), window];
+            NSScreen::backingScaleFactor(window.screen()) as f32
+        }
+    }
+
+    pub fn native_window(&self) -> id {
+        unsafe { msg_send![self.native_item.button(), window] }
+    }
+}
+
+extern "C" fn dealloc_view(this: &Object, _: Sel) {
+    unsafe {
+        drop_state(this);
+
+        let _: () = msg_send![super(this, class!(NSView)), dealloc];
+    }
+}
+
+extern "C" fn handle_view_event(this: &Object, _: Sel, native_event: id) {
+    unsafe {
+        if let Some(state) = get_state(this).upgrade() {
+            let mut state_borrow = state.as_ref().borrow_mut();
+            if let Some(event) =
+                Event::from_native(native_event, Some(state_borrow.content_size().y()))
+            {
+                if let Some(mut callback) = state_borrow.event_callback.take() {
+                    drop(state_borrow);
+                    callback(event);
+                    state.borrow_mut().event_callback = Some(callback);
+                }
+            }
+        }
+    }
+}
+
+extern "C" fn make_backing_layer(this: &Object, _: Sel) -> id {
+    if let Some(state) = unsafe { get_state(this).upgrade() } {
+        let state = state.borrow();
+        state.renderer.layer().as_ptr() as id
+    } else {
+        nil
+    }
+}
+
+extern "C" fn display_layer(this: &Object, _: Sel, _: id) {
+    unsafe {
+        if let Some(state) = get_state(this).upgrade() {
+            let mut state = state.borrow_mut();
+            if let Some(scene) = state.scene.take() {
+                state.renderer.render(&scene);
+            }
+        }
+    }
+}
+
+extern "C" fn view_did_change_effective_appearance(this: &Object, _: Sel) {
+    unsafe {
+        if let Some(state) = get_state(this).upgrade() {
+            let mut state_borrow = state.as_ref().borrow_mut();
+            if let Some(mut callback) = state_borrow.appearance_changed_callback.take() {
+                drop(state_borrow);
+                callback();
+                state.borrow_mut().appearance_changed_callback = Some(callback);
+            }
+        }
+    }
+}
+
+unsafe fn get_state(object: &Object) -> Weak<RefCell<StatusItemState>> {
+    let raw: *mut c_void = *object.get_ivar(STATE_IVAR);
+    let weak1 = Weak::from_raw(raw as *mut RefCell<StatusItemState>);
+    let weak2 = weak1.clone();
+    let _ = Weak::into_raw(weak1);
+    weak2
+}
+
+unsafe fn drop_state(object: &Object) {
+    let raw: *const c_void = *object.get_ivar(STATE_IVAR);
+    Weak::from_raw(raw as *const RefCell<StatusItemState>);
+}

third_party/gpui/src/platform/mac/text_system.rs

@@ -0,0 +1,846 @@
+use crate::{
+    Bounds, DevicePixels, Font, FontFallbacks, FontFeatures, FontId, FontMetrics, FontRun,
+    FontStyle, FontWeight, GlyphId, LineLayout, Pixels, PlatformTextSystem, Point,
+    RenderGlyphParams, Result, SUBPIXEL_VARIANTS_X, ShapedGlyph, ShapedRun, SharedString, Size,
+    point, px, size, swap_rgba_pa_to_bgra,
+};
+use anyhow::anyhow;
+use cocoa::appkit::CGFloat;
+use collections::HashMap;
+use core_foundation::{
+    attributed_string::CFMutableAttributedString,
+    base::{CFRange, TCFType},
+    number::CFNumber,
+    string::CFString,
+};
+use core_graphics::{
+    base::{CGGlyph, kCGImageAlphaPremultipliedLast},
+    color_space::CGColorSpace,
+    context::{CGContext, CGTextDrawingMode},
+    display::CGPoint,
+};
+use core_text::{
+    font::CTFont,
+    font_descriptor::{
+        kCTFontSlantTrait, kCTFontSymbolicTrait, kCTFontWeightTrait, kCTFontWidthTrait,
+    },
+    line::CTLine,
+    string_attributes::kCTFontAttributeName,
+};
+use font_kit::{
+    font::Font as FontKitFont,
+    handle::Handle,
+    hinting::HintingOptions,
+    metrics::Metrics,
+    properties::{Style as FontkitStyle, Weight as FontkitWeight},
+    source::SystemSource,
+    sources::mem::MemSource,
+};
+use parking_lot::{RwLock, RwLockUpgradableReadGuard};
+use pathfinder_geometry::{
+    rect::{RectF, RectI},
+    transform2d::Transform2F,
+    vector::{Vector2F, Vector2I},
+};
+use smallvec::SmallVec;
+use std::{borrow::Cow, char, convert::TryFrom, sync::Arc};
+
+use super::open_type::apply_features_and_fallbacks;
+
+#[allow(non_upper_case_globals)]
+const kCGImageAlphaOnly: u32 = 7;
+
+pub(crate) struct MacTextSystem(RwLock<MacTextSystemState>);
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+struct FontKey {
+    font_family: SharedString,
+    font_features: FontFeatures,
+    font_fallbacks: Option<FontFallbacks>,
+}
+
+struct MacTextSystemState {
+    memory_source: MemSource,
+    system_source: SystemSource,
+    fonts: Vec<FontKitFont>,
+    font_selections: HashMap<Font, FontId>,
+    font_ids_by_postscript_name: HashMap<String, FontId>,
+    font_ids_by_font_key: HashMap<FontKey, SmallVec<[FontId; 4]>>,
+    postscript_names_by_font_id: HashMap<FontId, String>,
+    /// UTF-16 indices of ZWNJS
+    zwnjs_scratch_space: Vec<usize>,
+}
+
+impl MacTextSystem {
+    pub(crate) fn new() -> Self {
+        Self(RwLock::new(MacTextSystemState {
+            memory_source: MemSource::empty(),
+            system_source: SystemSource::new(),
+            fonts: Vec::new(),
+            font_selections: HashMap::default(),
+            font_ids_by_postscript_name: HashMap::default(),
+            font_ids_by_font_key: HashMap::default(),
+            postscript_names_by_font_id: HashMap::default(),
+            zwnjs_scratch_space: Vec::new(),
+        }))
+    }
+}
+
+impl Default for MacTextSystem {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PlatformTextSystem for MacTextSystem {
+    fn add_fonts(&self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
+        self.0.write().add_fonts(fonts)
+    }
+
+    fn all_font_names(&self) -> Vec<String> {
+        let mut names = Vec::new();
+        let collection = core_text::font_collection::create_for_all_families();
+        let Some(descriptors) = collection.get_descriptors() else {
+            return names;
+        };
+        for descriptor in descriptors.into_iter() {
+            names.extend(lenient_font_attributes::family_name(&descriptor));
+        }
+        if let Ok(fonts_in_memory) = self.0.read().memory_source.all_families() {
+            names.extend(fonts_in_memory);
+        }
+        names
+    }
+
+    fn font_id(&self, font: &Font) -> Result<FontId> {
+        let lock = self.0.upgradable_read();
+        if let Some(font_id) = lock.font_selections.get(font) {
+            Ok(*font_id)
+        } else {
+            let mut lock = RwLockUpgradableReadGuard::upgrade(lock);
+            let font_key = FontKey {
+                font_family: font.family.clone(),
+                font_features: font.features.clone(),
+                font_fallbacks: font.fallbacks.clone(),
+            };
+            let candidates = if let Some(font_ids) = lock.font_ids_by_font_key.get(&font_key) {
+                font_ids.as_slice()
+            } else {
+                let font_ids =
+                    lock.load_family(&font.family, &font.features, font.fallbacks.as_ref())?;
+                lock.font_ids_by_font_key.insert(font_key.clone(), font_ids);
+                lock.font_ids_by_font_key[&font_key].as_ref()
+            };
+
+            let candidate_properties = candidates
+                .iter()
+                .map(|font_id| lock.fonts[font_id.0].properties())
+                .collect::<SmallVec<[_; 4]>>();
+
+            let ix = font_kit::matching::find_best_match(
+                &candidate_properties,
+                &font_kit::properties::Properties {
+                    style: font.style.into(),
+                    weight: font.weight.into(),
+                    stretch: Default::default(),
+                },
+            )?;
+
+            let font_id = candidates[ix];
+            lock.font_selections.insert(font.clone(), font_id);
+            Ok(font_id)
+        }
+    }
+
+    fn font_metrics(&self, font_id: FontId) -> FontMetrics {
+        self.0.read().fonts[font_id.0].metrics().into()
+    }
+
+    fn typographic_bounds(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Bounds<f32>> {
+        Ok(self.0.read().fonts[font_id.0]
+            .typographic_bounds(glyph_id.0)?
+            .into())
+    }
+
+    fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
+        self.0.read().advance(font_id, glyph_id)
+    }
+
+    fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
+        self.0.read().glyph_for_char(font_id, ch)
+    }
+
+    fn glyph_raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
+        self.0.read().raster_bounds(params)
+    }
+
+    fn rasterize_glyph(
+        &self,
+        glyph_id: &RenderGlyphParams,
+        raster_bounds: Bounds<DevicePixels>,
+    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
+        self.0.read().rasterize_glyph(glyph_id, raster_bounds)
+    }
+
+    fn layout_line(&self, text: &str, font_size: Pixels, font_runs: &[FontRun]) -> LineLayout {
+        self.0.write().layout_line(text, font_size, font_runs)
+    }
+}
+
+impl MacTextSystemState {
+    fn add_fonts(&mut self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
+        let fonts = fonts
+            .into_iter()
+            .map(|bytes| match bytes {
+                Cow::Borrowed(embedded_font) => {
+                    let data_provider = unsafe {
+                        core_graphics::data_provider::CGDataProvider::from_slice(embedded_font)
+                    };
+                    let font = core_graphics::font::CGFont::from_data_provider(data_provider)
+                        .map_err(|()| anyhow!("Could not load an embedded font."))?;
+                    let font = font_kit::loaders::core_text::Font::from_core_graphics_font(font);
+                    Ok(Handle::from_native(&font))
+                }
+                Cow::Owned(bytes) => Ok(Handle::from_memory(Arc::new(bytes), 0)),
+            })
+            .collect::<Result<Vec<_>>>()?;
+        self.memory_source.add_fonts(fonts.into_iter())?;
+        Ok(())
+    }
+
+    fn load_family(
+        &mut self,
+        name: &str,
+        features: &FontFeatures,
+        fallbacks: Option<&FontFallbacks>,
+    ) -> Result<SmallVec<[FontId; 4]>> {
+        let name = crate::text_system::font_name_with_fallbacks(name, ".AppleSystemUIFont");
+
+        let mut font_ids = SmallVec::new();
+        let family = self
+            .memory_source
+            .select_family_by_name(name)
+            .or_else(|_| self.system_source.select_family_by_name(name))?;
+        for font in family.fonts() {
+            let mut font = font.load()?;
+
+            apply_features_and_fallbacks(&mut font, features, fallbacks)?;
+            // This block contains a precautionary fix to guard against loading fonts
+            // that might cause panics due to `.unwrap()`s up the chain.
+            {
+                // We use the 'm' character for text measurements in various spots
+                // (e.g., the editor). However, at time of writing some of those usages
+                // will panic if the font has no 'm' glyph.
+                //
+                // Therefore, we check up front that the font has the necessary glyph.
+                let has_m_glyph = font.glyph_for_char('m').is_some();
+
+                // HACK: The 'Segoe Fluent Icons' font does not have an 'm' glyph,
+                // but we need to be able to load it for rendering Windows icons in
+                // the Storybook (on macOS).
+                let is_segoe_fluent_icons = font.full_name() == "Segoe Fluent Icons";
+
+                if !has_m_glyph && !is_segoe_fluent_icons {
+                    // I spent far too long trying to track down why a font missing the 'm'
+                    // character wasn't loading. This log statement will hopefully save
+                    // someone else from suffering the same fate.
+                    log::warn!(
+                        "font '{}' has no 'm' character and was not loaded",
+                        font.full_name()
+                    );
+                    continue;
+                }
+            }
+
+            // We've seen a number of panics in production caused by calling font.properties()
+            // which unwraps a downcast to CFNumber. This is an attempt to avoid the panic,
+            // and to try and identify the incalcitrant font.
+            let traits = font.native_font().all_traits();
+            if unsafe {
+                !(traits
+                    .get(kCTFontSymbolicTrait)
+                    .downcast::<CFNumber>()
+                    .is_some()
+                    && traits
+                        .get(kCTFontWidthTrait)
+                        .downcast::<CFNumber>()
+                        .is_some()
+                    && traits
+                        .get(kCTFontWeightTrait)
+                        .downcast::<CFNumber>()
+                        .is_some()
+                    && traits
+                        .get(kCTFontSlantTrait)
+                        .downcast::<CFNumber>()
+                        .is_some())
+            } {
+                log::error!(
+                    "Failed to read traits for font {:?}",
+                    font.postscript_name().unwrap()
+                );
+                continue;
+            }
+
+            let font_id = FontId(self.fonts.len());
+            font_ids.push(font_id);
+            let postscript_name = font.postscript_name().unwrap();
+            self.font_ids_by_postscript_name
+                .insert(postscript_name.clone(), font_id);
+            self.postscript_names_by_font_id
+                .insert(font_id, postscript_name);
+            self.fonts.push(font);
+        }
+        Ok(font_ids)
+    }
+
+    fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
+        Ok(self.fonts[font_id.0].advance(glyph_id.0)?.into())
+    }
+
+    fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
+        self.fonts[font_id.0].glyph_for_char(ch).map(GlyphId)
+    }
+
+    fn id_for_native_font(&mut self, requested_font: CTFont) -> FontId {
+        let postscript_name = requested_font.postscript_name();
+        if let Some(font_id) = self.font_ids_by_postscript_name.get(&postscript_name) {
+            *font_id
+        } else {
+            let font_id = FontId(self.fonts.len());
+            self.font_ids_by_postscript_name
+                .insert(postscript_name.clone(), font_id);
+            self.postscript_names_by_font_id
+                .insert(font_id, postscript_name);
+            self.fonts
+                .push(font_kit::font::Font::from_core_graphics_font(
+                    requested_font.copy_to_CGFont(),
+                ));
+            font_id
+        }
+    }
+
+    fn is_emoji(&self, font_id: FontId) -> bool {
+        self.postscript_names_by_font_id
+            .get(&font_id)
+            .is_some_and(|postscript_name| {
+                postscript_name == "AppleColorEmoji" || postscript_name == ".AppleColorEmojiUI"
+            })
+    }
+
+    fn raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
+        let font = &self.fonts[params.font_id.0];
+        let scale = Transform2F::from_scale(params.scale_factor);
+        Ok(font
+            .raster_bounds(
+                params.glyph_id.0,
+                params.font_size.into(),
+                scale,
+                HintingOptions::None,
+                font_kit::canvas::RasterizationOptions::GrayscaleAa,
+            )?
+            .into())
+    }
+
+    fn rasterize_glyph(
+        &self,
+        params: &RenderGlyphParams,
+        glyph_bounds: Bounds<DevicePixels>,
+    ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
+        if glyph_bounds.size.width.0 == 0 || glyph_bounds.size.height.0 == 0 {
+            anyhow::bail!("glyph bounds are empty");
+        } else {
+            // Add an extra pixel when the subpixel variant isn't zero to make room for anti-aliasing.
+            let mut bitmap_size = glyph_bounds.size;
+            if params.subpixel_variant.x > 0 {
+                bitmap_size.width += DevicePixels(1);
+            }
+            if params.subpixel_variant.y > 0 {
+                bitmap_size.height += DevicePixels(1);
+            }
+            let bitmap_size = bitmap_size;
+
+            let mut bytes;
+            let cx;
+            if params.is_emoji {
+                bytes = vec![0; bitmap_size.width.0 as usize * 4 * bitmap_size.height.0 as usize];
+                cx = CGContext::create_bitmap_context(
+                    Some(bytes.as_mut_ptr() as *mut _),
+                    bitmap_size.width.0 as usize,
+                    bitmap_size.height.0 as usize,
+                    8,
+                    bitmap_size.width.0 as usize * 4,
+                    &CGColorSpace::create_device_rgb(),
+                    kCGImageAlphaPremultipliedLast,
+                );
+            } else {
+                bytes = vec![0; bitmap_size.width.0 as usize * bitmap_size.height.0 as usize];
+                cx = CGContext::create_bitmap_context(
+                    Some(bytes.as_mut_ptr() as *mut _),
+                    bitmap_size.width.0 as usize,
+                    bitmap_size.height.0 as usize,
+                    8,
+                    bitmap_size.width.0 as usize,
+                    &CGColorSpace::create_device_gray(),
+                    kCGImageAlphaOnly,
+                );
+            }
+
+            // Move the origin to bottom left and account for scaling, this
+            // makes drawing text consistent with the font-kit's raster_bounds.
+            cx.translate(
+                -glyph_bounds.origin.x.0 as CGFloat,
+                (glyph_bounds.origin.y.0 + glyph_bounds.size.height.0) as CGFloat,
+            );
+            cx.scale(
+                params.scale_factor as CGFloat,
+                params.scale_factor as CGFloat,
+            );
+
+            let subpixel_shift = params
+                .subpixel_variant
+                .map(|v| v as f32 / SUBPIXEL_VARIANTS_X as f32);
+            cx.set_text_drawing_mode(CGTextDrawingMode::CGTextFill);
+            cx.set_gray_fill_color(0.0, 1.0);
+            cx.set_allows_antialiasing(true);
+            cx.set_should_antialias(true);
+            cx.set_allows_font_subpixel_positioning(true);
+            cx.set_should_subpixel_position_fonts(true);
+            cx.set_allows_font_subpixel_quantization(false);
+            cx.set_should_subpixel_quantize_fonts(false);
+            self.fonts[params.font_id.0]
+                .native_font()
+                .clone_with_font_size(f32::from(params.font_size) as CGFloat)
+                .draw_glyphs(
+                    &[params.glyph_id.0 as CGGlyph],
+                    &[CGPoint::new(
+                        (subpixel_shift.x / params.scale_factor) as CGFloat,
+                        (subpixel_shift.y / params.scale_factor) as CGFloat,
+                    )],
+                    cx,
+                );
+
+            if params.is_emoji {
+                // Convert from RGBA with premultiplied alpha to BGRA with straight alpha.
+                for pixel in bytes.chunks_exact_mut(4) {
+                    swap_rgba_pa_to_bgra(pixel);
+                }
+            }
+
+            Ok((bitmap_size, bytes))
+        }
+    }
+
+    fn layout_line(&mut self, text: &str, font_size: Pixels, font_runs: &[FontRun]) -> LineLayout {
+        const ZWNJ: char = '\u{200C}';
+        const ZWNJ_STR: &str = "\u{200C}";
+        const ZWNJ_SIZE_16: usize = ZWNJ.len_utf16();
+
+        self.zwnjs_scratch_space.clear();
+        // Construct the attributed string, converting UTF8 ranges to UTF16 ranges.
+        let mut string = CFMutableAttributedString::new();
+        let mut max_ascent = 0.0f32;
+        let mut max_descent = 0.0f32;
+
+        {
+            let mut ix_converter = StringIndexConverter::new(&text);
+            let mut last_font_run = None;
+            for run in font_runs {
+                let text = &text[ix_converter.utf8_ix..][..run.len];
+                // if the fonts are the same, we need to disconnect the text with a ZWNJ
+                // to prevent core text from forming ligatures between them
+                let needs_zwnj = last_font_run.replace(run.font_id) == Some(run.font_id);
+
+                let utf16_start = string.char_len(); // insert at end of string
+                ix_converter.advance_to_utf8_ix(ix_converter.utf8_ix + run.len);
+
+                // note: replace_str may silently ignore codepoints it dislikes (e.g., BOM at start of string)
+                string.replace_str(&CFString::new(text), CFRange::init(utf16_start, 0));
+                if needs_zwnj {
+                    let zwnjs_pos = string.char_len();
+                    self.zwnjs_scratch_space.push(zwnjs_pos as usize);
+                    string.replace_str(
+                        &CFString::from_static_string(ZWNJ_STR),
+                        CFRange::init(zwnjs_pos, 0),
+                    );
+                }
+                let utf16_end = string.char_len();
+
+                let cf_range = CFRange::init(utf16_start, utf16_end - utf16_start);
+                let font = &self.fonts[run.font_id.0];
+
+                let font_metrics = font.metrics();
+                let font_scale = font_size.0 / font_metrics.units_per_em as f32;
+                max_ascent = max_ascent.max(font_metrics.ascent * font_scale);
+                max_descent = max_descent.max(-font_metrics.descent * font_scale);
+
+                unsafe {
+                    string.set_attribute(
+                        cf_range,
+                        kCTFontAttributeName,
+                        &font.native_font().clone_with_font_size(font_size.into()),
+                    );
+                }
+            }
+        }
+        // Retrieve the glyphs from the shaped line, converting UTF16 offsets to UTF8 offsets.
+        let line = CTLine::new_with_attributed_string(string.as_concrete_TypeRef());
+        let glyph_runs = line.glyph_runs();
+        let mut runs = <Vec<ShapedRun>>::with_capacity(glyph_runs.len() as usize);
+        let mut ix_converter = StringIndexConverter::new(text);
+        for run in glyph_runs.into_iter() {
+            let attributes = run.attributes().unwrap();
+            let font = unsafe {
+                attributes
+                    .get(kCTFontAttributeName)
+                    .downcast::<CTFont>()
+                    .unwrap()
+            };
+            let font_id = self.id_for_native_font(font);
+
+            let mut glyphs = match runs.last_mut() {
+                Some(run) if run.font_id == font_id => &mut run.glyphs,
+                _ => {
+                    runs.push(ShapedRun {
+                        font_id,
+                        glyphs: Vec::with_capacity(run.glyph_count().try_into().unwrap_or(0)),
+                    });
+                    &mut runs.last_mut().unwrap().glyphs
+                }
+            };
+            for ((&glyph_id, position), &glyph_utf16_ix) in run
+                .glyphs()
+                .iter()
+                .zip(run.positions().iter())
+                .zip(run.string_indices().iter())
+            {
+                let mut glyph_utf16_ix = usize::try_from(glyph_utf16_ix).unwrap();
+                let r = self
+                    .zwnjs_scratch_space
+                    .binary_search_by(|&it| it.cmp(&glyph_utf16_ix));
+                match r {
+                    // this glyph is a ZWNJ, skip it
+                    Ok(_) => continue,
+                    // adjust the index to account for the ZWNJs we've inserted
+                    Err(idx) => glyph_utf16_ix -= idx * ZWNJ_SIZE_16,
+                }
+                if ix_converter.utf16_ix > glyph_utf16_ix {
+                    // We cannot reuse current index converter, as it can only seek forward. Restart the search.
+                    ix_converter = StringIndexConverter::new(text);
+                }
+                ix_converter.advance_to_utf16_ix(glyph_utf16_ix);
+                glyphs.push(ShapedGlyph {
+                    id: GlyphId(glyph_id as u32),
+                    position: point(position.x as f32, position.y as f32).map(px),
+                    index: ix_converter.utf8_ix,
+                    is_emoji: self.is_emoji(font_id),
+                });
+            }
+        }
+        let typographic_bounds = line.get_typographic_bounds();
+        LineLayout {
+            runs,
+            font_size,
+            width: typographic_bounds.width.into(),
+            ascent: max_ascent.into(),
+            descent: max_descent.into(),
+            len: text.len(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct StringIndexConverter<'a> {
+    text: &'a str,
+    /// Index in UTF-8 bytes
+    utf8_ix: usize,
+    /// Index in UTF-16 code units
+    utf16_ix: usize,
+}
+
+impl<'a> StringIndexConverter<'a> {
+    fn new(text: &'a str) -> Self {
+        Self {
+            text,
+            utf8_ix: 0,
+            utf16_ix: 0,
+        }
+    }
+
+    fn advance_to_utf8_ix(&mut self, utf8_target: usize) {
+        for (ix, c) in self.text[self.utf8_ix..].char_indices() {
+            if self.utf8_ix + ix >= utf8_target {
+                self.utf8_ix += ix;
+                return;
+            }
+            self.utf16_ix += c.len_utf16();
+        }
+        self.utf8_ix = self.text.len();
+    }
+
+    fn advance_to_utf16_ix(&mut self, utf16_target: usize) {
+        for (ix, c) in self.text[self.utf8_ix..].char_indices() {
+            if self.utf16_ix >= utf16_target {
+                self.utf8_ix += ix;
+                return;
+            }
+            self.utf16_ix += c.len_utf16();
+        }
+        self.utf8_ix = self.text.len();
+    }
+}
+
+impl From<Metrics> for FontMetrics {
+    fn from(metrics: Metrics) -> Self {
+        FontMetrics {
+            units_per_em: metrics.units_per_em,
+            ascent: metrics.ascent,
+            descent: metrics.descent,
+            line_gap: metrics.line_gap,
+            underline_position: metrics.underline_position,
+            underline_thickness: metrics.underline_thickness,
+            cap_height: metrics.cap_height,
+            x_height: metrics.x_height,
+            bounding_box: metrics.bounding_box.into(),
+        }
+    }
+}
+
+impl From<RectF> for Bounds<f32> {
+    fn from(rect: RectF) -> Self {
+        Bounds {
+            origin: point(rect.origin_x(), rect.origin_y()),
+            size: size(rect.width(), rect.height()),
+        }
+    }
+}
+
+impl From<RectI> for Bounds<DevicePixels> {
+    fn from(rect: RectI) -> Self {
+        Bounds {
+            origin: point(DevicePixels(rect.origin_x()), DevicePixels(rect.origin_y())),
+            size: size(DevicePixels(rect.width()), DevicePixels(rect.height())),
+        }
+    }
+}
+
+impl From<Vector2I> for Size<DevicePixels> {
+    fn from(value: Vector2I) -> Self {
+        size(value.x().into(), value.y().into())
+    }
+}
+
+impl From<RectI> for Bounds<i32> {
+    fn from(rect: RectI) -> Self {
+        Bounds {
+            origin: point(rect.origin_x(), rect.origin_y()),
+            size: size(rect.width(), rect.height()),
+        }
+    }
+}
+
+impl From<Point<u32>> for Vector2I {
+    fn from(size: Point<u32>) -> Self {
+        Vector2I::new(size.x as i32, size.y as i32)
+    }
+}
+
+impl From<Vector2F> for Size<f32> {
+    fn from(vec: Vector2F) -> Self {
+        size(vec.x(), vec.y())
+    }
+}
+
+impl From<FontWeight> for FontkitWeight {
+    fn from(value: FontWeight) -> Self {
+        FontkitWeight(value.0)
+    }
+}
+
+impl From<FontStyle> for FontkitStyle {
+    fn from(style: FontStyle) -> Self {
+        match style {
+            FontStyle::Normal => FontkitStyle::Normal,
+            FontStyle::Italic => FontkitStyle::Italic,
+            FontStyle::Oblique => FontkitStyle::Oblique,
+        }
+    }
+}
+
+// Some fonts may have no attributes despite `core_text` requiring them (and panicking).
+// This is the same version as `core_text` has without `expect` calls.
+mod lenient_font_attributes {
+    use core_foundation::{
+        base::{CFRetain, CFType, TCFType},
+        string::{CFString, CFStringRef},
+    };
+    use core_text::font_descriptor::{
+        CTFontDescriptor, CTFontDescriptorCopyAttribute, kCTFontFamilyNameAttribute,
+    };
+
+    pub fn family_name(descriptor: &CTFontDescriptor) -> Option<String> {
+        unsafe { get_string_attribute(descriptor, kCTFontFamilyNameAttribute) }
+    }
+
+    fn get_string_attribute(
+        descriptor: &CTFontDescriptor,
+        attribute: CFStringRef,
+    ) -> Option<String> {
+        unsafe {
+            let value = CTFontDescriptorCopyAttribute(descriptor.as_concrete_TypeRef(), attribute);
+            if value.is_null() {
+                return None;
+            }
+
+            let value = CFType::wrap_under_create_rule(value);
+            assert!(value.instance_of::<CFString>());
+            let s = wrap_under_get_rule(value.as_CFTypeRef() as CFStringRef);
+            Some(s.to_string())
+        }
+    }
+
+    unsafe fn wrap_under_get_rule(reference: CFStringRef) -> CFString {
+        unsafe {
+            assert!(!reference.is_null(), "Attempted to create a NULL object.");
+            let reference = CFRetain(reference as *const ::std::os::raw::c_void) as CFStringRef;
+            TCFType::wrap_under_create_rule(reference)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{FontRun, GlyphId, MacTextSystem, PlatformTextSystem, font, px};
+
+    #[test]
+    fn test_layout_line_bom_char() {
+        let fonts = MacTextSystem::new();
+        let font_id = fonts.font_id(&font("Helvetica")).unwrap();
+        let line = "\u{feff}";
+        let mut style = FontRun {
+            font_id,
+            len: line.len(),
+        };
+
+        let layout = fonts.layout_line(line, px(16.), &[style]);
+        assert_eq!(layout.len, line.len());
+        assert!(layout.runs.is_empty());
+
+        let line = "a\u{feff}b";
+        style.len = line.len();
+        let layout = fonts.layout_line(line, px(16.), &[style]);
+        assert_eq!(layout.len, line.len());
+        assert_eq!(layout.runs.len(), 1);
+        assert_eq!(layout.runs[0].glyphs.len(), 2);
+        assert_eq!(layout.runs[0].glyphs[0].id, GlyphId(68u32)); // a
+        // There's no glyph for \u{feff}
+        assert_eq!(layout.runs[0].glyphs[1].id, GlyphId(69u32)); // b
+
+        let line = "\u{feff}ab";
+        let font_runs = &[
+            FontRun {
+                len: "\u{feff}".len(),
+                font_id,
+            },
+            FontRun {
+                len: "ab".len(),
+                font_id,
+            },
+        ];
+        let layout = fonts.layout_line(line, px(16.), font_runs);
+        assert_eq!(layout.len, line.len());
+        assert_eq!(layout.runs.len(), 1);
+        assert_eq!(layout.runs[0].glyphs.len(), 2);
+        // There's no glyph for \u{feff}
+        assert_eq!(layout.runs[0].glyphs[0].id, GlyphId(68u32)); // a
+        assert_eq!(layout.runs[0].glyphs[1].id, GlyphId(69u32)); // b
+    }
+
+    #[test]
+    fn test_layout_line_zwnj_insertion() {
+        let fonts = MacTextSystem::new();
+        let font_id = fonts.font_id(&font("Helvetica")).unwrap();
+
+        let text = "hello world";
+        let font_runs = &[
+            FontRun { font_id, len: 5 }, // "hello"
+            FontRun { font_id, len: 6 }, // " world"
+        ];
+
+        let layout = fonts.layout_line(text, px(16.), font_runs);
+        assert_eq!(layout.len, text.len());
+
+        for run in &layout.runs {
+            for glyph in &run.glyphs {
+                assert!(
+                    glyph.index < text.len(),
+                    "Glyph index {} is out of bounds for text length {}",
+                    glyph.index,
+                    text.len()
+                );
+            }
+        }
+
+        // Test with different font runs - should not insert ZWNJ
+        let font_id2 = fonts.font_id(&font("Times")).unwrap_or(font_id);
+        let font_runs_different = &[
+            FontRun { font_id, len: 5 }, // "hello"
+            // " world"
+            FontRun {
+                font_id: font_id2,
+                len: 6,
+            },
+        ];
+
+        let layout2 = fonts.layout_line(text, px(16.), font_runs_different);
+        assert_eq!(layout2.len, text.len());
+
+        for run in &layout2.runs {
+            for glyph in &run.glyphs {
+                assert!(
+                    glyph.index < text.len(),
+                    "Glyph index {} is out of bounds for text length {}",
+                    glyph.index,
+                    text.len()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_layout_line_zwnj_edge_cases() {
+        let fonts = MacTextSystem::new();
+        let font_id = fonts.font_id(&font("Helvetica")).unwrap();
+
+        let text = "hello";
+        let font_runs = &[FontRun { font_id, len: 5 }];
+        let layout = fonts.layout_line(text, px(16.), font_runs);
+        assert_eq!(layout.len, text.len());
+
+        let text = "abc";
+        let font_runs = &[
+            FontRun { font_id, len: 1 }, // "a"
+            FontRun { font_id, len: 1 }, // "b"
+            FontRun { font_id, len: 1 }, // "c"
+        ];
+        let layout = fonts.layout_line(text, px(16.), font_runs);
+        assert_eq!(layout.len, text.len());
+
+        for run in &layout.runs {
+            for glyph in &run.glyphs {
+                assert!(
+                    glyph.index < text.len(),
+                    "Glyph index {} is out of bounds for text length {}",
+                    glyph.index,
+                    text.len()
+                );
+            }
+        }
+
+        // Test with empty text
+        let text = "";
+        let font_runs = &[];
+        let layout = fonts.layout_line(text, px(16.), font_runs);
+        assert_eq!(layout.len, 0);
+        assert!(layout.runs.is_empty());
+    }
+}

third_party/gpui/src/platform/mac/window_appearance.rs

@@ -0,0 +1,37 @@
+use crate::WindowAppearance;
+use cocoa::{
+    appkit::{NSAppearanceNameVibrantDark, NSAppearanceNameVibrantLight},
+    base::id,
+    foundation::NSString,
+};
+use objc::{msg_send, sel, sel_impl};
+use std::ffi::CStr;
+
+impl WindowAppearance {
+    pub(crate) unsafe fn from_native(appearance: id) -> Self {
+        let name: id = msg_send![appearance, name];
+        unsafe {
+            if name == NSAppearanceNameVibrantLight {
+                Self::VibrantLight
+            } else if name == NSAppearanceNameVibrantDark {
+                Self::VibrantDark
+            } else if name == NSAppearanceNameAqua {
+                Self::Light
+            } else if name == NSAppearanceNameDarkAqua {
+                Self::Dark
+            } else {
+                println!(
+                    "unknown appearance: {:?}",
+                    CStr::from_ptr(name.UTF8String())
+                );
+                Self::Light
+            }
+        }
+    }
+}
+
+#[link(name = "AppKit", kind = "framework")]
+unsafe extern "C" {
+    pub static NSAppearanceNameAqua: id;
+    pub static NSAppearanceNameDarkAqua: id;
+}

third_party/gpui/src/platform/scap_screen_capture.rs

@@ -0,0 +1,325 @@
+//! Screen capture for Linux and Windows
+use crate::{
+    DevicePixels, ForegroundExecutor, ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream,
+    Size, SourceMetadata, size,
+};
+use anyhow::{Context as _, Result, anyhow};
+use futures::channel::oneshot;
+use scap::Target;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::sync::atomic::{self, AtomicBool};
+
+/// Populates the receiver with the screens that can be captured.
+///
+/// `scap_default_target_source` should be used instead on Wayland, since `scap_screen_sources`
+/// won't return any results.
+#[allow(dead_code)]
+pub(crate) fn scap_screen_sources(
+    foreground_executor: &ForegroundExecutor,
+) -> oneshot::Receiver<Result<Vec<Rc<dyn ScreenCaptureSource>>>> {
+    let (sources_tx, sources_rx) = oneshot::channel();
+    get_screen_targets(sources_tx);
+    to_dyn_screen_capture_sources(sources_rx, foreground_executor)
+}
+
+/// Starts screen capture for the default target, and populates the receiver with a single source
+/// for it. The first frame of the screen capture is used to determine the size of the stream.
+///
+/// On Wayland (Linux), prompts the user to select a target, and populates the receiver with a
+/// single screen capture source for their selection.
+#[allow(dead_code)]
+pub(crate) fn start_scap_default_target_source(
+    foreground_executor: &ForegroundExecutor,
+) -> oneshot::Receiver<Result<Vec<Rc<dyn ScreenCaptureSource>>>> {
+    let (sources_tx, sources_rx) = oneshot::channel();
+    start_default_target_screen_capture(sources_tx);
+    to_dyn_screen_capture_sources(sources_rx, foreground_executor)
+}
+
+struct ScapCaptureSource {
+    target: scap::Display,
+    size: Size<DevicePixels>,
+}
+
+/// Populates the sender with the screens available for capture.
+fn get_screen_targets(sources_tx: oneshot::Sender<Result<Vec<ScapCaptureSource>>>) {
+    // Due to use of blocking APIs, a new thread is used.
+    std::thread::spawn(|| {
+        let targets = match scap::get_all_targets() {
+            Ok(targets) => targets,
+            Err(err) => {
+                sources_tx.send(Err(err)).ok();
+                return;
+            }
+        };
+        let sources = targets
+            .into_iter()
+            .filter_map(|target| match target {
+                scap::Target::Display(display) => {
+                    let size = Size {
+                        width: DevicePixels(display.width as i32),
+                        height: DevicePixels(display.height as i32),
+                    };
+                    Some(ScapCaptureSource {
+                        target: display,
+                        size,
+                    })
+                }
+                scap::Target::Window(_) => None,
+            })
+            .collect::<Vec<_>>();
+        sources_tx.send(Ok(sources)).ok();
+    });
+}
+
+impl ScreenCaptureSource for ScapCaptureSource {
+    fn metadata(&self) -> Result<SourceMetadata> {
+        Ok(SourceMetadata {
+            resolution: self.size,
+            label: Some(self.target.title.clone().into()),
+            is_main: None,
+            id: self.target.id as u64,
+        })
+    }
+
+    fn stream(
+        &self,
+        foreground_executor: &ForegroundExecutor,
+        frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,
+    ) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>> {
+        let (stream_tx, stream_rx) = oneshot::channel();
+        let target = self.target.clone();
+
+        // Due to use of blocking APIs, a dedicated thread is used.
+        std::thread::spawn(move || {
+            match new_scap_capturer(Some(scap::Target::Display(target.clone()))) {
+                Ok(mut capturer) => {
+                    capturer.start_capture();
+                    run_capture(capturer, target.clone(), frame_callback, stream_tx);
+                }
+                Err(e) => {
+                    stream_tx.send(Err(e)).ok();
+                }
+            }
+        });
+
+        to_dyn_screen_capture_stream(stream_rx, foreground_executor)
+    }
+}
+
+struct ScapDefaultTargetCaptureSource {
+    // Sender populated by single call to `ScreenCaptureSource::stream`.
+    stream_call_tx: std::sync::mpsc::SyncSender<(
+        // Provides the result of `ScreenCaptureSource::stream`.
+        oneshot::Sender<Result<ScapStream>>,
+        // Callback for frames.
+        Box<dyn Fn(ScreenCaptureFrame) + Send>,
+    )>,
+    target: scap::Display,
+    size: Size<DevicePixels>,
+}
+
+/// Starts screen capture on the default capture target, and populates the sender with the source.
+fn start_default_target_screen_capture(
+    sources_tx: oneshot::Sender<Result<Vec<ScapDefaultTargetCaptureSource>>>,
+) {
+    // Due to use of blocking APIs, a dedicated thread is used.
+    std::thread::spawn(|| {
+        let start_result = util::maybe!({
+            let mut capturer = new_scap_capturer(None)?;
+            capturer.start_capture();
+            let first_frame = capturer
+                .get_next_frame()
+                .context("Failed to get first frame of screenshare to get the size.")?;
+            let size = frame_size(&first_frame);
+            let target = capturer
+                .target()
+                .context("Unable to determine the target display.")?;
+            let target = target.clone();
+            Ok((capturer, size, target))
+        });
+
+        match start_result {
+            Ok((capturer, size, Target::Display(display))) => {
+                let (stream_call_tx, stream_rx) = std::sync::mpsc::sync_channel(1);
+                sources_tx
+                    .send(Ok(vec![ScapDefaultTargetCaptureSource {
+                        stream_call_tx,
+                        size,
+                        target: display.clone(),
+                    }]))
+                    .ok();
+                let Ok((stream_tx, frame_callback)) = stream_rx.recv() else {
+                    return;
+                };
+                run_capture(capturer, display, frame_callback, stream_tx);
+            }
+            Err(e) => {
+                sources_tx.send(Err(e)).ok();
+            }
+            _ => {
+                sources_tx
+                    .send(Err(anyhow!("The screen capture source is not a display")))
+                    .ok();
+            }
+        }
+    });
+}
+
+impl ScreenCaptureSource for ScapDefaultTargetCaptureSource {
+    fn metadata(&self) -> Result<SourceMetadata> {
+        Ok(SourceMetadata {
+            resolution: self.size,
+            label: None,
+            is_main: None,
+            id: self.target.id as u64,
+        })
+    }
+
+    fn stream(
+        &self,
+        foreground_executor: &ForegroundExecutor,
+        frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,
+    ) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>> {
+        let (tx, rx) = oneshot::channel();
+        match self.stream_call_tx.try_send((tx, frame_callback)) {
+            Ok(()) => {}
+            Err(std::sync::mpsc::TrySendError::Full((tx, _)))
+            | Err(std::sync::mpsc::TrySendError::Disconnected((tx, _))) => {
+                // Note: support could be added for being called again after end of prior stream.
+                tx.send(Err(anyhow!(
+                    "Can't call ScapDefaultTargetCaptureSource::stream multiple times."
+                )))
+                .ok();
+            }
+        }
+        to_dyn_screen_capture_stream(rx, foreground_executor)
+    }
+}
+
+fn new_scap_capturer(target: Option<scap::Target>) -> Result<scap::capturer::Capturer> {
+    scap::capturer::Capturer::build(scap::capturer::Options {
+        fps: 60,
+        show_cursor: true,
+        show_highlight: true,
+        // Note that the actual frame output type may differ.
+        output_type: scap::frame::FrameType::YUVFrame,
+        output_resolution: scap::capturer::Resolution::Captured,
+        crop_area: None,
+        target,
+        excluded_targets: None,
+    })
+}
+
+fn run_capture(
+    mut capturer: scap::capturer::Capturer,
+    display: scap::Display,
+    frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,
+    stream_tx: oneshot::Sender<Result<ScapStream>>,
+) {
+    let cancel_stream = Arc::new(AtomicBool::new(false));
+    let size = Size {
+        width: DevicePixels(display.width as i32),
+        height: DevicePixels(display.height as i32),
+    };
+    let stream_send_result = stream_tx.send(Ok(ScapStream {
+        cancel_stream: cancel_stream.clone(),
+        display,
+        size,
+    }));
+    if stream_send_result.is_err() {
+        return;
+    }
+    while !cancel_stream.load(std::sync::atomic::Ordering::SeqCst) {
+        match capturer.get_next_frame() {
+            Ok(frame) => frame_callback(ScreenCaptureFrame(frame)),
+            Err(err) => {
+                log::error!("Halting screen capture due to error: {err}");
+                break;
+            }
+        }
+    }
+    capturer.stop_capture();
+}
+
+struct ScapStream {
+    cancel_stream: Arc<AtomicBool>,
+    display: scap::Display,
+    size: Size<DevicePixels>,
+}
+
+impl ScreenCaptureStream for ScapStream {
+    fn metadata(&self) -> Result<SourceMetadata> {
+        Ok(SourceMetadata {
+            resolution: self.size,
+            label: Some(self.display.title.clone().into()),
+            is_main: None,
+            id: self.display.id as u64,
+        })
+    }
+}
+
+impl Drop for ScapStream {
+    fn drop(&mut self) {
+        self.cancel_stream.store(true, atomic::Ordering::SeqCst);
+    }
+}
+
+fn frame_size(frame: &scap::frame::Frame) -> Size<DevicePixels> {
+    let (width, height) = match frame {
+        scap::frame::Frame::YUVFrame(frame) => (frame.width, frame.height),
+        scap::frame::Frame::RGB(frame) => (frame.width, frame.height),
+        scap::frame::Frame::RGBx(frame) => (frame.width, frame.height),
+        scap::frame::Frame::XBGR(frame) => (frame.width, frame.height),
+        scap::frame::Frame::BGRx(frame) => (frame.width, frame.height),
+        scap::frame::Frame::BGR0(frame) => (frame.width, frame.height),
+        scap::frame::Frame::BGRA(frame) => (frame.width, frame.height),
+    };
+    size(DevicePixels(width), DevicePixels(height))
+}
+
+/// This is used by `get_screen_targets` and `start_default_target_screen_capture` to turn their
+/// results into `Rc<dyn ScreenCaptureSource>`. They need to `Send` their capture source, and so
+/// the capture source structs are used as `Rc<dyn ScreenCaptureSource>` is not `Send`.
+fn to_dyn_screen_capture_sources<T: ScreenCaptureSource + 'static>(
+    sources_rx: oneshot::Receiver<Result<Vec<T>>>,
+    foreground_executor: &ForegroundExecutor,
+) -> oneshot::Receiver<Result<Vec<Rc<dyn ScreenCaptureSource>>>> {
+    let (dyn_sources_tx, dyn_sources_rx) = oneshot::channel();
+    foreground_executor
+        .spawn(async move {
+            match sources_rx.await {
+                Ok(Ok(results)) => dyn_sources_tx
+                    .send(Ok(results
+                        .into_iter()
+                        .map(|source| Rc::new(source) as Rc<dyn ScreenCaptureSource>)
+                        .collect::<Vec<_>>()))
+                    .ok(),
+                Ok(Err(err)) => dyn_sources_tx.send(Err(err)).ok(),
+                Err(oneshot::Canceled) => None,
+            }
+        })
+        .detach();
+    dyn_sources_rx
+}
+
+/// Same motivation as `to_dyn_screen_capture_sources` above.
+fn to_dyn_screen_capture_stream<T: ScreenCaptureStream + 'static>(
+    sources_rx: oneshot::Receiver<Result<T>>,
+    foreground_executor: &ForegroundExecutor,
+) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>> {
+    let (dyn_sources_tx, dyn_sources_rx) = oneshot::channel();
+    foreground_executor
+        .spawn(async move {
+            match sources_rx.await {
+                Ok(Ok(stream)) => dyn_sources_tx
+                    .send(Ok(Box::new(stream) as Box<dyn ScreenCaptureStream>))
+                    .ok(),
+                Ok(Err(err)) => dyn_sources_tx.send(Err(err)).ok(),
+                Err(oneshot::Canceled) => None,
+            }
+        })
+        .detach();
+    dyn_sources_rx
+}

third_party/gpui/src/platform/test.rs

@@ -0,0 +1,11 @@
+mod dispatcher;
+mod display;
+mod platform;
+mod window;
+
+pub use dispatcher::*;
+pub(crate) use display::*;
+pub(crate) use platform::*;
+pub(crate) use window::*;
+
+pub use platform::{TestScreenCaptureSource, TestScreenCaptureStream};

third_party/gpui/src/platform/test/dispatcher.rs

@@ -0,0 +1,314 @@
+use crate::{PlatformDispatcher, TaskLabel};
+use async_task::Runnable;
+use backtrace::Backtrace;
+use collections::{HashMap, HashSet, VecDeque};
+use parking::Unparker;
+use parking_lot::Mutex;
+use rand::prelude::*;
+use std::{
+    future::Future,
+    ops::RangeInclusive,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+    time::{Duration, Instant},
+};
+use util::post_inc;
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+struct TestDispatcherId(usize);
+
+#[doc(hidden)]
+pub struct TestDispatcher {
+    id: TestDispatcherId,
+    state: Arc<Mutex<TestDispatcherState>>,
+}
+
+struct TestDispatcherState {
+    random: StdRng,
+    foreground: HashMap<TestDispatcherId, VecDeque<Runnable>>,
+    background: Vec<Runnable>,
+    deprioritized_background: Vec<Runnable>,
+    delayed: Vec<(Duration, Runnable)>,
+    start_time: Instant,
+    time: Duration,
+    is_main_thread: bool,
+    next_id: TestDispatcherId,
+    allow_parking: bool,
+    waiting_hint: Option<String>,
+    waiting_backtrace: Option<Backtrace>,
+    deprioritized_task_labels: HashSet<TaskLabel>,
+    block_on_ticks: RangeInclusive<usize>,
+    last_parked: Option<Unparker>,
+}
+
+impl TestDispatcher {
+    pub fn new(random: StdRng) -> Self {
+        let state = TestDispatcherState {
+            random,
+            foreground: HashMap::default(),
+            background: Vec::new(),
+            deprioritized_background: Vec::new(),
+            delayed: Vec::new(),
+            time: Duration::ZERO,
+            start_time: Instant::now(),
+            is_main_thread: true,
+            next_id: TestDispatcherId(1),
+            allow_parking: false,
+            waiting_hint: None,
+            waiting_backtrace: None,
+            deprioritized_task_labels: Default::default(),
+            block_on_ticks: 0..=1000,
+            last_parked: None,
+        };
+
+        TestDispatcher {
+            id: TestDispatcherId(0),
+            state: Arc::new(Mutex::new(state)),
+        }
+    }
+
+    pub fn advance_clock(&self, by: Duration) {
+        let new_now = self.state.lock().time + by;
+        loop {
+            self.run_until_parked();
+            let state = self.state.lock();
+            let next_due_time = state.delayed.first().map(|(time, _)| *time);
+            drop(state);
+            if let Some(due_time) = next_due_time
+                && due_time <= new_now
+            {
+                self.state.lock().time = due_time;
+                continue;
+            }
+            break;
+        }
+        self.state.lock().time = new_now;
+    }
+
+    pub fn advance_clock_to_next_delayed(&self) -> bool {
+        let next_due_time = self.state.lock().delayed.first().map(|(time, _)| *time);
+        if let Some(next_due_time) = next_due_time {
+            self.state.lock().time = next_due_time;
+            return true;
+        }
+        false
+    }
+
+    pub fn simulate_random_delay(&self) -> impl 'static + Send + Future<Output = ()> + use<> {
+        struct YieldNow {
+            pub(crate) count: usize,
+        }
+
+        impl Future for YieldNow {
+            type Output = ();
+
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+                if self.count > 0 {
+                    self.count -= 1;
+                    cx.waker().wake_by_ref();
+                    Poll::Pending
+                } else {
+                    Poll::Ready(())
+                }
+            }
+        }
+
+        YieldNow {
+            count: self.state.lock().random.random_range(0..10),
+        }
+    }
+
+    pub fn tick(&self, background_only: bool) -> bool {
+        let mut state = self.state.lock();
+
+        while let Some((deadline, _)) = state.delayed.first() {
+            if *deadline > state.time {
+                break;
+            }
+            let (_, runnable) = state.delayed.remove(0);
+            state.background.push(runnable);
+        }
+
+        let foreground_len: usize = if background_only {
+            0
+        } else {
+            state
+                .foreground
+                .values()
+                .map(|runnables| runnables.len())
+                .sum()
+        };
+        let background_len = state.background.len();
+
+        let runnable;
+        let main_thread;
+        if foreground_len == 0 && background_len == 0 {
+            let deprioritized_background_len = state.deprioritized_background.len();
+            if deprioritized_background_len == 0 {
+                return false;
+            }
+            let ix = state.random.random_range(0..deprioritized_background_len);
+            main_thread = false;
+            runnable = state.deprioritized_background.swap_remove(ix);
+        } else {
+            main_thread = state.random.random_ratio(
+                foreground_len as u32,
+                (foreground_len + background_len) as u32,
+            );
+            if main_thread {
+                let state = &mut *state;
+                runnable = state
+                    .foreground
+                    .values_mut()
+                    .filter(|runnables| !runnables.is_empty())
+                    .choose(&mut state.random)
+                    .unwrap()
+                    .pop_front()
+                    .unwrap();
+            } else {
+                let ix = state.random.random_range(0..background_len);
+                runnable = state.background.swap_remove(ix);
+            };
+        };
+
+        let was_main_thread = state.is_main_thread;
+        state.is_main_thread = main_thread;
+        drop(state);
+        runnable.run();
+        self.state.lock().is_main_thread = was_main_thread;
+
+        true
+    }
+
+    pub fn deprioritize(&self, task_label: TaskLabel) {
+        self.state
+            .lock()
+            .deprioritized_task_labels
+            .insert(task_label);
+    }
+
+    pub fn run_until_parked(&self) {
+        while self.tick(false) {}
+    }
+
+    pub fn parking_allowed(&self) -> bool {
+        self.state.lock().allow_parking
+    }
+
+    pub fn allow_parking(&self) {
+        self.state.lock().allow_parking = true
+    }
+
+    pub fn forbid_parking(&self) {
+        self.state.lock().allow_parking = false
+    }
+
+    pub fn set_waiting_hint(&self, msg: Option<String>) {
+        self.state.lock().waiting_hint = msg
+    }
+
+    pub fn waiting_hint(&self) -> Option<String> {
+        self.state.lock().waiting_hint.clone()
+    }
+
+    pub fn start_waiting(&self) {
+        self.state.lock().waiting_backtrace = Some(Backtrace::new_unresolved());
+    }
+
+    pub fn finish_waiting(&self) {
+        self.state.lock().waiting_backtrace.take();
+    }
+
+    pub fn waiting_backtrace(&self) -> Option<Backtrace> {
+        self.state.lock().waiting_backtrace.take().map(|mut b| {
+            b.resolve();
+            b
+        })
+    }
+
+    pub fn rng(&self) -> StdRng {
+        self.state.lock().random.clone()
+    }
+
+    pub fn set_block_on_ticks(&self, range: std::ops::RangeInclusive<usize>) {
+        self.state.lock().block_on_ticks = range;
+    }
+
+    pub fn gen_block_on_ticks(&self) -> usize {
+        let mut lock = self.state.lock();
+        let block_on_ticks = lock.block_on_ticks.clone();
+        lock.random.random_range(block_on_ticks)
+    }
+    pub fn unpark_last(&self) {
+        self.state
+            .lock()
+            .last_parked
+            .take()
+            .as_ref()
+            .map(Unparker::unpark);
+    }
+
+    pub fn set_unparker(&self, unparker: Unparker) {
+        let last = { self.state.lock().last_parked.replace(unparker) };
+        if let Some(last) = last {
+            last.unpark();
+        }
+    }
+}
+
+impl Clone for TestDispatcher {
+    fn clone(&self) -> Self {
+        let id = post_inc(&mut self.state.lock().next_id.0);
+        Self {
+            id: TestDispatcherId(id),
+            state: self.state.clone(),
+        }
+    }
+}
+
+impl PlatformDispatcher for TestDispatcher {
+    fn is_main_thread(&self) -> bool {
+        self.state.lock().is_main_thread
+    }
+
+    fn now(&self) -> Instant {
+        let state = self.state.lock();
+        state.start_time + state.time
+    }
+
+    fn dispatch(&self, runnable: Runnable, label: Option<TaskLabel>) {
+        {
+            let mut state = self.state.lock();
+            if label.is_some_and(|label| state.deprioritized_task_labels.contains(&label)) {
+                state.deprioritized_background.push(runnable);
+            } else {
+                state.background.push(runnable);
+            }
+        }
+        self.unpark_last();
+    }
+
+    fn dispatch_on_main_thread(&self, runnable: Runnable) {
+        self.state
+            .lock()
+            .foreground
+            .entry(self.id)
+            .or_default()
+            .push_back(runnable);
+        self.unpark_last();
+    }
+
+    fn dispatch_after(&self, duration: std::time::Duration, runnable: Runnable) {
+        let mut state = self.state.lock();
+        let next_time = state.time + duration;
+        let ix = match state.delayed.binary_search_by_key(&next_time, |e| e.0) {
+            Ok(ix) | Err(ix) => ix,
+        };
+        state.delayed.insert(ix, (next_time, runnable));
+    }
+
+    fn as_test(&self) -> Option<&TestDispatcher> {
+        Some(self)
+    }
+}

third_party/gpui/src/platform/test/display.rs

@@ -0,0 +1,33 @@
+use crate::{Bounds, DisplayId, Pixels, PlatformDisplay, Point, px};
+use anyhow::{Ok, Result};
+
+#[derive(Debug)]
+pub(crate) struct TestDisplay {
+    id: DisplayId,
+    uuid: uuid::Uuid,
+    bounds: Bounds<Pixels>,
+}
+
+impl TestDisplay {
+    pub fn new() -> Self {
+        TestDisplay {
+            id: DisplayId(1),
+            uuid: uuid::Uuid::new_v4(),
+            bounds: Bounds::from_corners(Point::default(), Point::new(px(1920.), px(1080.))),
+        }
+    }
+}
+
+impl PlatformDisplay for TestDisplay {
+    fn id(&self) -> crate::DisplayId {
+        self.id
+    }
+
+    fn uuid(&self) -> Result<uuid::Uuid> {
+        Ok(self.uuid)
+    }
+
+    fn bounds(&self) -> crate::Bounds<crate::Pixels> {
+        self.bounds
+    }
+}

third_party/gpui/src/platform/test/platform.rs

@@ -0,0 +1,463 @@
+use crate::{
+    AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DevicePixels,
+    DummyKeyboardMapper, ForegroundExecutor, Keymap, NoopTextSystem, Platform, PlatformDisplay,
+    PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem, PromptButton,
+    ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream, SourceMetadata, Task,
+    TestDisplay, TestWindow, WindowAppearance, WindowParams, size,
+};
+use anyhow::Result;
+use collections::VecDeque;
+use futures::channel::oneshot;
+use parking_lot::Mutex;
+use std::{
+    cell::RefCell,
+    path::{Path, PathBuf},
+    rc::{Rc, Weak},
+    sync::Arc,
+};
+#[cfg(target_os = "windows")]
+use windows::Win32::{
+    Graphics::Imaging::{CLSID_WICImagingFactory, IWICImagingFactory},
+    System::Com::{CLSCTX_INPROC_SERVER, CoCreateInstance},
+};
+
+/// TestPlatform implements the Platform trait for use in tests.
+pub(crate) struct TestPlatform {
+    background_executor: BackgroundExecutor,
+    foreground_executor: ForegroundExecutor,
+
+    pub(crate) active_window: RefCell<Option<TestWindow>>,
+    active_display: Rc<dyn PlatformDisplay>,
+    active_cursor: Mutex<CursorStyle>,
+    current_clipboard_item: Mutex<Option<ClipboardItem>>,
+    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+    current_primary_item: Mutex<Option<ClipboardItem>>,
+    pub(crate) prompts: RefCell<TestPrompts>,
+    screen_capture_sources: RefCell<Vec<TestScreenCaptureSource>>,
+    pub opened_url: RefCell<Option<String>>,
+    pub text_system: Arc<dyn PlatformTextSystem>,
+    #[cfg(target_os = "windows")]
+    bitmap_factory: std::mem::ManuallyDrop<IWICImagingFactory>,
+    weak: Weak<Self>,
+}
+
+#[derive(Clone)]
+/// A fake screen capture source, used for testing.
+pub struct TestScreenCaptureSource {}
+
+/// A fake screen capture stream, used for testing.
+pub struct TestScreenCaptureStream {}
+
+impl ScreenCaptureSource for TestScreenCaptureSource {
+    fn metadata(&self) -> Result<SourceMetadata> {
+        Ok(SourceMetadata {
+            id: 0,
+            is_main: None,
+            label: None,
+            resolution: size(DevicePixels(1), DevicePixels(1)),
+        })
+    }
+
+    fn stream(
+        &self,
+        _foreground_executor: &ForegroundExecutor,
+        _frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,
+    ) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>> {
+        let (mut tx, rx) = oneshot::channel();
+        let stream = TestScreenCaptureStream {};
+        tx.send(Ok(Box::new(stream) as Box<dyn ScreenCaptureStream>))
+            .ok();
+        rx
+    }
+}
+
+impl ScreenCaptureStream for TestScreenCaptureStream {
+    fn metadata(&self) -> Result<SourceMetadata> {
+        TestScreenCaptureSource {}.metadata()
+    }
+}
+
+struct TestPrompt {
+    msg: String,
+    detail: Option<String>,
+    answers: Vec<String>,
+    tx: oneshot::Sender<usize>,
+}
+
+#[derive(Default)]
+pub(crate) struct TestPrompts {
+    multiple_choice: VecDeque<TestPrompt>,
+    new_path: VecDeque<(PathBuf, oneshot::Sender<Result<Option<PathBuf>>>)>,
+}
+
+impl TestPlatform {
+    pub fn new(executor: BackgroundExecutor, foreground_executor: ForegroundExecutor) -> Rc<Self> {
+        #[cfg(target_os = "windows")]
+        let bitmap_factory = unsafe {
+            windows::Win32::System::Ole::OleInitialize(None)
+                .expect("unable to initialize Windows OLE");
+            std::mem::ManuallyDrop::new(
+                CoCreateInstance(&CLSID_WICImagingFactory, None, CLSCTX_INPROC_SERVER)
+                    .expect("Error creating bitmap factory."),
+            )
+        };
+
+        let text_system = Arc::new(NoopTextSystem);
+
+        Rc::new_cyclic(|weak| TestPlatform {
+            background_executor: executor,
+            foreground_executor,
+            prompts: Default::default(),
+            screen_capture_sources: Default::default(),
+            active_cursor: Default::default(),
+            active_display: Rc::new(TestDisplay::new()),
+            active_window: Default::default(),
+            current_clipboard_item: Mutex::new(None),
+            #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+            current_primary_item: Mutex::new(None),
+            weak: weak.clone(),
+            opened_url: Default::default(),
+            #[cfg(target_os = "windows")]
+            bitmap_factory,
+            text_system,
+        })
+    }
+
+    pub(crate) fn simulate_new_path_selection(
+        &self,
+        select_path: impl FnOnce(&std::path::Path) -> Option<std::path::PathBuf>,
+    ) {
+        let (path, tx) = self
+            .prompts
+            .borrow_mut()
+            .new_path
+            .pop_front()
+            .expect("no pending new path prompt");
+        self.background_executor().set_waiting_hint(None);
+        tx.send(Ok(select_path(&path))).ok();
+    }
+
+    #[track_caller]
+    pub(crate) fn simulate_prompt_answer(&self, response: &str) {
+        let prompt = self
+            .prompts
+            .borrow_mut()
+            .multiple_choice
+            .pop_front()
+            .expect("no pending multiple choice prompt");
+        self.background_executor().set_waiting_hint(None);
+        let Some(ix) = prompt.answers.iter().position(|a| a == response) else {
+            panic!(
+                "PROMPT: {}\n{:?}\n{:?}\nCannot respond with {}",
+                prompt.msg, prompt.detail, prompt.answers, response
+            )
+        };
+        prompt.tx.send(ix).ok();
+    }
+
+    pub(crate) fn has_pending_prompt(&self) -> bool {
+        !self.prompts.borrow().multiple_choice.is_empty()
+    }
+
+    pub(crate) fn pending_prompt(&self) -> Option<(String, String)> {
+        let prompts = self.prompts.borrow();
+        let prompt = prompts.multiple_choice.front()?;
+        Some((
+            prompt.msg.clone(),
+            prompt.detail.clone().unwrap_or_default(),
+        ))
+    }
+
+    pub(crate) fn set_screen_capture_sources(&self, sources: Vec<TestScreenCaptureSource>) {
+        *self.screen_capture_sources.borrow_mut() = sources;
+    }
+
+    pub(crate) fn prompt(
+        &self,
+        msg: &str,
+        detail: Option<&str>,
+        answers: &[PromptButton],
+    ) -> oneshot::Receiver<usize> {
+        let (tx, rx) = oneshot::channel();
+        let answers: Vec<String> = answers.iter().map(|s| s.label().to_string()).collect();
+        self.background_executor()
+            .set_waiting_hint(Some(format!("PROMPT: {:?} {:?}", msg, detail)));
+        self.prompts
+            .borrow_mut()
+            .multiple_choice
+            .push_back(TestPrompt {
+                msg: msg.to_string(),
+                detail: detail.map(|s| s.to_string()),
+                answers,
+                tx,
+            });
+        rx
+    }
+
+    pub(crate) fn set_active_window(&self, window: Option<TestWindow>) {
+        let executor = self.foreground_executor();
+        let previous_window = self.active_window.borrow_mut().take();
+        self.active_window.borrow_mut().clone_from(&window);
+
+        executor
+            .spawn(async move {
+                if let Some(previous_window) = previous_window {
+                    if let Some(window) = window.as_ref()
+                        && Rc::ptr_eq(&previous_window.0, &window.0)
+                    {
+                        return;
+                    }
+                    previous_window.simulate_active_status_change(false);
+                }
+                if let Some(window) = window {
+                    window.simulate_active_status_change(true);
+                }
+            })
+            .detach();
+    }
+
+    pub(crate) fn did_prompt_for_new_path(&self) -> bool {
+        !self.prompts.borrow().new_path.is_empty()
+    }
+}
+
+impl Platform for TestPlatform {
+    fn background_executor(&self) -> BackgroundExecutor {
+        self.background_executor.clone()
+    }
+
+    fn foreground_executor(&self) -> ForegroundExecutor {
+        self.foreground_executor.clone()
+    }
+
+    fn text_system(&self) -> Arc<dyn PlatformTextSystem> {
+        self.text_system.clone()
+    }
+
+    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
+        Box::new(TestKeyboardLayout)
+    }
+
+    fn keyboard_mapper(&self) -> Rc<dyn PlatformKeyboardMapper> {
+        Rc::new(DummyKeyboardMapper)
+    }
+
+    fn on_keyboard_layout_change(&self, _: Box<dyn FnMut()>) {}
+
+    fn run(&self, _on_finish_launching: Box<dyn FnOnce()>) {
+        unimplemented!()
+    }
+
+    fn quit(&self) {}
+
+    fn restart(&self, _: Option<PathBuf>) {
+        //
+    }
+
+    fn activate(&self, _ignoring_other_apps: bool) {
+        //
+    }
+
+    fn hide(&self) {
+        unimplemented!()
+    }
+
+    fn hide_other_apps(&self) {
+        unimplemented!()
+    }
+
+    fn unhide_other_apps(&self) {
+        unimplemented!()
+    }
+
+    fn displays(&self) -> Vec<std::rc::Rc<dyn crate::PlatformDisplay>> {
+        vec![self.active_display.clone()]
+    }
+
+    fn primary_display(&self) -> Option<std::rc::Rc<dyn crate::PlatformDisplay>> {
+        Some(self.active_display.clone())
+    }
+
+    #[cfg(feature = "screen-capture")]
+    fn is_screen_capture_supported(&self) -> bool {
+        true
+    }
+
+    #[cfg(feature = "screen-capture")]
+    fn screen_capture_sources(
+        &self,
+    ) -> oneshot::Receiver<Result<Vec<Rc<dyn ScreenCaptureSource>>>> {
+        let (mut tx, rx) = oneshot::channel();
+        tx.send(Ok(self
+            .screen_capture_sources
+            .borrow()
+            .iter()
+            .map(|source| Rc::new(source.clone()) as Rc<dyn ScreenCaptureSource>)
+            .collect()))
+            .ok();
+        rx
+    }
+
+    fn active_window(&self) -> Option<crate::AnyWindowHandle> {
+        self.active_window
+            .borrow()
+            .as_ref()
+            .map(|window| window.0.lock().handle)
+    }
+
+    fn open_window(
+        &self,
+        handle: AnyWindowHandle,
+        params: WindowParams,
+    ) -> anyhow::Result<Box<dyn crate::PlatformWindow>> {
+        let window = TestWindow::new(
+            handle,
+            params,
+            self.weak.clone(),
+            self.active_display.clone(),
+        );
+        Ok(Box::new(window))
+    }
+
+    fn window_appearance(&self) -> WindowAppearance {
+        WindowAppearance::Light
+    }
+
+    fn open_url(&self, url: &str) {
+        *self.opened_url.borrow_mut() = Some(url.to_string())
+    }
+
+    fn on_open_urls(&self, _callback: Box<dyn FnMut(Vec<String>)>) {
+        unimplemented!()
+    }
+
+    fn prompt_for_paths(
+        &self,
+        _options: crate::PathPromptOptions,
+    ) -> oneshot::Receiver<Result<Option<Vec<std::path::PathBuf>>>> {
+        unimplemented!()
+    }
+
+    fn prompt_for_new_path(
+        &self,
+        directory: &std::path::Path,
+        _suggested_name: Option<&str>,
+    ) -> oneshot::Receiver<Result<Option<std::path::PathBuf>>> {
+        let (tx, rx) = oneshot::channel();
+        self.background_executor()
+            .set_waiting_hint(Some(format!("PROMPT FOR PATH: {:?}", directory)));
+        self.prompts
+            .borrow_mut()
+            .new_path
+            .push_back((directory.to_path_buf(), tx));
+        rx
+    }
+
+    fn can_select_mixed_files_and_dirs(&self) -> bool {
+        true
+    }
+
+    fn reveal_path(&self, _path: &std::path::Path) {
+        unimplemented!()
+    }
+
+    fn on_quit(&self, _callback: Box<dyn FnMut()>) {}
+
+    fn on_reopen(&self, _callback: Box<dyn FnMut()>) {
+        unimplemented!()
+    }
+
+    fn set_menus(&self, _menus: Vec<crate::Menu>, _keymap: &Keymap) {}
+    fn set_dock_menu(&self, _menu: Vec<crate::MenuItem>, _keymap: &Keymap) {}
+
+    fn add_recent_document(&self, _paths: &Path) {}
+
+    fn on_app_menu_action(&self, _callback: Box<dyn FnMut(&dyn crate::Action)>) {}
+
+    fn on_will_open_app_menu(&self, _callback: Box<dyn FnMut()>) {}
+
+    fn on_validate_app_menu_command(&self, _callback: Box<dyn FnMut(&dyn crate::Action) -> bool>) {}
+
+    fn app_path(&self) -> Result<std::path::PathBuf> {
+        unimplemented!()
+    }
+
+    fn path_for_auxiliary_executable(&self, _name: &str) -> Result<std::path::PathBuf> {
+        unimplemented!()
+    }
+
+    fn set_cursor_style(&self, style: crate::CursorStyle) {
+        *self.active_cursor.lock() = style;
+    }
+
+    fn should_auto_hide_scrollbars(&self) -> bool {
+        false
+    }
+
+    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+    fn write_to_primary(&self, item: ClipboardItem) {
+        *self.current_primary_item.lock() = Some(item);
+    }
+
+    fn write_to_clipboard(&self, item: ClipboardItem) {
+        *self.current_clipboard_item.lock() = Some(item);
+    }
+
+    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+    fn read_from_primary(&self) -> Option<ClipboardItem> {
+        self.current_primary_item.lock().clone()
+    }
+
+    fn read_from_clipboard(&self) -> Option<ClipboardItem> {
+        self.current_clipboard_item.lock().clone()
+    }
+
+    fn write_credentials(&self, _url: &str, _username: &str, _password: &[u8]) -> Task<Result<()>> {
+        Task::ready(Ok(()))
+    }
+
+    fn read_credentials(&self, _url: &str) -> Task<Result<Option<(String, Vec<u8>)>>> {
+        Task::ready(Ok(None))
+    }
+
+    fn delete_credentials(&self, _url: &str) -> Task<Result<()>> {
+        Task::ready(Ok(()))
+    }
+
+    fn register_url_scheme(&self, _: &str) -> Task<anyhow::Result<()>> {
+        unimplemented!()
+    }
+
+    fn open_with_system(&self, _path: &Path) {
+        unimplemented!()
+    }
+}
+
+impl TestScreenCaptureSource {
+    /// Create a fake screen capture source, for testing.
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[cfg(target_os = "windows")]
+impl Drop for TestPlatform {
+    fn drop(&mut self) {
+        unsafe {
+            std::mem::ManuallyDrop::drop(&mut self.bitmap_factory);
+            windows::Win32::System::Ole::OleUninitialize();
+        }
+    }
+}
+
+struct TestKeyboardLayout;
+
+impl PlatformKeyboardLayout for TestKeyboardLayout {
+    fn id(&self) -> &str {
+        "zed.keyboard.example"
+    }
+
+    fn name(&self) -> &str {
+        "zed.keyboard.example"
+    }
+}

third_party/gpui/src/platform/test/window.rs

@@ -0,0 +1,362 @@
+use crate::{
+    AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DispatchEventResult, GpuSpecs,
+    Pixels, PlatformAtlas, PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow,
+    Point, PromptButton, RequestFrameOptions, Size, TestPlatform, TileId, WindowAppearance,
+    WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowParams,
+};
+use collections::HashMap;
+use parking_lot::Mutex;
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
+use std::{
+    rc::{Rc, Weak},
+    sync::{self, Arc},
+};
+
+pub(crate) struct TestWindowState {
+    pub(crate) bounds: Bounds<Pixels>,
+    pub(crate) handle: AnyWindowHandle,
+    display: Rc<dyn PlatformDisplay>,
+    pub(crate) title: Option<String>,
+    pub(crate) edited: bool,
+    platform: Weak<TestPlatform>,
+    sprite_atlas: Arc<dyn PlatformAtlas>,
+    pub(crate) should_close_handler: Option<Box<dyn FnMut() -> bool>>,
+    hit_test_window_control_callback: Option<Box<dyn FnMut() -> Option<WindowControlArea>>>,
+    input_callback: Option<Box<dyn FnMut(PlatformInput) -> DispatchEventResult>>,
+    active_status_change_callback: Option<Box<dyn FnMut(bool)>>,
+    hover_status_change_callback: Option<Box<dyn FnMut(bool)>>,
+    resize_callback: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,
+    moved_callback: Option<Box<dyn FnMut()>>,
+    input_handler: Option<PlatformInputHandler>,
+    is_fullscreen: bool,
+}
+
+#[derive(Clone)]
+pub(crate) struct TestWindow(pub(crate) Rc<Mutex<TestWindowState>>);
+
+impl HasWindowHandle for TestWindow {
+    fn window_handle(
+        &self,
+    ) -> Result<raw_window_handle::WindowHandle<'_>, raw_window_handle::HandleError> {
+        unimplemented!("Test Windows are not backed by a real platform window")
+    }
+}
+
+impl HasDisplayHandle for TestWindow {
+    fn display_handle(
+        &self,
+    ) -> Result<raw_window_handle::DisplayHandle<'_>, raw_window_handle::HandleError> {
+        unimplemented!("Test Windows are not backed by a real platform window")
+    }
+}
+
+impl TestWindow {
+    pub fn new(
+        handle: AnyWindowHandle,
+        params: WindowParams,
+        platform: Weak<TestPlatform>,
+        display: Rc<dyn PlatformDisplay>,
+    ) -> Self {
+        Self(Rc::new(Mutex::new(TestWindowState {
+            bounds: params.bounds,
+            display,
+            platform,
+            handle,
+            sprite_atlas: Arc::new(TestAtlas::new()),
+            title: Default::default(),
+            edited: false,
+            should_close_handler: None,
+            hit_test_window_control_callback: None,
+            input_callback: None,
+            active_status_change_callback: None,
+            hover_status_change_callback: None,
+            resize_callback: None,
+            moved_callback: None,
+            input_handler: None,
+            is_fullscreen: false,
+        })))
+    }
+
+    pub fn simulate_resize(&mut self, size: Size<Pixels>) {
+        let scale_factor = self.scale_factor();
+        let mut lock = self.0.lock();
+        let Some(mut callback) = lock.resize_callback.take() else {
+            return;
+        };
+        lock.bounds.size = size;
+        drop(lock);
+        callback(size, scale_factor);
+        self.0.lock().resize_callback = Some(callback);
+    }
+
+    pub(crate) fn simulate_active_status_change(&self, active: bool) {
+        let mut lock = self.0.lock();
+        let Some(mut callback) = lock.active_status_change_callback.take() else {
+            return;
+        };
+        drop(lock);
+        callback(active);
+        self.0.lock().active_status_change_callback = Some(callback);
+    }
+
+    pub fn simulate_input(&mut self, event: PlatformInput) -> bool {
+        let mut lock = self.0.lock();
+        let Some(mut callback) = lock.input_callback.take() else {
+            return false;
+        };
+        drop(lock);
+        let result = callback(event);
+        self.0.lock().input_callback = Some(callback);
+        !result.propagate
+    }
+}
+
+impl PlatformWindow for TestWindow {
+    fn bounds(&self) -> Bounds<Pixels> {
+        self.0.lock().bounds
+    }
+
+    fn window_bounds(&self) -> WindowBounds {
+        WindowBounds::Windowed(self.bounds())
+    }
+
+    fn is_maximized(&self) -> bool {
+        false
+    }
+
+    fn content_size(&self) -> Size<Pixels> {
+        self.bounds().size
+    }
+
+    fn resize(&mut self, size: Size<Pixels>) {
+        let mut lock = self.0.lock();
+        lock.bounds.size = size;
+    }
+
+    fn scale_factor(&self) -> f32 {
+        2.0
+    }
+
+    fn appearance(&self) -> WindowAppearance {
+        WindowAppearance::Light
+    }
+
+    fn display(&self) -> Option<std::rc::Rc<dyn crate::PlatformDisplay>> {
+        Some(self.0.lock().display.clone())
+    }
+
+    fn mouse_position(&self) -> Point<Pixels> {
+        Point::default()
+    }
+
+    fn modifiers(&self) -> crate::Modifiers {
+        crate::Modifiers::default()
+    }
+
+    fn capslock(&self) -> crate::Capslock {
+        crate::Capslock::default()
+    }
+
+    fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {
+        self.0.lock().input_handler = Some(input_handler);
+    }
+
+    fn take_input_handler(&mut self) -> Option<PlatformInputHandler> {
+        self.0.lock().input_handler.take()
+    }
+
+    fn prompt(
+        &self,
+        _level: crate::PromptLevel,
+        msg: &str,
+        detail: Option<&str>,
+        answers: &[PromptButton],
+    ) -> Option<futures::channel::oneshot::Receiver<usize>> {
+        Some(
+            self.0
+                .lock()
+                .platform
+                .upgrade()
+                .expect("platform dropped")
+                .prompt(msg, detail, answers),
+        )
+    }
+
+    fn activate(&self) {
+        self.0
+            .lock()
+            .platform
+            .upgrade()
+            .unwrap()
+            .set_active_window(Some(self.clone()))
+    }
+
+    fn is_active(&self) -> bool {
+        false
+    }
+
+    fn is_hovered(&self) -> bool {
+        false
+    }
+
+    fn set_title(&mut self, title: &str) {
+        self.0.lock().title = Some(title.to_owned());
+    }
+
+    fn set_app_id(&mut self, _app_id: &str) {}
+
+    fn set_background_appearance(&self, _background: WindowBackgroundAppearance) {}
+
+    fn set_edited(&mut self, edited: bool) {
+        self.0.lock().edited = edited;
+    }
+
+    fn show_character_palette(&self) {
+        unimplemented!()
+    }
+
+    fn minimize(&self) {
+        unimplemented!()
+    }
+
+    fn zoom(&self) {
+        unimplemented!()
+    }
+
+    fn toggle_fullscreen(&self) {
+        let mut lock = self.0.lock();
+        lock.is_fullscreen = !lock.is_fullscreen;
+    }
+
+    fn is_fullscreen(&self) -> bool {
+        self.0.lock().is_fullscreen
+    }
+
+    fn on_request_frame(&self, _callback: Box<dyn FnMut(RequestFrameOptions)>) {}
+
+    fn on_input(&self, callback: Box<dyn FnMut(crate::PlatformInput) -> DispatchEventResult>) {
+        self.0.lock().input_callback = Some(callback)
+    }
+
+    fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>) {
+        self.0.lock().active_status_change_callback = Some(callback)
+    }
+
+    fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>) {
+        self.0.lock().hover_status_change_callback = Some(callback)
+    }
+
+    fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {
+        self.0.lock().resize_callback = Some(callback)
+    }
+
+    fn on_moved(&self, callback: Box<dyn FnMut()>) {
+        self.0.lock().moved_callback = Some(callback)
+    }
+
+    fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>) {
+        self.0.lock().should_close_handler = Some(callback);
+    }
+
+    fn on_close(&self, _callback: Box<dyn FnOnce()>) {}
+
+    fn on_hit_test_window_control(&self, callback: Box<dyn FnMut() -> Option<WindowControlArea>>) {
+        self.0.lock().hit_test_window_control_callback = Some(callback);
+    }
+
+    fn on_appearance_changed(&self, _callback: Box<dyn FnMut()>) {}
+
+    fn draw(&self, _scene: &crate::Scene) {}
+
+    fn sprite_atlas(&self) -> sync::Arc<dyn crate::PlatformAtlas> {
+        self.0.lock().sprite_atlas.clone()
+    }
+
+    fn as_test(&mut self) -> Option<&mut TestWindow> {
+        Some(self)
+    }
+
+    #[cfg(target_os = "windows")]
+    fn get_raw_handle(&self) -> windows::Win32::Foundation::HWND {
+        unimplemented!()
+    }
+
+    fn show_window_menu(&self, _position: Point<Pixels>) {
+        unimplemented!()
+    }
+
+    fn start_window_move(&self) {
+        unimplemented!()
+    }
+
+    fn update_ime_position(&self, _bounds: Bounds<Pixels>) {}
+
+    fn gpu_specs(&self) -> Option<GpuSpecs> {
+        None
+    }
+}
+
+pub(crate) struct TestAtlasState {
+    next_id: u32,
+    tiles: HashMap<AtlasKey, AtlasTile>,
+}
+
+pub(crate) struct TestAtlas(Mutex<TestAtlasState>);
+
+impl TestAtlas {
+    pub fn new() -> Self {
+        TestAtlas(Mutex::new(TestAtlasState {
+            next_id: 0,
+            tiles: HashMap::default(),
+        }))
+    }
+}
+
+impl PlatformAtlas for TestAtlas {
+    fn get_or_insert_with<'a>(
+        &self,
+        key: &crate::AtlasKey,
+        build: &mut dyn FnMut() -> anyhow::Result<
+            Option<(Size<crate::DevicePixels>, std::borrow::Cow<'a, [u8]>)>,
+        >,
+    ) -> anyhow::Result<Option<crate::AtlasTile>> {
+        let mut state = self.0.lock();
+        if let Some(tile) = state.tiles.get(key) {
+            return Ok(Some(tile.clone()));
+        }
+        drop(state);
+
+        let Some((size, _)) = build()? else {
+            return Ok(None);
+        };
+
+        let mut state = self.0.lock();
+        state.next_id += 1;
+        let texture_id = state.next_id;
+        state.next_id += 1;
+        let tile_id = state.next_id;
+
+        state.tiles.insert(
+            key.clone(),
+            crate::AtlasTile {
+                texture_id: AtlasTextureId {
+                    index: texture_id,
+                    kind: crate::AtlasTextureKind::Monochrome,
+                },
+                tile_id: TileId(tile_id),
+                padding: 0,
+                bounds: crate::Bounds {
+                    origin: Point::default(),
+                    size,
+                },
+            },
+        );
+
+        Ok(Some(state.tiles[key].clone()))
+    }
+
+    fn remove(&self, key: &AtlasKey) {
+        let mut state = self.0.lock();
+        state.tiles.remove(key);
+    }
+}

third_party/gpui/src/platform/windows.rs

@@ -0,0 +1,40 @@
+mod clipboard;
+mod destination_list;
+mod direct_write;
+mod directx_atlas;
+mod directx_devices;
+mod directx_renderer;
+mod dispatcher;
+mod display;
+mod events;
+mod keyboard;
+mod platform;
+mod system_settings;
+mod util;
+mod vsync;
+mod window;
+mod wrapper;
+
+pub(crate) use clipboard::*;
+pub(crate) use destination_list::*;
+pub(crate) use direct_write::*;
+pub(crate) use directx_atlas::*;
+pub(crate) use directx_devices::*;
+pub(crate) use directx_renderer::*;
+pub(crate) use dispatcher::*;
+pub(crate) use display::*;
+pub(crate) use events::*;
+pub(crate) use keyboard::*;
+pub(crate) use platform::*;
+pub(crate) use system_settings::*;
+pub(crate) use util::*;
+pub(crate) use vsync::*;
+pub(crate) use window::*;
+pub(crate) use wrapper::*;
+
+pub(crate) use windows::Win32::Foundation::HWND;
+
+#[cfg(feature = "screen-capture")]
+pub(crate) type PlatformScreenCaptureFrame = scap::frame::Frame;
+#[cfg(not(feature = "screen-capture"))]
+pub(crate) type PlatformScreenCaptureFrame = ();

third_party/gpui/src/platform/windows/alpha_correction.hlsl

@@ -0,0 +1,28 @@
+float color_brightness(float3 color) {
+    // REC. 601 luminance coefficients for perceived brightness
+    return dot(color, float3(0.30f, 0.59f, 0.11f));
+}
+
+float light_on_dark_contrast(float enhancedContrast, float3 color) {
+    float brightness = color_brightness(color);
+    float multiplier = saturate(4.0f * (0.75f - brightness));
+    return enhancedContrast * multiplier;
+}
+
+float enhance_contrast(float alpha, float k) {
+    return alpha * (k + 1.0f) / (alpha * k + 1.0f);
+}
+
+float apply_alpha_correction(float a, float b, float4 g) {
+    float brightness_adjustment = g.x * b + g.y;
+    float correction = brightness_adjustment * a + (g.z * b + g.w);
+    return a + a * (1.0f - a) * correction;
+}
+
+float apply_contrast_and_gamma_correction(float sample, float3 color, float enhanced_contrast_factor, float4 gamma_ratios) {
+    float enhanced_contrast = light_on_dark_contrast(enhanced_contrast_factor, color);
+    float brightness = color_brightness(color);
+
+    float contrasted = enhance_contrast(sample, enhanced_contrast);
+    return apply_alpha_correction(contrasted, brightness, gamma_ratios);
+}

third_party/gpui/src/platform/windows/clipboard.rs

@@ -0,0 +1,388 @@
+use std::sync::LazyLock;
+
+use anyhow::Result;
+use collections::{FxHashMap, FxHashSet};
+use itertools::Itertools;
+use windows::Win32::{
+    Foundation::{HANDLE, HGLOBAL},
+    System::{
+        DataExchange::{
+            CloseClipboard, CountClipboardFormats, EmptyClipboard, EnumClipboardFormats,
+            GetClipboardData, GetClipboardFormatNameW, IsClipboardFormatAvailable, OpenClipboard,
+            RegisterClipboardFormatW, SetClipboardData,
+        },
+        Memory::{GMEM_MOVEABLE, GlobalAlloc, GlobalLock, GlobalSize, GlobalUnlock},
+        Ole::{CF_HDROP, CF_UNICODETEXT},
+    },
+    UI::Shell::{DragQueryFileW, HDROP},
+};
+use windows_core::PCWSTR;
+
+use crate::{ClipboardEntry, ClipboardItem, ClipboardString, Image, ImageFormat, hash};
+
+// https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-dragqueryfilew
+const DRAGDROP_GET_FILES_COUNT: u32 = 0xFFFFFFFF;
+
+// Clipboard formats
+static CLIPBOARD_HASH_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("GPUI internal text hash")));
+static CLIPBOARD_METADATA_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("GPUI internal metadata")));
+static CLIPBOARD_SVG_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("image/svg+xml")));
+static CLIPBOARD_GIF_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("GIF")));
+static CLIPBOARD_PNG_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("PNG")));
+static CLIPBOARD_JPG_FORMAT: LazyLock<u32> =
+    LazyLock::new(|| register_clipboard_format(windows::core::w!("JFIF")));
+
+// Helper maps and sets
+static FORMATS_MAP: LazyLock<FxHashMap<u32, ClipboardFormatType>> = LazyLock::new(|| {
+    let mut formats_map = FxHashMap::default();
+    formats_map.insert(CF_UNICODETEXT.0 as u32, ClipboardFormatType::Text);
+    formats_map.insert(*CLIPBOARD_PNG_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(*CLIPBOARD_GIF_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(*CLIPBOARD_JPG_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(*CLIPBOARD_SVG_FORMAT, ClipboardFormatType::Image);
+    formats_map.insert(CF_HDROP.0 as u32, ClipboardFormatType::Files);
+    formats_map
+});
+static FORMATS_SET: LazyLock<FxHashSet<u32>> = LazyLock::new(|| {
+    let mut formats_map = FxHashSet::default();
+    formats_map.insert(CF_UNICODETEXT.0 as u32);
+    formats_map.insert(*CLIPBOARD_PNG_FORMAT);
+    formats_map.insert(*CLIPBOARD_GIF_FORMAT);
+    formats_map.insert(*CLIPBOARD_JPG_FORMAT);
+    formats_map.insert(*CLIPBOARD_SVG_FORMAT);
+    formats_map.insert(CF_HDROP.0 as u32);
+    formats_map
+});
+static IMAGE_FORMATS_MAP: LazyLock<FxHashMap<u32, ImageFormat>> = LazyLock::new(|| {
+    let mut formats_map = FxHashMap::default();
+    formats_map.insert(*CLIPBOARD_PNG_FORMAT, ImageFormat::Png);
+    formats_map.insert(*CLIPBOARD_GIF_FORMAT, ImageFormat::Gif);
+    formats_map.insert(*CLIPBOARD_JPG_FORMAT, ImageFormat::Jpeg);
+    formats_map.insert(*CLIPBOARD_SVG_FORMAT, ImageFormat::Svg);
+    formats_map
+});
+
+#[derive(Debug, Clone, Copy)]
+enum ClipboardFormatType {
+    Text,
+    Image,
+    Files,
+}
+
+pub(crate) fn write_to_clipboard(item: ClipboardItem) {
+    with_clipboard(|| write_to_clipboard_inner(item));
+}
+
+pub(crate) fn read_from_clipboard() -> Option<ClipboardItem> {
+    with_clipboard(|| {
+        with_best_match_format(|item_format| match format_to_type(item_format) {
+            ClipboardFormatType::Text => read_string_from_clipboard(),
+            ClipboardFormatType::Image => read_image_from_clipboard(item_format),
+            ClipboardFormatType::Files => read_files_from_clipboard(),
+        })
+    })
+    .flatten()
+}
+
+pub(crate) fn with_file_names<F>(hdrop: HDROP, mut f: F)
+where
+    F: FnMut(String),
+{
+    let file_count = unsafe { DragQueryFileW(hdrop, DRAGDROP_GET_FILES_COUNT, None) };
+    for file_index in 0..file_count {
+        let filename_length = unsafe { DragQueryFileW(hdrop, file_index, None) } as usize;
+        let mut buffer = vec![0u16; filename_length + 1];
+        let ret = unsafe { DragQueryFileW(hdrop, file_index, Some(buffer.as_mut_slice())) };
+        if ret == 0 {
+            log::error!("unable to read file name of dragged file");
+            continue;
+        }
+        match String::from_utf16(&buffer[0..filename_length]) {
+            Ok(file_name) => f(file_name),
+            Err(e) => {
+                log::error!("dragged file name is not UTF-16: {}", e)
+            }
+        }
+    }
+}
+
+fn with_clipboard<F, T>(f: F) -> Option<T>
+where
+    F: FnOnce() -> T,
+{
+    match unsafe { OpenClipboard(None) } {
+        Ok(()) => {
+            let result = f();
+            if let Err(e) = unsafe { CloseClipboard() } {
+                log::error!("Failed to close clipboard: {e}",);
+            }
+            Some(result)
+        }
+        Err(e) => {
+            log::error!("Failed to open clipboard: {e}",);
+            None
+        }
+    }
+}
+
+fn register_clipboard_format(format: PCWSTR) -> u32 {
+    let ret = unsafe { RegisterClipboardFormatW(format) };
+    if ret == 0 {
+        panic!(
+            "Error when registering clipboard format: {}",
+            std::io::Error::last_os_error()
+        );
+    }
+    ret
+}
+
+#[inline]
+fn format_to_type(item_format: u32) -> &'static ClipboardFormatType {
+    FORMATS_MAP.get(&item_format).unwrap()
+}
+
+// Currently, we only write the first item.
+fn write_to_clipboard_inner(item: ClipboardItem) -> Result<()> {
+    unsafe {
+        EmptyClipboard()?;
+    }
+    match item.entries().first() {
+        Some(entry) => match entry {
+            ClipboardEntry::String(string) => {
+                write_string_to_clipboard(string)?;
+            }
+            ClipboardEntry::Image(image) => {
+                write_image_to_clipboard(image)?;
+            }
+        },
+        None => {
+            // Writing an empty list of entries just clears the clipboard.
+        }
+    }
+    Ok(())
+}
+
+fn write_string_to_clipboard(item: &ClipboardString) -> Result<()> {
+    let encode_wide = item.text.encode_utf16().chain(Some(0)).collect_vec();
+    set_data_to_clipboard(&encode_wide, CF_UNICODETEXT.0 as u32)?;
+
+    if let Some(metadata) = item.metadata.as_ref() {
+        let hash_result = {
+            let hash = ClipboardString::text_hash(&item.text);
+            hash.to_ne_bytes()
+        };
+        let encode_wide =
+            unsafe { std::slice::from_raw_parts(hash_result.as_ptr().cast::<u16>(), 4) };
+        set_data_to_clipboard(encode_wide, *CLIPBOARD_HASH_FORMAT)?;
+
+        let metadata_wide = metadata.encode_utf16().chain(Some(0)).collect_vec();
+        set_data_to_clipboard(&metadata_wide, *CLIPBOARD_METADATA_FORMAT)?;
+    }
+    Ok(())
+}
+
+fn set_data_to_clipboard<T>(data: &[T], format: u32) -> Result<()> {
+    unsafe {
+        let global = GlobalAlloc(GMEM_MOVEABLE, std::mem::size_of_val(data))?;
+        let handle = GlobalLock(global);
+        std::ptr::copy_nonoverlapping(data.as_ptr(), handle as _, data.len());
+        let _ = GlobalUnlock(global);
+        SetClipboardData(format, Some(HANDLE(global.0)))?;
+    }
+    Ok(())
+}
+
+// Here writing PNG to the clipboard to better support other apps. For more info, please ref to
+// the PR.
+fn write_image_to_clipboard(item: &Image) -> Result<()> {
+    match item.format {
+        ImageFormat::Svg => set_data_to_clipboard(item.bytes(), *CLIPBOARD_SVG_FORMAT)?,
+        ImageFormat::Gif => {
+            set_data_to_clipboard(item.bytes(), *CLIPBOARD_GIF_FORMAT)?;
+            let png_bytes = convert_image_to_png_format(item.bytes(), ImageFormat::Gif)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+        ImageFormat::Png => {
+            set_data_to_clipboard(item.bytes(), *CLIPBOARD_PNG_FORMAT)?;
+            let png_bytes = convert_image_to_png_format(item.bytes(), ImageFormat::Png)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+        ImageFormat::Jpeg => {
+            set_data_to_clipboard(item.bytes(), *CLIPBOARD_JPG_FORMAT)?;
+            let png_bytes = convert_image_to_png_format(item.bytes(), ImageFormat::Jpeg)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+        other => {
+            log::warn!(
+                "Clipboard unsupported image format: {:?}, convert to PNG instead.",
+                item.format
+            );
+            let png_bytes = convert_image_to_png_format(item.bytes(), other)?;
+            set_data_to_clipboard(&png_bytes, *CLIPBOARD_PNG_FORMAT)?;
+        }
+    }
+    Ok(())
+}
+
+fn convert_image_to_png_format(bytes: &[u8], image_format: ImageFormat) -> Result<Vec<u8>> {
+    let image = image::load_from_memory_with_format(bytes, image_format.into())?;
+    let mut output_buf = Vec::new();
+    image.write_to(
+        &mut std::io::Cursor::new(&mut output_buf),
+        image::ImageFormat::Png,
+    )?;
+    Ok(output_buf)
+}
+
+// Here, we enumerate all formats on the clipboard and find the first one that we can process.
+// The reason we don't use `GetPriorityClipboardFormat` is that it sometimes returns the
+// wrong format.
+// For instance, when copying a JPEG image from  Microsoft Word, there may be several formats
+// on the clipboard: Jpeg, Png, Svg.
+// If we use `GetPriorityClipboardFormat`, it will return Svg, which is not what we want.
+fn with_best_match_format<F>(f: F) -> Option<ClipboardItem>
+where
+    F: Fn(u32) -> Option<ClipboardEntry>,
+{
+    let count = unsafe { CountClipboardFormats() };
+    let mut clipboard_format = 0;
+    for _ in 0..count {
+        clipboard_format = unsafe { EnumClipboardFormats(clipboard_format) };
+        let Some(item_format) = FORMATS_SET.get(&clipboard_format) else {
+            continue;
+        };
+        if let Some(entry) = f(*item_format) {
+            return Some(ClipboardItem {
+                entries: vec![entry],
+            });
+        }
+    }
+    // log the formats that we don't support yet.
+    {
+        clipboard_format = 0;
+        for _ in 0..count {
+            clipboard_format = unsafe { EnumClipboardFormats(clipboard_format) };
+            let mut buffer = [0u16; 64];
+            unsafe { GetClipboardFormatNameW(clipboard_format, &mut buffer) };
+            let format_name = String::from_utf16_lossy(&buffer);
+            log::warn!(
+                "Try to paste with unsupported clipboard format: {}, {}.",
+                clipboard_format,
+                format_name
+            );
+        }
+    }
+    None
+}
+
+fn read_string_from_clipboard() -> Option<ClipboardEntry> {
+    let text = with_clipboard_data(CF_UNICODETEXT.0 as u32, |data_ptr, _| {
+        let pcwstr = PCWSTR(data_ptr as *const u16);
+        String::from_utf16_lossy(unsafe { pcwstr.as_wide() })
+    })?;
+    let Some(hash) = read_hash_from_clipboard() else {
+        return Some(ClipboardEntry::String(ClipboardString::new(text)));
+    };
+    let Some(metadata) = read_metadata_from_clipboard() else {
+        return Some(ClipboardEntry::String(ClipboardString::new(text)));
+    };
+    if hash == ClipboardString::text_hash(&text) {
+        Some(ClipboardEntry::String(ClipboardString {
+            text,
+            metadata: Some(metadata),
+        }))
+    } else {
+        Some(ClipboardEntry::String(ClipboardString::new(text)))
+    }
+}
+
+fn read_hash_from_clipboard() -> Option<u64> {
+    if unsafe { IsClipboardFormatAvailable(*CLIPBOARD_HASH_FORMAT).is_err() } {
+        return None;
+    }
+    with_clipboard_data(*CLIPBOARD_HASH_FORMAT, |data_ptr, size| {
+        if size < 8 {
+            return None;
+        }
+        let hash_bytes: [u8; 8] = unsafe {
+            std::slice::from_raw_parts(data_ptr.cast::<u8>(), 8)
+                .try_into()
+                .ok()
+        }?;
+        Some(u64::from_ne_bytes(hash_bytes))
+    })?
+}
+
+fn read_metadata_from_clipboard() -> Option<String> {
+    unsafe { IsClipboardFormatAvailable(*CLIPBOARD_METADATA_FORMAT).ok()? };
+    with_clipboard_data(*CLIPBOARD_METADATA_FORMAT, |data_ptr, _size| {
+        let pcwstr = PCWSTR(data_ptr as *const u16);
+        String::from_utf16_lossy(unsafe { pcwstr.as_wide() })
+    })
+}
+
+fn read_image_from_clipboard(format: u32) -> Option<ClipboardEntry> {
+    let image_format = format_number_to_image_format(format)?;
+    read_image_for_type(format, *image_format)
+}
+
+#[inline]
+fn format_number_to_image_format(format_number: u32) -> Option<&'static ImageFormat> {
+    IMAGE_FORMATS_MAP.get(&format_number)
+}
+
+fn read_image_for_type(format_number: u32, format: ImageFormat) -> Option<ClipboardEntry> {
+    let (bytes, id) = with_clipboard_data(format_number, |data_ptr, size| {
+        let bytes = unsafe { std::slice::from_raw_parts(data_ptr as *mut u8 as _, size).to_vec() };
+        let id = hash(&bytes);
+        (bytes, id)
+    })?;
+    Some(ClipboardEntry::Image(Image { format, bytes, id }))
+}
+
+fn read_files_from_clipboard() -> Option<ClipboardEntry> {
+    let text = with_clipboard_data(CF_HDROP.0 as u32, |data_ptr, _size| {
+        let hdrop = HDROP(data_ptr);
+        let mut filenames = String::new();
+        with_file_names(hdrop, |file_name| {
+            filenames.push_str(&file_name);
+        });
+        filenames
+    })?;
+    Some(ClipboardEntry::String(ClipboardString {
+        text,
+        metadata: None,
+    }))
+}
+
+fn with_clipboard_data<F, R>(format: u32, f: F) -> Option<R>
+where
+    F: FnOnce(*mut std::ffi::c_void, usize) -> R,
+{
+    let global = HGLOBAL(unsafe { GetClipboardData(format).ok() }?.0);
+    let size = unsafe { GlobalSize(global) };
+    let data_ptr = unsafe { GlobalLock(global) };
+    let result = f(data_ptr, size);
+    unsafe { GlobalUnlock(global).ok() };
+    Some(result)
+}
+
+impl From<ImageFormat> for image::ImageFormat {
+    fn from(value: ImageFormat) -> Self {
+        match value {
+            ImageFormat::Png => image::ImageFormat::Png,
+            ImageFormat::Jpeg => image::ImageFormat::Jpeg,
+            ImageFormat::Webp => image::ImageFormat::WebP,
+            ImageFormat::Gif => image::ImageFormat::Gif,
+            // TODO: ImageFormat::Svg
+            ImageFormat::Bmp => image::ImageFormat::Bmp,
+            ImageFormat::Tiff => image::ImageFormat::Tiff,
+            _ => unreachable!(),
+        }
+    }
+}

third_party/gpui/src/platform/windows/color_text_raster.hlsl

@@ -0,0 +1,44 @@
+#include "alpha_correction.hlsl"
+
+struct RasterVertexOutput {
+    float4 position : SV_Position;
+    float2 texcoord : TEXCOORD0;
+};
+
+RasterVertexOutput emoji_rasterization_vertex(uint vertexID : SV_VERTEXID)
+{
+    RasterVertexOutput output;
+    output.texcoord = float2((vertexID << 1) & 2, vertexID & 2);
+    output.position = float4(output.texcoord * 2.0f - 1.0f, 0.0f, 1.0f);
+    output.position.y = -output.position.y;
+
+    return output;
+}
+
+struct PixelInput {
+    float4 position: SV_Position;
+    float2 texcoord : TEXCOORD0;
+};
+
+struct Bounds {
+    int2 origin;
+    int2 size;
+};
+
+Texture2D<float> t_layer : register(t0);
+SamplerState s_layer : register(s0);
+
+cbuffer GlyphLayerTextureParams : register(b0) {
+    Bounds bounds;
+    float4 run_color;
+    float4 gamma_ratios;
+    float grayscale_enhanced_contrast;
+    float3 _pad;
+};
+
+float4 emoji_rasterization_fragment(PixelInput input): SV_Target {
+    float sample = t_layer.Sample(s_layer, input.texcoord.xy).r;
+    float alpha_corrected = apply_contrast_and_gamma_correction(sample, run_color.rgb, grayscale_enhanced_contrast, gamma_ratios);
+    float alpha = alpha_corrected * run_color.a;
+    return float4(run_color.rgb * alpha, alpha);
+}

third_party/gpui/src/platform/windows/destination_list.rs

@@ -0,0 +1,201 @@
+use std::path::PathBuf;
+
+use itertools::Itertools;
+use smallvec::SmallVec;
+use windows::{
+    Win32::{
+        Foundation::PROPERTYKEY,
+        Globalization::u_strlen,
+        System::Com::{CLSCTX_INPROC_SERVER, CoCreateInstance, StructuredStorage::PROPVARIANT},
+        UI::{
+            Controls::INFOTIPSIZE,
+            Shell::{
+                Common::{IObjectArray, IObjectCollection},
+                DestinationList, EnumerableObjectCollection, ICustomDestinationList, IShellLinkW,
+                PropertiesSystem::IPropertyStore,
+                ShellLink,
+            },
+        },
+    },
+    core::{GUID, HSTRING, Interface},
+};
+
+use crate::{Action, MenuItem};
+
+pub(crate) struct JumpList {
+    pub(crate) dock_menus: Vec<DockMenuItem>,
+    pub(crate) recent_workspaces: Vec<SmallVec<[PathBuf; 2]>>,
+}
+
+impl JumpList {
+    pub(crate) fn new() -> Self {
+        Self {
+            dock_menus: Vec::new(),
+            recent_workspaces: Vec::new(),
+        }
+    }
+}
+
+pub(crate) struct DockMenuItem {
+    pub(crate) name: String,
+    pub(crate) description: String,
+    pub(crate) action: Box<dyn Action>,
+}
+
+impl DockMenuItem {
+    pub(crate) fn new(item: MenuItem) -> anyhow::Result<Self> {
+        match item {
+            MenuItem::Action { name, action, .. } => Ok(Self {
+                name: name.clone().into(),
+                description: if name == "New Window" {
+                    "Opens a new window".to_string()
+                } else {
+                    name.into()
+                },
+                action,
+            }),
+            _ => anyhow::bail!("Only `MenuItem::Action` is supported for dock menu on Windows."),
+        }
+    }
+}
+
+// This code is based on the example from Microsoft:
+// https://github.com/microsoft/Windows-classic-samples/blob/main/Samples/Win7Samples/winui/shell/appshellintegration/RecipePropertyHandler/RecipePropertyHandler.cpp
+pub(crate) fn update_jump_list(
+    jump_list: &JumpList,
+) -> anyhow::Result<Vec<SmallVec<[PathBuf; 2]>>> {
+    let (list, removed) = create_destination_list()?;
+    add_recent_folders(&list, &jump_list.recent_workspaces, removed.as_ref())?;
+    add_dock_menu(&list, &jump_list.dock_menus)?;
+    unsafe { list.CommitList() }?;
+    Ok(removed)
+}
+
+// Copied from:
+// https://github.com/microsoft/windows-rs/blob/0fc3c2e5a13d4316d242bdeb0a52af611eba8bd4/crates/libs/windows/src/Windows/Win32/Storage/EnhancedStorage/mod.rs#L1881
+const PKEY_TITLE: PROPERTYKEY = PROPERTYKEY {
+    fmtid: GUID::from_u128(0xf29f85e0_4ff9_1068_ab91_08002b27b3d9),
+    pid: 2,
+};
+
+fn create_destination_list() -> anyhow::Result<(ICustomDestinationList, Vec<SmallVec<[PathBuf; 2]>>)>
+{
+    let list: ICustomDestinationList =
+        unsafe { CoCreateInstance(&DestinationList, None, CLSCTX_INPROC_SERVER) }?;
+
+    let mut slots = 0;
+    let user_removed: IObjectArray = unsafe { list.BeginList(&mut slots) }?;
+
+    let count = unsafe { user_removed.GetCount() }?;
+    if count == 0 {
+        return Ok((list, Vec::new()));
+    }
+
+    let mut removed = Vec::with_capacity(count as usize);
+    for i in 0..count {
+        let shell_link: IShellLinkW = unsafe { user_removed.GetAt(i)? };
+        let description = {
+            // INFOTIPSIZE is the maximum size of the buffer
+            // see https://learn.microsoft.com/en-us/windows/win32/api/shobjidl_core/nf-shobjidl_core-ishelllinkw-getdescription
+            let mut buffer = [0u16; INFOTIPSIZE as usize];
+            unsafe { shell_link.GetDescription(&mut buffer)? };
+            let len = unsafe { u_strlen(buffer.as_ptr()) };
+            String::from_utf16_lossy(&buffer[..len as usize])
+        };
+        let args = description.split('\n').map(PathBuf::from).collect();
+
+        removed.push(args);
+    }
+
+    Ok((list, removed))
+}
+
+fn add_dock_menu(list: &ICustomDestinationList, dock_menus: &[DockMenuItem]) -> anyhow::Result<()> {
+    unsafe {
+        let tasks: IObjectCollection =
+            CoCreateInstance(&EnumerableObjectCollection, None, CLSCTX_INPROC_SERVER)?;
+        for (idx, dock_menu) in dock_menus.iter().enumerate() {
+            let argument = HSTRING::from(format!("--dock-action {}", idx));
+            let description = HSTRING::from(dock_menu.description.as_str());
+            let display = dock_menu.name.as_str();
+            let task = create_shell_link(argument, description, None, display)?;
+            tasks.AddObject(&task)?;
+        }
+        list.AddUserTasks(&tasks)?;
+        Ok(())
+    }
+}
+
+fn add_recent_folders(
+    list: &ICustomDestinationList,
+    entries: &[SmallVec<[PathBuf; 2]>],
+    removed: &Vec<SmallVec<[PathBuf; 2]>>,
+) -> anyhow::Result<()> {
+    unsafe {
+        let tasks: IObjectCollection =
+            CoCreateInstance(&EnumerableObjectCollection, None, CLSCTX_INPROC_SERVER)?;
+
+        for folder_path in entries.iter().filter(|path| !removed.contains(path)) {
+            let argument = HSTRING::from(
+                folder_path
+                    .iter()
+                    .map(|path| format!("\"{}\"", path.display()))
+                    .join(" "),
+            );
+
+            let description = HSTRING::from(
+                folder_path
+                    .iter()
+                    .map(|path| path.to_string_lossy())
+                    .collect::<Vec<_>>()
+                    .join("\n"),
+            );
+            // simulate folder icon
+            // https://github.com/microsoft/vscode/blob/7a5dc239516a8953105da34f84bae152421a8886/src/vs/platform/workspaces/electron-main/workspacesHistoryMainService.ts#L380
+            let icon = HSTRING::from("explorer.exe");
+
+            let display = folder_path
+                .iter()
+                .map(|p| {
+                    p.file_name()
+                        .map(|name| name.to_string_lossy())
+                        .unwrap_or_else(|| p.to_string_lossy())
+                })
+                .join(", ");
+
+            tasks.AddObject(&create_shell_link(
+                argument,
+                description,
+                Some(icon),
+                &display,
+            )?)?;
+        }
+
+        list.AppendCategory(&HSTRING::from("Recent Folders"), &tasks)?;
+        Ok(())
+    }
+}
+
+fn create_shell_link(
+    argument: HSTRING,
+    description: HSTRING,
+    icon: Option<HSTRING>,
+    display: &str,
+) -> anyhow::Result<IShellLinkW> {
+    unsafe {
+        let link: IShellLinkW = CoCreateInstance(&ShellLink, None, CLSCTX_INPROC_SERVER)?;
+        let exe_path = HSTRING::from(std::env::current_exe()?.as_os_str());
+        link.SetPath(&exe_path)?;
+        link.SetArguments(&argument)?;
+        link.SetDescription(&description)?;
+        if let Some(icon) = icon {
+            link.SetIconLocation(&icon, 0)?;
+        }
+        let store: IPropertyStore = link.cast()?;
+        let title = PROPVARIANT::from(display);
+        store.SetValue(&PKEY_TITLE, &title)?;
+        store.Commit()?;
+
+        Ok(link)
+    }
+}

third_party/gpui/src/platform/windows/directx_atlas.rs

@@ -0,0 +1,308 @@
+use collections::FxHashMap;
+use etagere::BucketedAtlasAllocator;
+use parking_lot::Mutex;
+use windows::Win32::Graphics::{
+    Direct3D11::{
+        D3D11_BIND_SHADER_RESOURCE, D3D11_BOX, D3D11_TEXTURE2D_DESC, D3D11_USAGE_DEFAULT,
+        ID3D11Device, ID3D11DeviceContext, ID3D11ShaderResourceView, ID3D11Texture2D,
+    },
+    Dxgi::Common::*,
+};
+
+use crate::{
+    AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTile, Bounds, DevicePixels, PlatformAtlas,
+    Point, Size, platform::AtlasTextureList,
+};
+
+pub(crate) struct DirectXAtlas(Mutex<DirectXAtlasState>);
+
+struct DirectXAtlasState {
+    device: ID3D11Device,
+    device_context: ID3D11DeviceContext,
+    monochrome_textures: AtlasTextureList<DirectXAtlasTexture>,
+    polychrome_textures: AtlasTextureList<DirectXAtlasTexture>,
+    tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
+}
+
+struct DirectXAtlasTexture {
+    id: AtlasTextureId,
+    bytes_per_pixel: u32,
+    allocator: BucketedAtlasAllocator,
+    texture: ID3D11Texture2D,
+    view: [Option<ID3D11ShaderResourceView>; 1],
+    live_atlas_keys: u32,
+}
+
+impl DirectXAtlas {
+    pub(crate) fn new(device: &ID3D11Device, device_context: &ID3D11DeviceContext) -> Self {
+        DirectXAtlas(Mutex::new(DirectXAtlasState {
+            device: device.clone(),
+            device_context: device_context.clone(),
+            monochrome_textures: Default::default(),
+            polychrome_textures: Default::default(),
+            tiles_by_key: Default::default(),
+        }))
+    }
+
+    pub(crate) fn get_texture_view(
+        &self,
+        id: AtlasTextureId,
+    ) -> [Option<ID3D11ShaderResourceView>; 1] {
+        let lock = self.0.lock();
+        let tex = lock.texture(id);
+        tex.view.clone()
+    }
+
+    pub(crate) fn handle_device_lost(
+        &self,
+        device: &ID3D11Device,
+        device_context: &ID3D11DeviceContext,
+    ) {
+        let mut lock = self.0.lock();
+        lock.device = device.clone();
+        lock.device_context = device_context.clone();
+        lock.monochrome_textures = AtlasTextureList::default();
+        lock.polychrome_textures = AtlasTextureList::default();
+        lock.tiles_by_key.clear();
+    }
+}
+
+impl PlatformAtlas for DirectXAtlas {
+    fn get_or_insert_with<'a>(
+        &self,
+        key: &AtlasKey,
+        build: &mut dyn FnMut() -> anyhow::Result<
+            Option<(Size<DevicePixels>, std::borrow::Cow<'a, [u8]>)>,
+        >,
+    ) -> anyhow::Result<Option<AtlasTile>> {
+        let mut lock = self.0.lock();
+        if let Some(tile) = lock.tiles_by_key.get(key) {
+            Ok(Some(tile.clone()))
+        } else {
+            let Some((size, bytes)) = build()? else {
+                return Ok(None);
+            };
+            let tile = lock
+                .allocate(size, key.texture_kind())
+                .ok_or_else(|| anyhow::anyhow!("failed to allocate"))?;
+            let texture = lock.texture(tile.texture_id);
+            texture.upload(&lock.device_context, tile.bounds, &bytes);
+            lock.tiles_by_key.insert(key.clone(), tile.clone());
+            Ok(Some(tile))
+        }
+    }
+
+    fn remove(&self, key: &AtlasKey) {
+        let mut lock = self.0.lock();
+
+        let Some(id) = lock.tiles_by_key.remove(key).map(|tile| tile.texture_id) else {
+            return;
+        };
+
+        let textures = match id.kind {
+            AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,
+            AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,
+        };
+
+        let Some(texture_slot) = textures.textures.get_mut(id.index as usize) else {
+            return;
+        };
+
+        if let Some(mut texture) = texture_slot.take() {
+            texture.decrement_ref_count();
+            if texture.is_unreferenced() {
+                textures.free_list.push(texture.id.index as usize);
+                lock.tiles_by_key.remove(key);
+            } else {
+                *texture_slot = Some(texture);
+            }
+        }
+    }
+}
+
+impl DirectXAtlasState {
+    fn allocate(
+        &mut self,
+        size: Size<DevicePixels>,
+        texture_kind: AtlasTextureKind,
+    ) -> Option<AtlasTile> {
+        {
+            let textures = match texture_kind {
+                AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
+                AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+            };
+
+            if let Some(tile) = textures
+                .iter_mut()
+                .rev()
+                .find_map(|texture| texture.allocate(size))
+            {
+                return Some(tile);
+            }
+        }
+
+        let texture = self.push_texture(size, texture_kind)?;
+        texture.allocate(size)
+    }
+
+    fn push_texture(
+        &mut self,
+        min_size: Size<DevicePixels>,
+        kind: AtlasTextureKind,
+    ) -> Option<&mut DirectXAtlasTexture> {
+        const DEFAULT_ATLAS_SIZE: Size<DevicePixels> = Size {
+            width: DevicePixels(1024),
+            height: DevicePixels(1024),
+        };
+        // Max texture size for DirectX. See:
+        // https://learn.microsoft.com/en-us/windows/win32/direct3d11/overviews-direct3d-11-resources-limits
+        const MAX_ATLAS_SIZE: Size<DevicePixels> = Size {
+            width: DevicePixels(16384),
+            height: DevicePixels(16384),
+        };
+        let size = min_size.min(&MAX_ATLAS_SIZE).max(&DEFAULT_ATLAS_SIZE);
+        let pixel_format;
+        let bind_flag;
+        let bytes_per_pixel;
+        match kind {
+            AtlasTextureKind::Monochrome => {
+                pixel_format = DXGI_FORMAT_R8_UNORM;
+                bind_flag = D3D11_BIND_SHADER_RESOURCE;
+                bytes_per_pixel = 1;
+            }
+            AtlasTextureKind::Polychrome => {
+                pixel_format = DXGI_FORMAT_B8G8R8A8_UNORM;
+                bind_flag = D3D11_BIND_SHADER_RESOURCE;
+                bytes_per_pixel = 4;
+            }
+        }
+        let texture_desc = D3D11_TEXTURE2D_DESC {
+            Width: size.width.0 as u32,
+            Height: size.height.0 as u32,
+            MipLevels: 1,
+            ArraySize: 1,
+            Format: pixel_format,
+            SampleDesc: DXGI_SAMPLE_DESC {
+                Count: 1,
+                Quality: 0,
+            },
+            Usage: D3D11_USAGE_DEFAULT,
+            BindFlags: bind_flag.0 as u32,
+            CPUAccessFlags: 0,
+            MiscFlags: 0,
+        };
+        let mut texture: Option<ID3D11Texture2D> = None;
+        unsafe {
+            // This only returns None if the device is lost, which we will recreate later.
+            // So it's ok to return None here.
+            self.device
+                .CreateTexture2D(&texture_desc, None, Some(&mut texture))
+                .ok()?;
+        }
+        let texture = texture.unwrap();
+
+        let texture_list = match kind {
+            AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
+            AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
+        };
+        let index = texture_list.free_list.pop();
+        let view = unsafe {
+            let mut view = None;
+            self.device
+                .CreateShaderResourceView(&texture, None, Some(&mut view))
+                .ok()?;
+            [view]
+        };
+        let atlas_texture = DirectXAtlasTexture {
+            id: AtlasTextureId {
+                index: index.unwrap_or(texture_list.textures.len()) as u32,
+                kind,
+            },
+            bytes_per_pixel,
+            allocator: etagere::BucketedAtlasAllocator::new(size.into()),
+            texture,
+            view,
+            live_atlas_keys: 0,
+        };
+        if let Some(ix) = index {
+            texture_list.textures[ix] = Some(atlas_texture);
+            texture_list.textures.get_mut(ix).unwrap().as_mut()
+        } else {
+            texture_list.textures.push(Some(atlas_texture));
+            texture_list.textures.last_mut().unwrap().as_mut()
+        }
+    }
+
+    fn texture(&self, id: AtlasTextureId) -> &DirectXAtlasTexture {
+        let textures = match id.kind {
+            crate::AtlasTextureKind::Monochrome => &self.monochrome_textures,
+            crate::AtlasTextureKind::Polychrome => &self.polychrome_textures,
+        };
+        textures[id.index as usize].as_ref().unwrap()
+    }
+}
+
+impl DirectXAtlasTexture {
+    fn allocate(&mut self, size: Size<DevicePixels>) -> Option<AtlasTile> {
+        let allocation = self.allocator.allocate(size.into())?;
+        let tile = AtlasTile {
+            texture_id: self.id,
+            tile_id: allocation.id.into(),
+            bounds: Bounds {
+                origin: allocation.rectangle.min.into(),
+                size,
+            },
+            padding: 0,
+        };
+        self.live_atlas_keys += 1;
+        Some(tile)
+    }
+
+    fn upload(
+        &self,
+        device_context: &ID3D11DeviceContext,
+        bounds: Bounds<DevicePixels>,
+        bytes: &[u8],
+    ) {
+        unsafe {
+            device_context.UpdateSubresource(
+                &self.texture,
+                0,
+                Some(&D3D11_BOX {
+                    left: bounds.left().0 as u32,
+                    top: bounds.top().0 as u32,
+                    front: 0,
+                    right: bounds.right().0 as u32,
+                    bottom: bounds.bottom().0 as u32,
+                    back: 1,
+                }),
+                bytes.as_ptr() as _,
+                bounds.size.width.to_bytes(self.bytes_per_pixel as u8),
+                0,
+            );
+        }
+    }
+
+    fn decrement_ref_count(&mut self) {
+        self.live_atlas_keys -= 1;
+    }
+
+    fn is_unreferenced(&mut self) -> bool {
+        self.live_atlas_keys == 0
+    }
+}
+
+impl From<Size<DevicePixels>> for etagere::Size {
+    fn from(size: Size<DevicePixels>) -> Self {
+        etagere::Size::new(size.width.into(), size.height.into())
+    }
+}
+
+impl From<etagere::Point> for Point<DevicePixels> {
+    fn from(value: etagere::Point) -> Self {
+        Point {
+            x: DevicePixels::from(value.x),
+            y: DevicePixels::from(value.y),
+        }
+    }
+}

third_party/gpui/src/platform/windows/directx_devices.rs

@@ -0,0 +1,197 @@
+use anyhow::{Context, Result};
+use util::ResultExt;
+use windows::Win32::{
+    Foundation::HMODULE,
+    Graphics::{
+        Direct3D::{
+            D3D_DRIVER_TYPE_UNKNOWN, D3D_FEATURE_LEVEL, D3D_FEATURE_LEVEL_10_1,
+            D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_11_1,
+        },
+        Direct3D11::{
+            D3D11_CREATE_DEVICE_BGRA_SUPPORT, D3D11_CREATE_DEVICE_DEBUG,
+            D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS,
+            D3D11_SDK_VERSION, D3D11CreateDevice, ID3D11Device, ID3D11DeviceContext,
+        },
+        Dxgi::{
+            CreateDXGIFactory2, DXGI_CREATE_FACTORY_DEBUG, DXGI_CREATE_FACTORY_FLAGS,
+            IDXGIAdapter1, IDXGIFactory6,
+        },
+    },
+};
+use windows::core::Interface;
+
+pub(crate) fn try_to_recover_from_device_lost<T>(
+    mut f: impl FnMut() -> Result<T>,
+    on_success: impl FnOnce(T),
+    on_error: impl FnOnce(),
+) {
+    let result = (0..5).find_map(|i| {
+        if i > 0 {
+            // Add a small delay before retrying
+            std::thread::sleep(std::time::Duration::from_millis(100));
+        }
+        f().log_err()
+    });
+
+    if let Some(result) = result {
+        on_success(result);
+    } else {
+        on_error();
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct DirectXDevices {
+    pub(crate) adapter: IDXGIAdapter1,
+    pub(crate) dxgi_factory: IDXGIFactory6,
+    pub(crate) device: ID3D11Device,
+    pub(crate) device_context: ID3D11DeviceContext,
+}
+
+impl DirectXDevices {
+    pub(crate) fn new() -> Result<Self> {
+        let debug_layer_available = check_debug_layer_available();
+        let dxgi_factory =
+            get_dxgi_factory(debug_layer_available).context("Creating DXGI factory")?;
+        let adapter =
+            get_adapter(&dxgi_factory, debug_layer_available).context("Getting DXGI adapter")?;
+        let (device, device_context) = {
+            let mut context: Option<ID3D11DeviceContext> = None;
+            let mut feature_level = D3D_FEATURE_LEVEL::default();
+            let device = get_device(
+                &adapter,
+                Some(&mut context),
+                Some(&mut feature_level),
+                debug_layer_available,
+            )
+            .context("Creating Direct3D device")?;
+            match feature_level {
+                D3D_FEATURE_LEVEL_11_1 => {
+                    log::info!("Created device with Direct3D 11.1 feature level.")
+                }
+                D3D_FEATURE_LEVEL_11_0 => {
+                    log::info!("Created device with Direct3D 11.0 feature level.")
+                }
+                D3D_FEATURE_LEVEL_10_1 => {
+                    log::info!("Created device with Direct3D 10.1 feature level.")
+                }
+                _ => unreachable!(),
+            }
+            (device, context.unwrap())
+        };
+
+        Ok(Self {
+            adapter,
+            dxgi_factory,
+            device,
+            device_context,
+        })
+    }
+}
+
+#[inline]
+fn check_debug_layer_available() -> bool {
+    #[cfg(debug_assertions)]
+    {
+        use windows::Win32::Graphics::Dxgi::{DXGIGetDebugInterface1, IDXGIInfoQueue};
+
+        unsafe { DXGIGetDebugInterface1::<IDXGIInfoQueue>(0) }
+            .log_err()
+            .is_some()
+    }
+    #[cfg(not(debug_assertions))]
+    {
+        false
+    }
+}
+
+#[inline]
+fn get_dxgi_factory(debug_layer_available: bool) -> Result<IDXGIFactory6> {
+    let factory_flag = if debug_layer_available {
+        DXGI_CREATE_FACTORY_DEBUG
+    } else {
+        #[cfg(debug_assertions)]
+        log::warn!(
+            "Failed to get DXGI debug interface. DirectX debugging features will be disabled."
+        );
+        DXGI_CREATE_FACTORY_FLAGS::default()
+    };
+    unsafe { Ok(CreateDXGIFactory2(factory_flag)?) }
+}
+
+#[inline]
+fn get_adapter(dxgi_factory: &IDXGIFactory6, debug_layer_available: bool) -> Result<IDXGIAdapter1> {
+    for adapter_index in 0.. {
+        let adapter: IDXGIAdapter1 = unsafe { dxgi_factory.EnumAdapters(adapter_index)?.cast()? };
+        if let Ok(desc) = unsafe { adapter.GetDesc1() } {
+            let gpu_name = String::from_utf16_lossy(&desc.Description)
+                .trim_matches(char::from(0))
+                .to_string();
+            log::info!("Using GPU: {}", gpu_name);
+        }
+        // Check to see whether the adapter supports Direct3D 11, but don't
+        // create the actual device yet.
+        if get_device(&adapter, None, None, debug_layer_available)
+            .log_err()
+            .is_some()
+        {
+            return Ok(adapter);
+        }
+    }
+
+    unreachable!()
+}
+
+#[inline]
+fn get_device(
+    adapter: &IDXGIAdapter1,
+    context: Option<*mut Option<ID3D11DeviceContext>>,
+    feature_level: Option<*mut D3D_FEATURE_LEVEL>,
+    debug_layer_available: bool,
+) -> Result<ID3D11Device> {
+    let mut device: Option<ID3D11Device> = None;
+    let device_flags = if debug_layer_available {
+        D3D11_CREATE_DEVICE_BGRA_SUPPORT | D3D11_CREATE_DEVICE_DEBUG
+    } else {
+        D3D11_CREATE_DEVICE_BGRA_SUPPORT
+    };
+    unsafe {
+        D3D11CreateDevice(
+            adapter,
+            D3D_DRIVER_TYPE_UNKNOWN,
+            HMODULE::default(),
+            device_flags,
+            // 4x MSAA is required for Direct3D Feature Level 10.1 or better
+            Some(&[
+                D3D_FEATURE_LEVEL_11_1,
+                D3D_FEATURE_LEVEL_11_0,
+                D3D_FEATURE_LEVEL_10_1,
+            ]),
+            D3D11_SDK_VERSION,
+            Some(&mut device),
+            feature_level,
+            context,
+        )?;
+    }
+    let device = device.unwrap();
+    let mut data = D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS::default();
+    unsafe {
+        device
+            .CheckFeatureSupport(
+                D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS,
+                &mut data as *mut _ as _,
+                std::mem::size_of::<D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS>() as u32,
+            )
+            .context("Checking GPU device feature support")?;
+    }
+    if data
+        .ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x
+        .as_bool()
+    {
+        Ok(device)
+    } else {
+        Err(anyhow::anyhow!(
+            "Required feature StructuredBuffer is not supported by GPU/driver"
+        ))
+    }
+}

third_party/gpui/src/platform/windows/dispatcher.rs

@@ -0,0 +1,110 @@
+use std::{
+    thread::{ThreadId, current},
+    time::Duration,
+};
+
+use async_task::Runnable;
+use flume::Sender;
+use util::ResultExt;
+use windows::{
+    System::Threading::{
+        ThreadPool, ThreadPoolTimer, TimerElapsedHandler, WorkItemHandler, WorkItemPriority,
+    },
+    Win32::{
+        Foundation::{LPARAM, WPARAM},
+        UI::WindowsAndMessaging::PostMessageW,
+    },
+};
+
+use crate::{
+    HWND, PlatformDispatcher, SafeHwnd, TaskLabel, WM_GPUI_TASK_DISPATCHED_ON_MAIN_THREAD,
+};
+
+pub(crate) struct WindowsDispatcher {
+    main_sender: Sender<Runnable>,
+    main_thread_id: ThreadId,
+    platform_window_handle: SafeHwnd,
+    validation_number: usize,
+}
+
+impl WindowsDispatcher {
+    pub(crate) fn new(
+        main_sender: Sender<Runnable>,
+        platform_window_handle: HWND,
+        validation_number: usize,
+    ) -> Self {
+        let main_thread_id = current().id();
+        let platform_window_handle = platform_window_handle.into();
+
+        WindowsDispatcher {
+            main_sender,
+            main_thread_id,
+            platform_window_handle,
+            validation_number,
+        }
+    }
+
+    fn dispatch_on_threadpool(&self, runnable: Runnable) {
+        let handler = {
+            let mut task_wrapper = Some(runnable);
+            WorkItemHandler::new(move |_| {
+                task_wrapper.take().unwrap().run();
+                Ok(())
+            })
+        };
+        ThreadPool::RunWithPriorityAsync(&handler, WorkItemPriority::High).log_err();
+    }
+
+    fn dispatch_on_threadpool_after(&self, runnable: Runnable, duration: Duration) {
+        let handler = {
+            let mut task_wrapper = Some(runnable);
+            TimerElapsedHandler::new(move |_| {
+                task_wrapper.take().unwrap().run();
+                Ok(())
+            })
+        };
+        ThreadPoolTimer::CreateTimer(&handler, duration.into()).log_err();
+    }
+}
+
+impl PlatformDispatcher for WindowsDispatcher {
+    fn is_main_thread(&self) -> bool {
+        current().id() == self.main_thread_id
+    }
+
+    fn dispatch(&self, runnable: Runnable, label: Option<TaskLabel>) {
+        self.dispatch_on_threadpool(runnable);
+        if let Some(label) = label {
+            log::debug!("TaskLabel: {label:?}");
+        }
+    }
+
+    fn dispatch_on_main_thread(&self, runnable: Runnable) {
+        match self.main_sender.send(runnable) {
+            Ok(_) => unsafe {
+                PostMessageW(
+                    Some(self.platform_window_handle.as_raw()),
+                    WM_GPUI_TASK_DISPATCHED_ON_MAIN_THREAD,
+                    WPARAM(self.validation_number),
+                    LPARAM(0),
+                )
+                .log_err();
+            },
+            Err(runnable) => {
+                // NOTE: Runnable may wrap a Future that is !Send.
+                //
+                // This is usually safe because we only poll it on the main thread.
+                // However if the send fails, we know that:
+                // 1. main_receiver has been dropped (which implies the app is shutting down)
+                // 2. we are on a background thread.
+                // It is not safe to drop something !Send on the wrong thread, and
+                // the app will exit soon anyway, so we must forget the runnable.
+                std::mem::forget(runnable);
+            }
+        }
+    }
+
+    fn dispatch_after(&self, duration: Duration, runnable: Runnable) {
+        self.dispatch_on_threadpool_after(runnable, duration);
+    }
+}

third_party/gpui/src/platform/windows/display.rs

@@ -0,0 +1,255 @@
+use itertools::Itertools;
+use smallvec::SmallVec;
+use std::rc::Rc;
+use util::ResultExt;
+use uuid::Uuid;
+use windows::{
+    Win32::{
+        Foundation::*,
+        Graphics::Gdi::*,
+        UI::{
+            HiDpi::{GetDpiForMonitor, MDT_EFFECTIVE_DPI},
+            WindowsAndMessaging::USER_DEFAULT_SCREEN_DPI,
+        },
+    },
+    core::*,
+};
+
+use crate::{Bounds, DevicePixels, DisplayId, Pixels, PlatformDisplay, logical_point, point, size};
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct WindowsDisplay {
+    pub handle: HMONITOR,
+    pub display_id: DisplayId,
+    scale_factor: f32,
+    bounds: Bounds<Pixels>,
+    physical_bounds: Bounds<DevicePixels>,
+    uuid: Uuid,
+}
+
+// The `HMONITOR` is thread-safe.
+unsafe impl Send for WindowsDisplay {}
+unsafe impl Sync for WindowsDisplay {}
+
+impl WindowsDisplay {
+    pub(crate) fn new(display_id: DisplayId) -> Option<Self> {
+        let screen = available_monitors().into_iter().nth(display_id.0 as _)?;
+        let info = get_monitor_info(screen).log_err()?;
+        let monitor_size = info.monitorInfo.rcMonitor;
+        let uuid = generate_uuid(&info.szDevice);
+        let scale_factor = get_scale_factor_for_monitor(screen).log_err()?;
+        let physical_size = size(
+            (monitor_size.right - monitor_size.left).into(),
+            (monitor_size.bottom - monitor_size.top).into(),
+        );
+
+        Some(WindowsDisplay {
+            handle: screen,
+            display_id,
+            scale_factor,
+            bounds: Bounds {
+                origin: logical_point(
+                    monitor_size.left as f32,
+                    monitor_size.top as f32,
+                    scale_factor,
+                ),
+                size: physical_size.to_pixels(scale_factor),
+            },
+            physical_bounds: Bounds {
+                origin: point(monitor_size.left.into(), monitor_size.top.into()),
+                size: physical_size,
+            },
+            uuid,
+        })
+    }
+
+    pub fn new_with_handle(monitor: HMONITOR) -> Self {
+        let info = get_monitor_info(monitor).expect("unable to get monitor info");
+        let monitor_size = info.monitorInfo.rcMonitor;
+        let uuid = generate_uuid(&info.szDevice);
+        let display_id = available_monitors()
+            .iter()
+            .position(|handle| handle.0 == monitor.0)
+            .unwrap();
+        let scale_factor =
+            get_scale_factor_for_monitor(monitor).expect("unable to get scale factor for monitor");
+        let physical_size = size(
+            (monitor_size.right - monitor_size.left).into(),
+            (monitor_size.bottom - monitor_size.top).into(),
+        );
+
+        WindowsDisplay {
+            handle: monitor,
+            display_id: DisplayId(display_id as _),
+            scale_factor,
+            bounds: Bounds {
+                origin: logical_point(
+                    monitor_size.left as f32,
+                    monitor_size.top as f32,
+                    scale_factor,
+                ),
+                size: physical_size.to_pixels(scale_factor),
+            },
+            physical_bounds: Bounds {
+                origin: point(monitor_size.left.into(), monitor_size.top.into()),
+                size: physical_size,
+            },
+            uuid,
+        }
+    }
+
+    fn new_with_handle_and_id(handle: HMONITOR, display_id: DisplayId) -> Self {
+        let info = get_monitor_info(handle).expect("unable to get monitor info");
+        let monitor_size = info.monitorInfo.rcMonitor;
+        let uuid = generate_uuid(&info.szDevice);
+        let scale_factor =
+            get_scale_factor_for_monitor(handle).expect("unable to get scale factor for monitor");
+        let physical_size = size(
+            (monitor_size.right - monitor_size.left).into(),
+            (monitor_size.bottom - monitor_size.top).into(),
+        );
+
+        WindowsDisplay {
+            handle,
+            display_id,
+            scale_factor,
+            bounds: Bounds {
+                origin: logical_point(
+                    monitor_size.left as f32,
+                    monitor_size.top as f32,
+                    scale_factor,
+                ),
+                size: physical_size.to_pixels(scale_factor),
+            },
+            physical_bounds: Bounds {
+                origin: point(monitor_size.left.into(), monitor_size.top.into()),
+                size: physical_size,
+            },
+            uuid,
+        }
+    }
+
+    pub fn primary_monitor() -> Option<Self> {
+        // https://devblogs.microsoft.com/oldnewthing/20070809-00/?p=25643
+        const POINT_ZERO: POINT = POINT { x: 0, y: 0 };
+        let monitor = unsafe { MonitorFromPoint(POINT_ZERO, MONITOR_DEFAULTTOPRIMARY) };
+        if monitor.is_invalid() {
+            log::error!(
+                "can not find the primary monitor: {}",
+                std::io::Error::last_os_error()
+            );
+            return None;
+        }
+        Some(WindowsDisplay::new_with_handle(monitor))
+    }
+
+    /// Check if the center point of given bounds is inside this monitor
+    pub fn check_given_bounds(&self, bounds: Bounds<Pixels>) -> bool {
+        let center = bounds.center();
+        let center = POINT {
+            x: (center.x.0 * self.scale_factor) as i32,
+            y: (center.y.0 * self.scale_factor) as i32,
+        };
+        let monitor = unsafe { MonitorFromPoint(center, MONITOR_DEFAULTTONULL) };
+        if monitor.is_invalid() {
+            false
+        } else {
+            let display = WindowsDisplay::new_with_handle(monitor);
+            display.uuid == self.uuid
+        }
+    }
+
+    pub fn displays() -> Vec<Rc<dyn PlatformDisplay>> {
+        available_monitors()
+            .into_iter()
+            .enumerate()
+            .map(|(id, handle)| {
+                Rc::new(WindowsDisplay::new_with_handle_and_id(
+                    handle,
+                    DisplayId(id as _),
+                )) as Rc<dyn PlatformDisplay>
+            })
+            .collect()
+    }
+
+    /// Check if this monitor is still online
+    pub fn is_connected(hmonitor: HMONITOR) -> bool {
+        available_monitors().iter().contains(&hmonitor)
+    }
+
+    pub fn physical_bounds(&self) -> Bounds<DevicePixels> {
+        self.physical_bounds
+    }
+}
+
+impl PlatformDisplay for WindowsDisplay {
+    fn id(&self) -> DisplayId {
+        self.display_id
+    }
+
+    fn uuid(&self) -> anyhow::Result<Uuid> {
+        Ok(self.uuid)
+    }
+
+    fn bounds(&self) -> Bounds<Pixels> {
+        self.bounds
+    }
+}
+
+fn available_monitors() -> SmallVec<[HMONITOR; 4]> {
+    let mut monitors: SmallVec<[HMONITOR; 4]> = SmallVec::new();
+    unsafe {
+        EnumDisplayMonitors(
+            None,
+            None,
+            Some(monitor_enum_proc),
+            LPARAM(&mut monitors as *mut _ as _),
+        )
+        .ok()
+        .log_err();
+    }
+    monitors
+}
+
+unsafe extern "system" fn monitor_enum_proc(
+    hmonitor: HMONITOR,
+    _hdc: HDC,
+    _place: *mut RECT,
+    data: LPARAM,
+) -> BOOL {
+    let monitors = data.0 as *mut SmallVec<[HMONITOR; 4]>;
+    unsafe { (*monitors).push(hmonitor) };
+    BOOL(1)
+}
+
+fn get_monitor_info(hmonitor: HMONITOR) -> anyhow::Result<MONITORINFOEXW> {
+    let mut monitor_info: MONITORINFOEXW = unsafe { std::mem::zeroed() };
+    monitor_info.monitorInfo.cbSize = std::mem::size_of::<MONITORINFOEXW>() as u32;
+    let status = unsafe {
+        GetMonitorInfoW(
+            hmonitor,
+            &mut monitor_info as *mut MONITORINFOEXW as *mut MONITORINFO,
+        )
+    };
+    if status.as_bool() {
+        Ok(monitor_info)
+    } else {
+        Err(anyhow::anyhow!(std::io::Error::last_os_error()))
+    }
+}
+
+fn generate_uuid(device_name: &[u16]) -> Uuid {
+    let name = device_name
+        .iter()
+        .flat_map(|&a| a.to_be_bytes())
+        .collect_vec();
+    Uuid::new_v5(&Uuid::NAMESPACE_DNS, &name)
+}
+
+fn get_scale_factor_for_monitor(monitor: HMONITOR) -> Result<f32> {
+    let mut dpi_x = 0;
+    let mut dpi_y = 0;
+    unsafe { GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y) }?;
+    assert_eq!(dpi_x, dpi_y);
+    Ok(dpi_x as f32 / USER_DEFAULT_SCREEN_DPI as f32)
+}

third_party/gpui/src/platform/windows/keyboard.rs

@@ -0,0 +1,404 @@
+use anyhow::Result;
+use collections::HashMap;
+use windows::Win32::UI::{
+    Input::KeyboardAndMouse::{
+        GetKeyboardLayoutNameW, MAPVK_VK_TO_CHAR, MAPVK_VK_TO_VSC, MapVirtualKeyW, ToUnicode,
+        VIRTUAL_KEY, VK_0, VK_1, VK_2, VK_3, VK_4, VK_5, VK_6, VK_7, VK_8, VK_9, VK_ABNT_C1,
+        VK_CONTROL, VK_MENU, VK_OEM_1, VK_OEM_2, VK_OEM_3, VK_OEM_4, VK_OEM_5, VK_OEM_6, VK_OEM_7,
+        VK_OEM_8, VK_OEM_102, VK_OEM_COMMA, VK_OEM_MINUS, VK_OEM_PERIOD, VK_OEM_PLUS, VK_SHIFT,
+    },
+    WindowsAndMessaging::KL_NAMELENGTH,
+};
+use windows_core::HSTRING;
+
+use crate::{
+    KeybindingKeystroke, Keystroke, Modifiers, PlatformKeyboardLayout, PlatformKeyboardMapper,
+};
+
+pub(crate) struct WindowsKeyboardLayout {
+    id: String,
+    name: String,
+}
+
+pub(crate) struct WindowsKeyboardMapper {
+    key_to_vkey: HashMap<String, (u16, bool)>,
+    vkey_to_key: HashMap<u16, String>,
+    vkey_to_shifted: HashMap<u16, String>,
+}
+
+impl PlatformKeyboardLayout for WindowsKeyboardLayout {
+    fn id(&self) -> &str {
+        &self.id
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl PlatformKeyboardMapper for WindowsKeyboardMapper {
+    fn map_key_equivalent(
+        &self,
+        mut keystroke: Keystroke,
+        use_key_equivalents: bool,
+    ) -> KeybindingKeystroke {
+        let Some((vkey, shifted_key)) = self.get_vkey_from_key(&keystroke.key, use_key_equivalents)
+        else {
+            return KeybindingKeystroke::from_keystroke(keystroke);
+        };
+        if shifted_key && keystroke.modifiers.shift {
+            log::warn!(
+                "Keystroke '{}' has both shift and a shifted key, this is likely a bug",
+                keystroke.key
+            );
+        }
+
+        let shift = shifted_key || keystroke.modifiers.shift;
+        keystroke.modifiers.shift = false;
+
+        let Some(key) = self.vkey_to_key.get(&vkey).cloned() else {
+            log::error!(
+                "Failed to map key equivalent '{:?}' to a valid key",
+                keystroke
+            );
+            return KeybindingKeystroke::from_keystroke(keystroke);
+        };
+
+        keystroke.key = if shift {
+            let Some(shifted_key) = self.vkey_to_shifted.get(&vkey).cloned() else {
+                log::error!(
+                    "Failed to map keystroke {:?} with virtual key '{:?}' to a shifted key",
+                    keystroke,
+                    vkey
+                );
+                return KeybindingKeystroke::from_keystroke(keystroke);
+            };
+            shifted_key
+        } else {
+            key.clone()
+        };
+
+        let modifiers = Modifiers {
+            shift,
+            ..keystroke.modifiers
+        };
+
+        KeybindingKeystroke::new(keystroke, modifiers, key)
+    }
+
+    fn get_key_equivalents(&self) -> Option<&HashMap<char, char>> {
+        None
+    }
+}
+
+impl WindowsKeyboardLayout {
+    pub(crate) fn new() -> Result<Self> {
+        let mut buffer = [0u16; KL_NAMELENGTH as usize];
+        unsafe { GetKeyboardLayoutNameW(&mut buffer)? };
+        let id = HSTRING::from_wide(&buffer).to_string();
+        let entry = windows_registry::LOCAL_MACHINE.open(format!(
+            "System\\CurrentControlSet\\Control\\Keyboard Layouts\\{}",
+            id
+        ))?;
+        let name = entry.get_hstring("Layout Text")?.to_string();
+        Ok(Self { id, name })
+    }
+
+    pub(crate) fn unknown() -> Self {
+        Self {
+            id: "unknown".to_string(),
+            name: "unknown".to_string(),
+        }
+    }
+
+    pub(crate) fn uses_altgr(&self) -> bool {
+        // Check if this is a known AltGr layout by examining the layout ID
+        // The layout ID is a hex string like "00000409" (US) or "00000407" (German)
+        // Extract the language ID (last 4 bytes)
+        let id_bytes = self.id.as_bytes();
+        if id_bytes.len() >= 4 {
+            let lang_id = &id_bytes[id_bytes.len() - 4..];
+            // List of keyboard layouts that use AltGr (non-exhaustive)
+            matches!(
+                lang_id,
+                b"0407" | // German
+                b"040C" | // French
+                b"040A" | // Spanish
+                b"0415" | // Polish
+                b"0413" | // Dutch
+                b"0816" | // Portuguese
+                b"041D" | // Swedish
+                b"0414" | // Norwegian
+                b"040B" | // Finnish
+                b"041F" | // Turkish
+                b"0419" | // Russian
+                b"0405" | // Czech
+                b"040E" | // Hungarian
+                b"0424" | // Slovenian
+                b"041B" | // Slovak
+                b"0418" // Romanian
+            )
+        } else {
+            false
+        }
+    }
+}
+
+impl WindowsKeyboardMapper {
+    pub(crate) fn new() -> Self {
+        let mut key_to_vkey = HashMap::default();
+        let mut vkey_to_key = HashMap::default();
+        let mut vkey_to_shifted = HashMap::default();
+        for vkey in CANDIDATE_VKEYS {
+            if let Some(key) = get_key_from_vkey(*vkey) {
+                key_to_vkey.insert(key.clone(), (vkey.0, false));
+                vkey_to_key.insert(vkey.0, key);
+            }
+            let scan_code = unsafe { MapVirtualKeyW(vkey.0 as u32, MAPVK_VK_TO_VSC) };
+            if scan_code == 0 {
+                continue;
+            }
+            if let Some(shifted_key) = get_shifted_key(*vkey, scan_code) {
+                key_to_vkey.insert(shifted_key.clone(), (vkey.0, true));
+                vkey_to_shifted.insert(vkey.0, shifted_key);
+            }
+        }
+        Self {
+            key_to_vkey,
+            vkey_to_key,
+            vkey_to_shifted,
+        }
+    }
+
+    fn get_vkey_from_key(&self, key: &str, use_key_equivalents: bool) -> Option<(u16, bool)> {
+        if use_key_equivalents {
+            get_vkey_from_key_with_us_layout(key)
+        } else {
+            self.key_to_vkey.get(key).cloned()
+        }
+    }
+}
+
+pub(crate) fn get_keystroke_key(
+    vkey: VIRTUAL_KEY,
+    scan_code: u32,
+    modifiers: &mut Modifiers,
+) -> Option<String> {
+    if modifiers.shift && need_to_convert_to_shifted_key(vkey) {
+        get_shifted_key(vkey, scan_code).inspect(|_| {
+            modifiers.shift = false;
+        })
+    } else {
+        get_key_from_vkey(vkey)
+    }
+}
+
+fn get_key_from_vkey(vkey: VIRTUAL_KEY) -> Option<String> {
+    let key_data = unsafe { MapVirtualKeyW(vkey.0 as u32, MAPVK_VK_TO_CHAR) };
+    if key_data == 0 {
+        return None;
+    }
+
+    // The high word contains dead key flag, the low word contains the character
+    let key = char::from_u32(key_data & 0xFFFF)?;
+
+    Some(key.to_ascii_lowercase().to_string())
+}
+
+#[inline]
+fn need_to_convert_to_shifted_key(vkey: VIRTUAL_KEY) -> bool {
+    matches!(
+        vkey,
+        VK_OEM_3
+            | VK_OEM_MINUS
+            | VK_OEM_PLUS
+            | VK_OEM_4
+            | VK_OEM_5
+            | VK_OEM_6
+            | VK_OEM_1
+            | VK_OEM_7
+            | VK_OEM_COMMA
+            | VK_OEM_PERIOD
+            | VK_OEM_2
+            | VK_OEM_102
+            | VK_OEM_8
+            | VK_ABNT_C1
+            | VK_0
+            | VK_1
+            | VK_2
+            | VK_3
+            | VK_4
+            | VK_5
+            | VK_6
+            | VK_7
+            | VK_8
+            | VK_9
+    )
+}
+
+fn get_shifted_key(vkey: VIRTUAL_KEY, scan_code: u32) -> Option<String> {
+    generate_key_char(vkey, scan_code, false, true, false)
+}
+
+pub(crate) fn generate_key_char(
+    vkey: VIRTUAL_KEY,
+    scan_code: u32,
+    control: bool,
+    shift: bool,
+    alt: bool,
+) -> Option<String> {
+    let mut state = [0; 256];
+    if control {
+        state[VK_CONTROL.0 as usize] = 0x80;
+    }
+    if shift {
+        state[VK_SHIFT.0 as usize] = 0x80;
+    }
+    if alt {
+        state[VK_MENU.0 as usize] = 0x80;
+    }
+
+    let mut buffer = [0; 8];
+    let len = unsafe { ToUnicode(vkey.0 as u32, scan_code, Some(&state), &mut buffer, 1 << 2) };
+
+    match len {
+        len if len > 0 => String::from_utf16(&buffer[..len as usize])
+            .ok()
+            .filter(|candidate| {
+                !candidate.is_empty() && !candidate.chars().next().unwrap().is_control()
+            }),
+        len if len < 0 => String::from_utf16(&buffer[..(-len as usize)]).ok(),
+        _ => None,
+    }
+}
+
+fn get_vkey_from_key_with_us_layout(key: &str) -> Option<(u16, bool)> {
+    match key {
+        // ` => VK_OEM_3
+        "`" => Some((VK_OEM_3.0, false)),
+        "~" => Some((VK_OEM_3.0, true)),
+        "1" => Some((VK_1.0, false)),
+        "!" => Some((VK_1.0, true)),
+        "2" => Some((VK_2.0, false)),
+        "@" => Some((VK_2.0, true)),
+        "3" => Some((VK_3.0, false)),
+        "#" => Some((VK_3.0, true)),
+        "4" => Some((VK_4.0, false)),
+        "$" => Some((VK_4.0, true)),
+        "5" => Some((VK_5.0, false)),
+        "%" => Some((VK_5.0, true)),
+        "6" => Some((VK_6.0, false)),
+        "^" => Some((VK_6.0, true)),
+        "7" => Some((VK_7.0, false)),
+        "&" => Some((VK_7.0, true)),
+        "8" => Some((VK_8.0, false)),
+        "*" => Some((VK_8.0, true)),
+        "9" => Some((VK_9.0, false)),
+        "(" => Some((VK_9.0, true)),
+        "0" => Some((VK_0.0, false)),
+        ")" => Some((VK_0.0, true)),
+        "-" => Some((VK_OEM_MINUS.0, false)),
+        "_" => Some((VK_OEM_MINUS.0, true)),
+        "=" => Some((VK_OEM_PLUS.0, false)),
+        "+" => Some((VK_OEM_PLUS.0, true)),
+        "[" => Some((VK_OEM_4.0, false)),
+        "{" => Some((VK_OEM_4.0, true)),
+        "]" => Some((VK_OEM_6.0, false)),
+        "}" => Some((VK_OEM_6.0, true)),
+        "\\" => Some((VK_OEM_5.0, false)),
+        "|" => Some((VK_OEM_5.0, true)),
+        ";" => Some((VK_OEM_1.0, false)),
+        ":" => Some((VK_OEM_1.0, true)),
+        "'" => Some((VK_OEM_7.0, false)),
+        "\"" => Some((VK_OEM_7.0, true)),
+        "," => Some((VK_OEM_COMMA.0, false)),
+        "<" => Some((VK_OEM_COMMA.0, true)),
+        "." => Some((VK_OEM_PERIOD.0, false)),
+        ">" => Some((VK_OEM_PERIOD.0, true)),
+        "/" => Some((VK_OEM_2.0, false)),
+        "?" => Some((VK_OEM_2.0, true)),
+        _ => None,
+    }
+}
+
+const CANDIDATE_VKEYS: &[VIRTUAL_KEY] = &[
+    VK_OEM_3,
+    VK_OEM_MINUS,
+    VK_OEM_PLUS,
+    VK_OEM_4,
+    VK_OEM_5,
+    VK_OEM_6,
+    VK_OEM_1,
+    VK_OEM_7,
+    VK_OEM_COMMA,
+    VK_OEM_PERIOD,
+    VK_OEM_2,
+    VK_OEM_102,
+    VK_OEM_8,
+    VK_ABNT_C1,
+    VK_0,
+    VK_1,
+    VK_2,
+    VK_3,
+    VK_4,
+    VK_5,
+    VK_6,
+    VK_7,
+    VK_8,
+    VK_9,
+];
+
+#[cfg(test)]
+mod tests {
+    use crate::{Keystroke, Modifiers, PlatformKeyboardMapper, WindowsKeyboardMapper};
+
+    #[test]
+    fn test_keyboard_mapper() {
+        let mapper = WindowsKeyboardMapper::new();
+
+        // Normal case
+        let keystroke = Keystroke {
+            modifiers: Modifiers::control(),
+            key: "a".to_string(),
+            key_char: None,
+        };
+        let mapped = mapper.map_key_equivalent(keystroke.clone(), true);
+        assert_eq!(*mapped.inner(), keystroke);
+        assert_eq!(mapped.key(), "a");
+        assert_eq!(*mapped.modifiers(), Modifiers::control());
+
+        // Shifted case, ctrl-$
+        let keystroke = Keystroke {
+            modifiers: Modifiers::control(),
+            key: "$".to_string(),
+            key_char: None,
+        };
+        let mapped = mapper.map_key_equivalent(keystroke.clone(), true);
+        assert_eq!(*mapped.inner(), keystroke);
+        assert_eq!(mapped.key(), "4");
+        assert_eq!(*mapped.modifiers(), Modifiers::control_shift());
+
+        // Shifted case, but shift is true
+        let keystroke = Keystroke {
+            modifiers: Modifiers::control_shift(),
+            key: "$".to_string(),
+            key_char: None,
+        };
+        let mapped = mapper.map_key_equivalent(keystroke, true);
+        assert_eq!(mapped.inner().modifiers, Modifiers::control());
+        assert_eq!(mapped.key(), "4");
+        assert_eq!(*mapped.modifiers(), Modifiers::control_shift());
+
+        // Windows style
+        let keystroke = Keystroke {
+            modifiers: Modifiers::control_shift(),
+            key: "4".to_string(),
+            key_char: None,
+        };
+        let mapped = mapper.map_key_equivalent(keystroke, true);
+        assert_eq!(mapped.inner().modifiers, Modifiers::control());
+        assert_eq!(mapped.inner().key, "$");
+        assert_eq!(mapped.key(), "4");
+        assert_eq!(*mapped.modifiers(), Modifiers::control_shift());
+    }
+}

third_party/gpui/src/platform/windows/system_settings.rs

@@ -0,0 +1,197 @@
+use std::ffi::{c_uint, c_void};
+
+use ::util::ResultExt;
+use windows::Win32::UI::{
+    Shell::{ABM_GETSTATE, ABM_GETTASKBARPOS, ABS_AUTOHIDE, APPBARDATA, SHAppBarMessage},
+    WindowsAndMessaging::{
+        SPI_GETWHEELSCROLLCHARS, SPI_GETWHEELSCROLLLINES, SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS,
+        SystemParametersInfoW,
+    },
+};
+
+use crate::*;
+
+use super::WindowsDisplay;
+
+/// Windows settings pulled from SystemParametersInfo
+/// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-systemparametersinfow
+#[derive(Default, Debug, Clone, Copy)]
+pub(crate) struct WindowsSystemSettings {
+    pub(crate) mouse_wheel_settings: MouseWheelSettings,
+    pub(crate) auto_hide_taskbar_position: Option<AutoHideTaskbarPosition>,
+}
+
+#[derive(Default, Debug, Clone, Copy)]
+pub(crate) struct MouseWheelSettings {
+    /// SEE: SPI_GETWHEELSCROLLCHARS
+    pub(crate) wheel_scroll_chars: u32,
+    /// SEE: SPI_GETWHEELSCROLLLINES
+    pub(crate) wheel_scroll_lines: u32,
+}
+
+impl WindowsSystemSettings {
+    pub(crate) fn new(display: WindowsDisplay) -> Self {
+        let mut settings = Self::default();
+        settings.init(display);
+        settings
+    }
+
+    fn init(&mut self, display: WindowsDisplay) {
+        self.mouse_wheel_settings.update();
+        self.auto_hide_taskbar_position = AutoHideTaskbarPosition::new(display).log_err().flatten();
+    }
+
+    pub(crate) fn update(&mut self, display: WindowsDisplay, wparam: usize) {
+        match wparam {
+            // SPI_SETWORKAREA
+            47 => self.update_taskbar_position(display),
+            // SPI_GETWHEELSCROLLLINES, SPI_GETWHEELSCROLLCHARS
+            104 | 108 => self.update_mouse_wheel_settings(),
+            _ => {}
+        }
+    }
+
+    fn update_mouse_wheel_settings(&mut self) {
+        self.mouse_wheel_settings.update();
+    }
+
+    fn update_taskbar_position(&mut self, display: WindowsDisplay) {
+        self.auto_hide_taskbar_position = AutoHideTaskbarPosition::new(display).log_err().flatten();
+    }
+}
+
+impl MouseWheelSettings {
+    fn update(&mut self) {
+        self.update_wheel_scroll_chars();
+        self.update_wheel_scroll_lines();
+    }
+
+    fn update_wheel_scroll_chars(&mut self) {
+        let mut value = c_uint::default();
+        let result = unsafe {
+            SystemParametersInfoW(
+                SPI_GETWHEELSCROLLCHARS,
+                0,
+                Some((&mut value) as *mut c_uint as *mut c_void),
+                SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS::default(),
+            )
+        };
+
+        if result.log_err() != None && self.wheel_scroll_chars != value {
+            self.wheel_scroll_chars = value;
+        }
+    }
+
+    fn update_wheel_scroll_lines(&mut self) {
+        let mut value = c_uint::default();
+        let result = unsafe {
+            SystemParametersInfoW(
+                SPI_GETWHEELSCROLLLINES,
+                0,
+                Some((&mut value) as *mut c_uint as *mut c_void),
+                SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS::default(),
+            )
+        };
+
+        if result.log_err() != None && self.wheel_scroll_lines != value {
+            self.wheel_scroll_lines = value;
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub(crate) enum AutoHideTaskbarPosition {
+    Left,
+    Right,
+    Top,
+    #[default]
+    Bottom,
+}
+
+impl AutoHideTaskbarPosition {
+    fn new(display: WindowsDisplay) -> anyhow::Result<Option<Self>> {
+        if !check_auto_hide_taskbar_enable() {
+            // If auto hide taskbar is not enable, we do nothing in this case.
+            return Ok(None);
+        }
+        let mut info = APPBARDATA {
+            cbSize: std::mem::size_of::<APPBARDATA>() as u32,
+            ..Default::default()
+        };
+        let ret = unsafe { SHAppBarMessage(ABM_GETTASKBARPOS, &mut info) };
+        if ret == 0 {
+            anyhow::bail!(
+                "Unable to retrieve taskbar position: {}",
+                std::io::Error::last_os_error()
+            );
+        }
+        let taskbar_bounds: Bounds<DevicePixels> = Bounds::new(
+            point(info.rc.left.into(), info.rc.top.into()),
+            size(
+                (info.rc.right - info.rc.left).into(),
+                (info.rc.bottom - info.rc.top).into(),
+            ),
+        );
+        let display_bounds = display.physical_bounds();
+        if display_bounds.intersect(&taskbar_bounds) != taskbar_bounds {
+            // This case indicates that taskbar is not on the current monitor.
+            return Ok(None);
+        }
+        if taskbar_bounds.bottom() == display_bounds.bottom()
+            && taskbar_bounds.right() == display_bounds.right()
+        {
+            if taskbar_bounds.size.height < display_bounds.size.height
+                && taskbar_bounds.size.width == display_bounds.size.width
+            {
+                return Ok(Some(Self::Bottom));
+            }
+            if taskbar_bounds.size.width < display_bounds.size.width
+                && taskbar_bounds.size.height == display_bounds.size.height
+            {
+                return Ok(Some(Self::Right));
+            }
+            log::error!(
+                "Unrecognized taskbar bounds {:?} give display bounds {:?}",
+                taskbar_bounds,
+                display_bounds
+            );
+            return Ok(None);
+        }
+        if taskbar_bounds.top() == display_bounds.top()
+            && taskbar_bounds.left() == display_bounds.left()
+        {
+            if taskbar_bounds.size.height < display_bounds.size.height
+                && taskbar_bounds.size.width == display_bounds.size.width
+            {
+                return Ok(Some(Self::Top));
+            }
+            if taskbar_bounds.size.width < display_bounds.size.width
+                && taskbar_bounds.size.height == display_bounds.size.height
+            {
+                return Ok(Some(Self::Left));
+            }
+            log::error!(
+                "Unrecognized taskbar bounds {:?} give display bounds {:?}",
+                taskbar_bounds,
+                display_bounds
+            );
+            return Ok(None);
+        }
+        log::error!(
+            "Unrecognized taskbar bounds {:?} give display bounds {:?}",
+            taskbar_bounds,
+            display_bounds
+        );
+        Ok(None)
+    }
+}
+
+/// Check if auto hide taskbar is enable or not.
+fn check_auto_hide_taskbar_enable() -> bool {
+    let mut info = APPBARDATA {
+        cbSize: std::mem::size_of::<APPBARDATA>() as u32,
+        ..Default::default()
+    };
+    let ret = unsafe { SHAppBarMessage(ABM_GETSTATE, &mut info) } as u32;
+    ret == ABS_AUTOHIDE
+}

third_party/gpui/src/platform/windows/util.rs

@@ -0,0 +1,219 @@
+use std::sync::OnceLock;
+
+use ::util::ResultExt;
+use anyhow::Context;
+use windows::{
+    UI::{
+        Color,
+        ViewManagement::{UIColorType, UISettings},
+    },
+    Wdk::System::SystemServices::RtlGetVersion,
+    Win32::{
+        Foundation::*, Graphics::Dwm::*, System::LibraryLoader::LoadLibraryA,
+        UI::WindowsAndMessaging::*,
+    },
+    core::{BOOL, HSTRING, PCSTR},
+};
+
+use crate::*;
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum WindowsVersion {
+    Win10,
+    Win11,
+}
+
+impl WindowsVersion {
+    pub(crate) fn new() -> anyhow::Result<Self> {
+        let mut version = unsafe { std::mem::zeroed() };
+        let status = unsafe { RtlGetVersion(&mut version) };
+
+        status.ok()?;
+        if version.dwBuildNumber >= 22000 {
+            Ok(WindowsVersion::Win11)
+        } else {
+            Ok(WindowsVersion::Win10)
+        }
+    }
+}
+
+pub(crate) trait HiLoWord {
+    fn hiword(&self) -> u16;
+    fn loword(&self) -> u16;
+    fn signed_hiword(&self) -> i16;
+    fn signed_loword(&self) -> i16;
+}
+
+impl HiLoWord for WPARAM {
+    fn hiword(&self) -> u16 {
+        ((self.0 >> 16) & 0xFFFF) as u16
+    }
+
+    fn loword(&self) -> u16 {
+        (self.0 & 0xFFFF) as u16
+    }
+
+    fn signed_hiword(&self) -> i16 {
+        ((self.0 >> 16) & 0xFFFF) as i16
+    }
+
+    fn signed_loword(&self) -> i16 {
+        (self.0 & 0xFFFF) as i16
+    }
+}
+
+impl HiLoWord for LPARAM {
+    fn hiword(&self) -> u16 {
+        ((self.0 >> 16) & 0xFFFF) as u16
+    }
+
+    fn loword(&self) -> u16 {
+        (self.0 & 0xFFFF) as u16
+    }
+
+    fn signed_hiword(&self) -> i16 {
+        ((self.0 >> 16) & 0xFFFF) as i16
+    }
+
+    fn signed_loword(&self) -> i16 {
+        (self.0 & 0xFFFF) as i16
+    }
+}
+
+pub(crate) unsafe fn get_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX) -> isize {
+    #[cfg(target_pointer_width = "64")]
+    unsafe {
+        GetWindowLongPtrW(hwnd, nindex)
+    }
+    #[cfg(target_pointer_width = "32")]
+    unsafe {
+        GetWindowLongW(hwnd, nindex) as isize
+    }
+}
+
+pub(crate) unsafe fn set_window_long(
+    hwnd: HWND,
+    nindex: WINDOW_LONG_PTR_INDEX,
+    dwnewlong: isize,
+) -> isize {
+    #[cfg(target_pointer_width = "64")]
+    unsafe {
+        SetWindowLongPtrW(hwnd, nindex, dwnewlong)
+    }
+    #[cfg(target_pointer_width = "32")]
+    unsafe {
+        SetWindowLongW(hwnd, nindex, dwnewlong as i32) as isize
+    }
+}
+
+pub(crate) fn windows_credentials_target_name(url: &str) -> String {
+    format!("zed:url={}", url)
+}
+
+pub(crate) fn load_cursor(style: CursorStyle) -> Option<HCURSOR> {
+    static ARROW: OnceLock<SafeCursor> = OnceLock::new();
+    static IBEAM: OnceLock<SafeCursor> = OnceLock::new();
+    static CROSS: OnceLock<SafeCursor> = OnceLock::new();
+    static HAND: OnceLock<SafeCursor> = OnceLock::new();
+    static SIZEWE: OnceLock<SafeCursor> = OnceLock::new();
+    static SIZENS: OnceLock<SafeCursor> = OnceLock::new();
+    static NO: OnceLock<SafeCursor> = OnceLock::new();
+    let (lock, name) = match style {
+        CursorStyle::IBeam | CursorStyle::IBeamCursorForVerticalLayout => (&IBEAM, IDC_IBEAM),
+        CursorStyle::Crosshair => (&CROSS, IDC_CROSS),
+        CursorStyle::PointingHand | CursorStyle::DragLink => (&HAND, IDC_HAND),
+        CursorStyle::ResizeLeft
+        | CursorStyle::ResizeRight
+        | CursorStyle::ResizeLeftRight
+        | CursorStyle::ResizeColumn => (&SIZEWE, IDC_SIZEWE),
+        CursorStyle::ResizeUp
+        | CursorStyle::ResizeDown
+        | CursorStyle::ResizeUpDown
+        | CursorStyle::ResizeRow => (&SIZENS, IDC_SIZENS),
+        CursorStyle::OperationNotAllowed => (&NO, IDC_NO),
+        CursorStyle::None => return None,
+        _ => (&ARROW, IDC_ARROW),
+    };
+    Some(
+        *(*lock.get_or_init(|| {
+            HCURSOR(
+                unsafe { LoadImageW(None, name, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED) }
+                    .log_err()
+                    .unwrap_or_default()
+                    .0,
+            )
+            .into()
+        })),
+    )
+}
+
+/// This function is used to configure the dark mode for the window built-in title bar.
+pub(crate) fn configure_dwm_dark_mode(hwnd: HWND, appearance: WindowAppearance) {
+    let dark_mode_enabled: BOOL = match appearance {
+        WindowAppearance::Dark | WindowAppearance::VibrantDark => true.into(),
+        WindowAppearance::Light | WindowAppearance::VibrantLight => false.into(),
+    };
+    unsafe {
+        DwmSetWindowAttribute(
+            hwnd,
+            DWMWA_USE_IMMERSIVE_DARK_MODE,
+            &dark_mode_enabled as *const _ as _,
+            std::mem::size_of::<BOOL>() as u32,
+        )
+        .log_err();
+    }
+}
+
+#[inline]
+pub(crate) fn logical_point(x: f32, y: f32, scale_factor: f32) -> Point<Pixels> {
+    Point {
+        x: px(x / scale_factor),
+        y: px(y / scale_factor),
+    }
+}
+
+// https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/apply-windows-themes
+#[inline]
+pub(crate) fn system_appearance() -> Result<WindowAppearance> {
+    let ui_settings = UISettings::new()?;
+    let foreground_color = ui_settings.GetColorValue(UIColorType::Foreground)?;
+    // If the foreground is light, then is_color_light will evaluate to true,
+    // meaning Dark mode is enabled.
+    if is_color_light(&foreground_color) {
+        Ok(WindowAppearance::Dark)
+    } else {
+        Ok(WindowAppearance::Light)
+    }
+}
+
+#[inline(always)]
+fn is_color_light(color: &Color) -> bool {
+    ((5 * color.G as u32) + (2 * color.R as u32) + color.B as u32) > (8 * 128)
+}
+
+pub(crate) fn show_error(title: &str, content: String) {
+    let _ = unsafe {
+        MessageBoxW(
+            None,
+            &HSTRING::from(content),
+            &HSTRING::from(title),
+            MB_ICONERROR | MB_SYSTEMMODAL,
+        )
+    };
+}
+
+pub(crate) fn with_dll_library<R, F>(dll_name: PCSTR, f: F) -> Result<R>
+where
+    F: FnOnce(HMODULE) -> Result<R>,
+{
+    let library = unsafe {
+        LoadLibraryA(dll_name).with_context(|| format!("Loading dll: {}", dll_name.display()))?
+    };
+    let result = f(library);
+    unsafe {
+        FreeLibrary(library)
+            .with_context(|| format!("Freeing dll: {}", dll_name.display()))
+            .log_err();
+    }
+    result
+}

third_party/gpui/src/platform/windows/vsync.rs

@@ -0,0 +1,81 @@
+use std::{
+    sync::LazyLock,
+    time::{Duration, Instant},
+};
+
+use anyhow::{Context, Result};
+use util::ResultExt;
+use windows::Win32::{
+    Foundation::HWND,
+    Graphics::Dwm::{DWM_TIMING_INFO, DwmFlush, DwmGetCompositionTimingInfo},
+    System::Performance::QueryPerformanceFrequency,
+};
+
+static QPC_TICKS_PER_SECOND: LazyLock<u64> = LazyLock::new(|| {
+    let mut frequency = 0;
+    // On systems that run Windows XP or later, the function will always succeed and
+    // will thus never return zero.
+    unsafe { QueryPerformanceFrequency(&mut frequency).unwrap() };
+    frequency as u64
+});
+
+const VSYNC_INTERVAL_THRESHOLD: Duration = Duration::from_millis(1);
+const DEFAULT_VSYNC_INTERVAL: Duration = Duration::from_micros(16_666); // ~60Hz
+
+pub(crate) struct VSyncProvider {
+    interval: Duration,
+    f: Box<dyn Fn() -> bool>,
+}
+
+impl VSyncProvider {
+    pub(crate) fn new() -> Self {
+        let interval = get_dwm_interval()
+            .context("Failed to get DWM interval")
+            .log_err()
+            .unwrap_or(DEFAULT_VSYNC_INTERVAL);
+        let f = Box::new(|| unsafe { DwmFlush().is_ok() });
+        Self { interval, f }
+    }
+
+    pub(crate) fn wait_for_vsync(&self) {
+        let vsync_start = Instant::now();
+        let wait_succeeded = (self.f)();
+        let elapsed = vsync_start.elapsed();
+        // DwmFlush and DCompositionWaitForCompositorClock returns very early
+        // instead of waiting until vblank when the monitor goes to sleep or is
+        // unplugged (nothing to present due to desktop occlusion). We use 1ms as
+        // a threshold for the duration of the wait functions and fallback to
+        // Sleep() if it returns before that. This could happen during normal
+        // operation for the first call after the vsync thread becomes non-idle,
+        // but it shouldn't happen often.
+        if !wait_succeeded || elapsed < VSYNC_INTERVAL_THRESHOLD {
+            log::trace!("VSyncProvider::wait_for_vsync() took less time than expected");
+            std::thread::sleep(self.interval);
+        }
+    }
+}
+
+fn get_dwm_interval() -> Result<Duration> {
+    let mut timing_info = DWM_TIMING_INFO {
+        cbSize: std::mem::size_of::<DWM_TIMING_INFO>() as u32,
+        ..Default::default()
+    };
+    unsafe { DwmGetCompositionTimingInfo(HWND::default(), &mut timing_info) }?;
+    let interval = retrieve_duration(timing_info.qpcRefreshPeriod, *QPC_TICKS_PER_SECOND);
+    // Check for interval values that are impossibly low. A 29 microsecond
+    // interval was seen (from a qpcRefreshPeriod of 60).
+    if interval < VSYNC_INTERVAL_THRESHOLD {
+        Ok(retrieve_duration(
+            timing_info.rateRefresh.uiDenominator as u64,
+            timing_info.rateRefresh.uiNumerator as u64,
+        ))
+    } else {
+        Ok(interval)
+    }
+}
+
+#[inline]
+fn retrieve_duration(counts: u64, ticks_per_second: u64) -> Duration {
+    let ticks_per_microsecond = ticks_per_second / 1_000_000;
+    Duration::from_micros(counts / ticks_per_microsecond)
+}

third_party/gpui/src/platform/windows/wrapper.rs

@@ -0,0 +1,53 @@
+use std::ops::Deref;
+
+use windows::Win32::{Foundation::HWND, UI::WindowsAndMessaging::HCURSOR};
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct SafeCursor {
+    raw: HCURSOR,
+}
+
+unsafe impl Send for SafeCursor {}
+unsafe impl Sync for SafeCursor {}
+
+impl From<HCURSOR> for SafeCursor {
+    fn from(value: HCURSOR) -> Self {
+        SafeCursor { raw: value }
+    }
+}
+
+impl Deref for SafeCursor {
+    type Target = HCURSOR;
+
+    fn deref(&self) -> &Self::Target {
+        &self.raw
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct SafeHwnd {
+    raw: HWND,
+}
+
+impl SafeHwnd {
+    pub(crate) fn as_raw(&self) -> HWND {
+        self.raw
+    }
+}
+
+unsafe impl Send for SafeHwnd {}
+unsafe impl Sync for SafeHwnd {}
+
+impl From<HWND> for SafeHwnd {
+    fn from(value: HWND) -> Self {
+        SafeHwnd { raw: value }
+    }
+}
+
+impl Deref for SafeHwnd {
+    type Target = HWND;
+
+    fn deref(&self) -> &Self::Target {
+        &self.raw
+    }
+}